revert

.github/workflows/rust-ci.yml

@@ -62,26 +62,6 @@ jobs:
           components: rustfmt
       - name: cargo fmt
         run: cargo fmt -- --config imports_granularity=Item --check
-      - name: Verify codegen for mcp-types
-        run: ./mcp-types/check_lib_rs.py
-
-  cargo_shear:
-    name: cargo shear
-    runs-on: ubuntu-24.04
-    needs: changed
-    if: ${{ needs.changed.outputs.codex == 'true' || needs.changed.outputs.workflows == 'true' || github.event_name == 'push' }}
-    defaults:
-      run:
-        working-directory: codex-rs
-    steps:
-      - uses: actions/checkout@v5
-      - uses: dtolnay/rust-toolchain@1.89
-      - uses: taiki-e/install-action@0c5db7f7f897c03b771660e91d065338615679f4 # v2
-        with:
-          tool: cargo-shear
-          version: 1.5.1
-      - name: cargo shear
-        run: cargo shear
 
   # --- CI to validate on different os/targets --------------------------------
   lint_build_test:
@@ -180,17 +160,12 @@ jobs:
           find . -name Cargo.toml -mindepth 2 -maxdepth 2 -print0 \
             | xargs -0 -n1 -I{} bash -c 'cd "$(dirname "{}")" && cargo check --profile ${{ matrix.profile }}'
 
-      - uses: taiki-e/install-action@0c5db7f7f897c03b771660e91d065338615679f4 # v2
-        with:
-          tool: nextest
-          version: 0.9.103
-
-      - name: tests
+      - name: cargo test
         id: test
-        # Tests take too long for release builds to run them on every PR.
+        # `cargo test` takes too long for release builds to run them on every PR
         if: ${{ matrix.profile != 'release' }}
         continue-on-error: true
-        run: cargo nextest run --all-features --no-fail-fast --target ${{ matrix.target }}
+        run: cargo test --all-features --target ${{ matrix.target }} --profile ${{ matrix.profile }}
         env:
           RUST_BACKTRACE: 1
 
@@ -207,7 +182,7 @@ jobs:
   # --- Gatherer job that you mark as the ONLY required status -----------------
   results:
     name: CI results (required)
-    needs: [changed, general, cargo_shear, lint_build_test]
+    needs: [changed, general, lint_build_test]
     if: always()
     runs-on: ubuntu-24.04
     steps:
@@ -215,7 +190,6 @@ jobs:
         shell: bash
         run: |
           echo "general: ${{ needs.general.result }}"
-          echo "shear  : ${{ needs.cargo_shear.result }}"
           echo "matrix : ${{ needs.lint_build_test.result }}"
 
           # If nothing relevant changed (PR touching only root README, etc.),
@@ -227,5 +201,4 @@ jobs:
 
           # Otherwise require the jobs to have succeeded
           [[ '${{ needs.general.result }}' == 'success' ]] || { echo 'general failed'; exit 1; }
-          [[ '${{ needs.cargo_shear.result }}' == 'success' ]] || { echo 'cargo_shear failed'; exit 1; }
           [[ '${{ needs.lint_build_test.result }}' == 'success' ]] || { echo 'matrix failed'; exit 1; }

.github/workflows/rust-release.yml

@@ -219,22 +219,3 @@ jobs:
         with:
           tag: ${{ github.ref_name }}
           config: .github/dotslash-config.json
-
-  update-branch:
-    name: Update latest-alpha-cli branch
-    permissions:
-      contents: write
-    needs: release
-    runs-on: ubuntu-latest
-
-    steps:
-      - name: Update latest-alpha-cli branch
-        env:
-          GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-        run: |
-          set -euo pipefail
-          gh api \
-            repos/${GITHUB_REPOSITORY}/git/refs/heads/latest-alpha-cli \
-            -X PATCH \
-            -f sha="${GITHUB_SHA}" \
-            -F force=true

codex-rs/Cargo.toml

@@ -34,7 +34,6 @@ rust = {}
 
 [workspace.lints.clippy]
 expect_used = "deny"
-redundant_clone = "deny"
 uninlined_format_args = "deny"
 unwrap_used = "deny"
 

codex-rs/README.md

@@ -35,7 +35,7 @@ npx @modelcontextprotocol/inspector codex mcp
 
 You can enable notifications by configuring a script that is run whenever the agent finishes a turn. The [notify documentation](../docs/config.md#notify) includes a detailed example that explains how to get desktop notifications via [terminal-notifier](https://github.com/julienXX/terminal-notifier) on macOS.
 
-### `codex exec` to run Codex programmatically/non-interactively
+### `codex exec` to run Codex programmatially/non-interactively
 
 To run Codex non-interactively, run `codex exec PROMPT` (you can also pass the prompt via `stdin`) and Codex will work on your task until it decides that it is done and exits. Output is printed to the terminal directly. You can set the `RUST_LOG` environment variable to see more about what's going on.
 

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

@@ -726,15 +726,13 @@ fn compute_replacements(
             line_index = start_idx + pattern.len();
         } else {
             return Err(ApplyPatchError::ComputeReplacements(format!(
-                "Failed to find expected lines in {}:\n{}",
-                path.display(),
-                chunk.old_lines.join("\n"),
+                "Failed to find expected lines {:?} in {}",
+                chunk.old_lines,
+                path.display()
             )));
         }
     }
 
-    replacements.sort_by(|(lhs_idx, _, _), (rhs_idx, _, _)| lhs_idx.cmp(rhs_idx));
-
     Ok(replacements)
 }
 
@@ -1218,33 +1216,6 @@ PATCH"#,
         assert_eq!(contents, "a\nB\nc\nd\nE\nf\ng\n");
     }
 
-    #[test]
-    fn test_pure_addition_chunk_followed_by_removal() {
-        let dir = tempdir().unwrap();
-        let path = dir.path().join("panic.txt");
-        fs::write(&path, "line1\nline2\nline3\n").unwrap();
-        let patch = wrap_patch(&format!(
-            r#"*** Update File: {}
-@@
-+after-context
-+second-line
-@@
- line1
--line2
--line3
-+line2-replacement"#,
-            path.display()
-        ));
-        let mut stdout = Vec::new();
-        let mut stderr = Vec::new();
-        apply_patch(&patch, &mut stdout, &mut stderr).unwrap();
-        let contents = fs::read_to_string(path).unwrap();
-        assert_eq!(
-            contents,
-            "line1\nline2-replacement\nafter-context\nsecond-line\n"
-        );
-    }
-
     /// Ensure that patches authored with ASCII characters can update lines that
     /// contain typographic Unicode punctuation (e.g. EN DASH, NON-BREAKING
     /// HYPHEN). Historically `git apply` succeeds in such scenarios but our

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

@@ -617,7 +617,7 @@ fn test_parse_patch_lenient() {
     assert_eq!(
         parse_patch_text(&patch_text_in_double_quoted_heredoc, ParseMode::Lenient),
         Ok(ApplyPatchArgs {
-            hunks: expected_patch,
+            hunks: expected_patch.clone(),
             patch: patch_text.to_string(),
             workdir: None,
         })
@@ -637,7 +637,7 @@ fn test_parse_patch_lenient() {
         "<<EOF\n*** Begin Patch\n*** Update File: file2.py\nEOF\n".to_string();
     assert_eq!(
         parse_patch_text(&patch_text_with_missing_closing_heredoc, ParseMode::Strict),
-        Err(expected_error)
+        Err(expected_error.clone())
     );
     assert_eq!(
         parse_patch_text(&patch_text_with_missing_closing_heredoc, ParseMode::Lenient),

codex-rs/chatgpt/Cargo.toml

@@ -11,6 +11,8 @@ anyhow = "1"
 clap = { version = "4", features = ["derive"] }
 codex-common = { path = "../common", features = ["cli"] }
 codex-core = { path = "../core" }
+codex-protocol = { path = "../protocol" }
+reqwest = { version = "0.12", features = ["json", "stream"] }
 serde = { version = "1", features = ["derive"] }
 serde_json = "1"
 tokio = { version = "1", features = ["full"] }

codex-rs/chatgpt/src/apply_command.rs

@@ -31,7 +31,7 @@ pub async fn run_apply_command(
         ConfigOverrides::default(),
     )?;
 
-    init_chatgpt_token_from_auth(&config.codex_home).await?;
+    init_chatgpt_token_from_auth(&config.codex_home, &config.responses_originator_header).await?;
 
     let task_response = get_task(&config, apply_cli.task_id).await?;
     apply_diff_from_task(task_response, cwd).await

codex-rs/chatgpt/src/chatgpt_client.rs

@@ -13,10 +13,10 @@ pub(crate) async fn chatgpt_get_request<T: DeserializeOwned>(
     path: String,
 ) -> anyhow::Result<T> {
     let chatgpt_base_url = &config.chatgpt_base_url;
-    init_chatgpt_token_from_auth(&config.codex_home).await?;
+    init_chatgpt_token_from_auth(&config.codex_home, &config.responses_originator_header).await?;
 
     // Make direct HTTP request to ChatGPT backend API with the token
-    let client = create_client();
+    let client = create_client(&config.responses_originator_header);
     let url = format!("{chatgpt_base_url}{path}");
 
     let token =

codex-rs/chatgpt/src/chatgpt_token.rs

@@ -1,4 +1,5 @@
 use codex_core::CodexAuth;
+use codex_protocol::mcp_protocol::AuthMode;
 use std::path::Path;
 use std::sync::LazyLock;
 use std::sync::RwLock;
@@ -18,8 +19,11 @@ pub fn set_chatgpt_token_data(value: TokenData) {
 }
 
 /// Initialize the ChatGPT token from auth.json file
-pub async fn init_chatgpt_token_from_auth(codex_home: &Path) -> std::io::Result<()> {
-    let auth = CodexAuth::from_codex_home(codex_home)?;
+pub async fn init_chatgpt_token_from_auth(
+    codex_home: &Path,
+    originator: &str,
+) -> std::io::Result<()> {
+    let auth = CodexAuth::from_codex_home(codex_home, AuthMode::ChatGPT, originator)?;
     if let Some(auth) = auth {
         let token_data = auth.get_token_data().await?;
         set_chatgpt_token_data(token_data);

codex-rs/cli/src/login.rs

@@ -1,6 +1,7 @@
 use codex_common::CliConfigOverrides;
 use codex_core::CodexAuth;
 use codex_core::auth::CLIENT_ID;
+use codex_core::auth::OPENAI_API_KEY_ENV_VAR;
 use codex_core::auth::login_with_api_key;
 use codex_core::auth::logout;
 use codex_core::config::Config;
@@ -8,10 +9,11 @@ use codex_core::config::ConfigOverrides;
 use codex_login::ServerOptions;
 use codex_login::run_login_server;
 use codex_protocol::mcp_protocol::AuthMode;
+use std::env;
 use std::path::PathBuf;
 
-pub async fn login_with_chatgpt(codex_home: PathBuf) -> std::io::Result<()> {
-    let opts = ServerOptions::new(codex_home, CLIENT_ID.to_string());
+pub async fn login_with_chatgpt(codex_home: PathBuf, originator: String) -> std::io::Result<()> {
+    let opts = ServerOptions::new(codex_home, CLIENT_ID.to_string(), originator);
     let server = run_login_server(opts)?;
 
     eprintln!(
@@ -25,7 +27,12 @@ pub async fn login_with_chatgpt(codex_home: PathBuf) -> std::io::Result<()> {
 pub async fn run_login_with_chatgpt(cli_config_overrides: CliConfigOverrides) -> ! {
     let config = load_config_or_exit(cli_config_overrides);
 
-    match login_with_chatgpt(config.codex_home).await {
+    match login_with_chatgpt(
+        config.codex_home,
+        config.responses_originator_header.clone(),
+    )
+    .await
+    {
         Ok(_) => {
             eprintln!("Successfully logged in");
             std::process::exit(0);
@@ -55,25 +62,26 @@ pub async fn run_login_with_api_key(
     }
 }
 
-/// Login using the OAuth device code flow.
-///
-/// Currently not implemented; exits with a clear message.
-pub async fn run_login_with_device_code(cli_config_overrides: CliConfigOverrides) -> ! {
-    // Parse and load config for consistency with other login commands.
-    let _config = load_config_or_exit(cli_config_overrides);
-
-    eprintln!("Device code login is not supported yet.");
-    std::process::exit(2);
-}
-
 pub async fn run_login_status(cli_config_overrides: CliConfigOverrides) -> ! {
     let config = load_config_or_exit(cli_config_overrides);
 
-    match CodexAuth::from_codex_home(&config.codex_home) {
+    match CodexAuth::from_codex_home(
+        &config.codex_home,
+        config.preferred_auth_method,
+        &config.responses_originator_header,
+    ) {
         Ok(Some(auth)) => match auth.mode {
             AuthMode::ApiKey => match auth.get_token().await {
                 Ok(api_key) => {
                     eprintln!("Logged in using an API key - {}", safe_format_key(&api_key));
+
+                    if let Ok(env_api_key) = env::var(OPENAI_API_KEY_ENV_VAR)
+                        && env_api_key == api_key
+                    {
+                        eprintln!(
+                            "   API loaded from OPENAI_API_KEY environment variable or .env file"
+                        );
+                    }
                     std::process::exit(0);
                 }
                 Err(e) => {

codex-rs/cli/src/main.rs

@@ -10,7 +10,6 @@ use codex_cli::SeatbeltCommand;
 use codex_cli::login::run_login_status;
 use codex_cli::login::run_login_with_api_key;
 use codex_cli::login::run_login_with_chatgpt;
-use codex_cli::login::run_login_with_device_code;
 use codex_cli::login::run_logout;
 use codex_cli::proto;
 use codex_common::CliConfigOverrides;
@@ -109,10 +108,6 @@ struct LoginCommand {
     #[arg(long = "api-key", value_name = "API_KEY")]
     api_key: Option<String>,
 
-    /// Use device code flow (not yet supported)
-    #[arg(long = "use-device-code")]
-    use_device_code: bool,
-
     #[command(subcommand)]
     action: Option<LoginSubcommand>,
 }
@@ -173,9 +168,7 @@ async fn cli_main(codex_linux_sandbox_exe: Option<PathBuf>) -> anyhow::Result<()
                     run_login_status(login_cli.config_overrides).await;
                 }
                 None => {
-                    if login_cli.use_device_code {
-                        run_login_with_device_code(login_cli.config_overrides).await;
-                    } else if let Some(api_key) = login_cli.api_key {
+                    if let Some(api_key) = login_cli.api_key {
                         run_login_with_api_key(login_cli.config_overrides, api_key).await;
                     } else {
                         run_login_with_chatgpt(login_cli.config_overrides).await;

codex-rs/cli/src/proto.rs

@@ -37,8 +37,11 @@ pub async fn run_main(opts: ProtoCli) -> anyhow::Result<()> {
 
     let config = Config::load_with_cli_overrides(overrides_vec, ConfigOverrides::default())?;
     // Use conversation_manager API to start a conversation
-    let conversation_manager =
-        ConversationManager::new(AuthManager::shared(config.codex_home.clone()));
+    let conversation_manager = ConversationManager::new(AuthManager::shared(
+        config.codex_home.clone(),
+        config.preferred_auth_method,
+        config.responses_originator_header.clone(),
+    ));
     let NewConversation {
         conversation_id: _,
         conversation,

codex-rs/common/src/model_presets.rs

@@ -49,13 +49,6 @@ pub fn builtin_model_presets() -> &'static [ModelPreset] {
             model: "gpt-5",
             effort: ReasoningEffort::High,
         },
-        ModelPreset {
-            id: "gpt-5-high-new",
-            label: "gpt-5 high new",
-            description: "— our latest release tuned to rely on the model's built-in reasoning defaults",
-            model: "gpt-5-high-new",
-            effort: ReasoningEffort::Medium,
-        },
     ];
     PRESETS
 }

codex-rs/core/Cargo.toml

@@ -26,12 +26,14 @@ eventsource-stream = "0.2.3"
 futures = "0.3"
 libc = "0.2.175"
 mcp-types = { path = "../mcp-types" }
+mime_guess = "2.0"
 os_info = "3.12.0"
 portable-pty = "0.9.0"
 rand = "0.9"
 regex-lite = "0.1.7"
 reqwest = { version = "0.12", features = ["json", "stream"] }
 serde = { version = "1", features = ["derive"] }
+serde_bytes = "0.11"
 serde_json = "1"
 sha1 = "0.10.6"
 shlex = "1.3.0"
@@ -54,7 +56,7 @@ tracing = { version = "0.1.41", features = ["log"] }
 tree-sitter = "0.25.9"
 tree-sitter-bash = "0.25.0"
 uuid = { version = "1", features = ["serde", "v4"] }
-which = "6"
+whoami = "1.6.1"
 wildmatch = "2.4.0"
 
 
@@ -70,6 +72,9 @@ openssl-sys = { version = "*", features = ["vendored"] }
 [target.aarch64-unknown-linux-musl.dependencies]
 openssl-sys = { version = "*", features = ["vendored"] }
 
+[target.'cfg(target_os = "windows")'.dependencies]
+which = "6"
+
 [dev-dependencies]
 assert_cmd = "2"
 core_test_support = { path = "tests/common" }
@@ -80,6 +85,3 @@ tempfile = "3"
 tokio-test = "0.4"
 walkdir = "2.5.0"
 wiremock = "0.6"
-
-[package.metadata.cargo-shear]
-ignored = ["openssl-sys"]

codex-rs/core/src/auth.rs

@@ -17,7 +17,6 @@ use std::time::Duration;
 
 use codex_protocol::mcp_protocol::AuthMode;
 
-use crate::token_data::PlanType;
 use crate::token_data::TokenData;
 use crate::token_data::parse_id_token;
 
@@ -71,9 +70,14 @@ impl CodexAuth {
         Ok(access)
     }
 
-    /// Loads the available auth information from the auth.json.
-    pub fn from_codex_home(codex_home: &Path) -> std::io::Result<Option<CodexAuth>> {
-        load_auth(codex_home)
+    /// Loads the available auth information from the auth.json or
+    /// OPENAI_API_KEY environment variable.
+    pub fn from_codex_home(
+        codex_home: &Path,
+        preferred_auth_method: AuthMode,
+        originator: &str,
+    ) -> std::io::Result<Option<CodexAuth>> {
+        load_auth(codex_home, true, preferred_auth_method, originator)
     }
 
     pub async fn get_token_data(&self) -> Result<TokenData, std::io::Error> {
@@ -132,12 +136,13 @@ impl CodexAuth {
     }
 
     pub fn get_account_id(&self) -> Option<String> {
-        self.get_current_token_data().and_then(|t| t.account_id)
+        self.get_current_token_data()
+            .and_then(|t| t.account_id.clone())
     }
 
-    pub(crate) fn get_plan_type(&self) -> Option<PlanType> {
+    pub fn get_plan_type(&self) -> Option<String> {
         self.get_current_token_data()
-            .and_then(|t| t.id_token.chatgpt_plan_type)
+            .and_then(|t| t.id_token.chatgpt_plan_type.as_ref().map(|p| p.as_string()))
     }
 
     fn get_current_auth_json(&self) -> Option<AuthDotJson> {
@@ -146,7 +151,7 @@ impl CodexAuth {
     }
 
     fn get_current_token_data(&self) -> Option<TokenData> {
-        self.get_current_auth_json().and_then(|t| t.tokens)
+        self.get_current_auth_json().and_then(|t| t.tokens.clone())
     }
 
     /// Consider this private to integration tests.
@@ -168,7 +173,7 @@ impl CodexAuth {
             mode: AuthMode::ChatGPT,
             auth_file: PathBuf::new(),
             auth_dot_json,
-            client: crate::default_client::create_client(),
+            client: crate::default_client::create_client("codex_cli_rs"),
         }
     }
 
@@ -183,17 +188,19 @@ impl CodexAuth {
     }
 
     pub fn from_api_key(api_key: &str) -> Self {
-        Self::from_api_key_with_client(api_key, crate::default_client::create_client())
+        Self::from_api_key_with_client(
+            api_key,
+            crate::default_client::create_client(crate::default_client::DEFAULT_ORIGINATOR),
+        )
     }
 }
 
 pub const OPENAI_API_KEY_ENV_VAR: &str = "OPENAI_API_KEY";
 
-pub fn read_openai_api_key_from_env() -> Option<String> {
+fn read_openai_api_key_from_env() -> Option<String> {
     env::var(OPENAI_API_KEY_ENV_VAR)
         .ok()
-        .map(|value| value.trim().to_string())
-        .filter(|value| !value.is_empty())
+        .filter(|s| !s.is_empty())
 }
 
 pub fn get_auth_file(codex_home: &Path) -> PathBuf {
@@ -211,7 +218,7 @@ pub fn logout(codex_home: &Path) -> std::io::Result<bool> {
     }
 }
 
-/// Writes an `auth.json` that contains only the API key.
+/// Writes an `auth.json` that contains only the API key. Intended for CLI use.
 pub fn login_with_api_key(codex_home: &Path, api_key: &str) -> std::io::Result<()> {
     let auth_dot_json = AuthDotJson {
         openai_api_key: Some(api_key.to_string()),
@@ -221,11 +228,29 @@ pub fn login_with_api_key(codex_home: &Path, api_key: &str) -> std::io::Result<(
     write_auth_json(&get_auth_file(codex_home), &auth_dot_json)
 }
 
-fn load_auth(codex_home: &Path) -> std::io::Result<Option<CodexAuth>> {
+fn load_auth(
+    codex_home: &Path,
+    include_env_var: bool,
+    preferred_auth_method: AuthMode,
+    originator: &str,
+) -> std::io::Result<Option<CodexAuth>> {
+    // First, check to see if there is a valid auth.json file. If not, we fall
+    // back to AuthMode::ApiKey using the OPENAI_API_KEY environment variable
+    // (if it is set).
     let auth_file = get_auth_file(codex_home);
-    let client = crate::default_client::create_client();
+    let client = crate::default_client::create_client(originator);
     let auth_dot_json = match try_read_auth_json(&auth_file) {
         Ok(auth) => auth,
+        // If auth.json does not exist, try to read the OPENAI_API_KEY from the
+        // environment variable.
+        Err(e) if e.kind() == std::io::ErrorKind::NotFound && include_env_var => {
+            return match read_openai_api_key_from_env() {
+                Some(api_key) => Ok(Some(CodexAuth::from_api_key_with_client(&api_key, client))),
+                None => Ok(None),
+            };
+        }
+        // Though if auth.json exists but is malformed, do not fall back to the
+        // env var because the user may be expecting to use AuthMode::ChatGPT.
         Err(e) => {
             return Err(e);
         }
@@ -237,11 +262,32 @@ fn load_auth(codex_home: &Path) -> std::io::Result<Option<CodexAuth>> {
         last_refresh,
     } = auth_dot_json;
 
-    // Prefer AuthMode.ApiKey if it's set in the auth.json.
+    // If the auth.json has an API key AND does not appear to be on a plan that
+    // should prefer AuthMode::ChatGPT, use AuthMode::ApiKey.
     if let Some(api_key) = &auth_json_api_key {
-        return Ok(Some(CodexAuth::from_api_key_with_client(api_key, client)));
+        // Should any of these be AuthMode::ChatGPT with the api_key set?
+        // Does AuthMode::ChatGPT indicate that there is an auth.json that is
+        // "refreshable" even if we are using the API key for auth?
+        match &tokens {
+            Some(tokens) => {
+                if tokens.should_use_api_key(preferred_auth_method, tokens.is_openai_email()) {
+                    return Ok(Some(CodexAuth::from_api_key_with_client(api_key, client)));
+                } else {
+                    // Ignore the API key and fall through to ChatGPT auth.
+                }
+            }
+            None => {
+                // We have an API key but no tokens in the auth.json file.
+                // Perhaps the user ran `codex login --api-key <KEY>` or updated
+                // auth.json by hand. Either way, let's assume they are trying
+                // to use their API key.
+                return Ok(Some(CodexAuth::from_api_key_with_client(api_key, client)));
+            }
+        }
     }
 
+    // For the AuthMode::ChatGPT variant, perhaps neither api_key nor
+    // openai_api_key should exist?
     Ok(Some(CodexAuth {
         api_key: None,
         mode: AuthMode::ChatGPT,
@@ -291,10 +337,10 @@ async fn update_tokens(
     let tokens = auth_dot_json.tokens.get_or_insert_with(TokenData::default);
     tokens.id_token = parse_id_token(&id_token).map_err(std::io::Error::other)?;
     if let Some(access_token) = access_token {
-        tokens.access_token = access_token;
+        tokens.access_token = access_token.to_string();
     }
     if let Some(refresh_token) = refresh_token {
-        tokens.refresh_token = refresh_token;
+        tokens.refresh_token = refresh_token.to_string();
     }
     auth_dot_json.last_refresh = Some(Utc::now());
     write_auth_json(auth_file, &auth_dot_json)?;
@@ -371,6 +417,7 @@ use std::sync::RwLock;
 /// Internal cached auth state.
 #[derive(Clone, Debug)]
 struct CachedAuth {
+    preferred_auth_mode: AuthMode,
     auth: Option<CodexAuth>,
 }
 
@@ -426,7 +473,9 @@ mod tests {
             auth_dot_json,
             auth_file: _,
             ..
-        } = super::load_auth(codex_home.path()).unwrap().unwrap();
+        } = super::load_auth(codex_home.path(), false, AuthMode::ChatGPT, "codex_cli_rs")
+            .unwrap()
+            .unwrap();
         assert_eq!(None, api_key);
         assert_eq!(AuthMode::ChatGPT, mode);
 
@@ -455,6 +504,88 @@ mod tests {
         )
     }
 
+    /// Even if the OPENAI_API_KEY is set in auth.json, if the plan is not in
+    /// [`TokenData::is_plan_that_should_use_api_key`], it should use
+    /// [`AuthMode::ChatGPT`].
+    #[tokio::test]
+    async fn pro_account_with_api_key_still_uses_chatgpt_auth() {
+        let codex_home = tempdir().unwrap();
+        let fake_jwt = write_auth_file(
+            AuthFileParams {
+                openai_api_key: Some("sk-test-key".to_string()),
+                chatgpt_plan_type: "pro".to_string(),
+            },
+            codex_home.path(),
+        )
+        .expect("failed to write auth file");
+
+        let CodexAuth {
+            api_key,
+            mode,
+            auth_dot_json,
+            auth_file: _,
+            ..
+        } = super::load_auth(codex_home.path(), false, AuthMode::ChatGPT, "codex_cli_rs")
+            .unwrap()
+            .unwrap();
+        assert_eq!(None, api_key);
+        assert_eq!(AuthMode::ChatGPT, mode);
+
+        let guard = auth_dot_json.lock().unwrap();
+        let auth_dot_json = guard.as_ref().expect("AuthDotJson should exist");
+        assert_eq!(
+            &AuthDotJson {
+                openai_api_key: None,
+                tokens: Some(TokenData {
+                    id_token: IdTokenInfo {
+                        email: Some("user@example.com".to_string()),
+                        chatgpt_plan_type: Some(PlanType::Known(KnownPlan::Pro)),
+                        raw_jwt: fake_jwt,
+                    },
+                    access_token: "test-access-token".to_string(),
+                    refresh_token: "test-refresh-token".to_string(),
+                    account_id: None,
+                }),
+                last_refresh: Some(
+                    DateTime::parse_from_rfc3339(LAST_REFRESH)
+                        .unwrap()
+                        .with_timezone(&Utc)
+                ),
+            },
+            auth_dot_json
+        )
+    }
+
+    /// If the OPENAI_API_KEY is set in auth.json and it is an enterprise
+    /// account, then it should use [`AuthMode::ApiKey`].
+    #[tokio::test]
+    async fn enterprise_account_with_api_key_uses_apikey_auth() {
+        let codex_home = tempdir().unwrap();
+        write_auth_file(
+            AuthFileParams {
+                openai_api_key: Some("sk-test-key".to_string()),
+                chatgpt_plan_type: "enterprise".to_string(),
+            },
+            codex_home.path(),
+        )
+        .expect("failed to write auth file");
+
+        let CodexAuth {
+            api_key,
+            mode,
+            auth_dot_json,
+            auth_file: _,
+            ..
+        } = super::load_auth(codex_home.path(), false, AuthMode::ChatGPT, "codex_cli_rs")
+            .unwrap()
+            .unwrap();
+        assert_eq!(Some("sk-test-key".to_string()), api_key);
+        assert_eq!(AuthMode::ApiKey, mode);
+
+        let guard = auth_dot_json.lock().expect("should unwrap");
+        assert!(guard.is_none(), "auth_dot_json should be None");
+    }
+
     #[tokio::test]
     async fn loads_api_key_from_auth_json() {
         let dir = tempdir().unwrap();
@@ -465,7 +596,9 @@ mod tests {
         )
         .unwrap();
 
-        let auth = super::load_auth(dir.path()).unwrap().unwrap();
+        let auth = super::load_auth(dir.path(), false, AuthMode::ChatGPT, "codex_cli_rs")
+            .unwrap()
+            .unwrap();
         assert_eq!(auth.mode, AuthMode::ApiKey);
         assert_eq!(auth.api_key, Some("sk-test-key".to_string()));
 
@@ -547,6 +680,7 @@ mod tests {
 #[derive(Debug)]
 pub struct AuthManager {
     codex_home: PathBuf,
+    originator: String,
     inner: RwLock<CachedAuth>,
 }
 
@@ -555,19 +689,30 @@ impl AuthManager {
     /// preferred auth method. Errors loading auth are swallowed; `auth()` will
     /// simply return `None` in that case so callers can treat it as an
     /// unauthenticated state.
-    pub fn new(codex_home: PathBuf) -> Self {
-        let auth = CodexAuth::from_codex_home(&codex_home).ok().flatten();
+    pub fn new(codex_home: PathBuf, preferred_auth_mode: AuthMode, originator: String) -> Self {
+        let auth = CodexAuth::from_codex_home(&codex_home, preferred_auth_mode, &originator)
+            .ok()
+            .flatten();
         Self {
             codex_home,
-            inner: RwLock::new(CachedAuth { auth }),
+            originator,
+            inner: RwLock::new(CachedAuth {
+                preferred_auth_mode,
+                auth,
+            }),
         }
     }
 
     /// Create an AuthManager with a specific CodexAuth, for testing only.
     pub fn from_auth_for_testing(auth: CodexAuth) -> Arc<Self> {
-        let cached = CachedAuth { auth: Some(auth) };
+        let preferred_auth_mode = auth.mode;
+        let cached = CachedAuth {
+            preferred_auth_mode,
+            auth: Some(auth),
+        };
         Arc::new(Self {
             codex_home: PathBuf::new(),
+            originator: "codex_cli_rs".to_string(),
             inner: RwLock::new(cached),
         })
     }
@@ -577,10 +722,21 @@ impl AuthManager {
         self.inner.read().ok().and_then(|c| c.auth.clone())
     }
 
-    /// Force a reload of the auth information from auth.json. Returns
+    /// Preferred auth method used when (re)loading.
+    pub fn preferred_auth_method(&self) -> AuthMode {
+        self.inner
+            .read()
+            .map(|c| c.preferred_auth_mode)
+            .unwrap_or(AuthMode::ApiKey)
+    }
+
+    /// Force a reload using the existing preferred auth method. Returns
     /// whether the auth value changed.
     pub fn reload(&self) -> bool {
-        let new_auth = CodexAuth::from_codex_home(&self.codex_home).ok().flatten();
+        let preferred = self.preferred_auth_method();
+        let new_auth = CodexAuth::from_codex_home(&self.codex_home, preferred, &self.originator)
+            .ok()
+            .flatten();
         if let Ok(mut guard) = self.inner.write() {
             let changed = !AuthManager::auths_equal(&guard.auth, &new_auth);
             guard.auth = new_auth;
@@ -599,8 +755,12 @@ impl AuthManager {
     }
 
     /// Convenience constructor returning an `Arc` wrapper.
-    pub fn shared(codex_home: PathBuf) -> Arc<Self> {
-        Arc::new(Self::new(codex_home))
+    pub fn shared(
+        codex_home: PathBuf,
+        preferred_auth_mode: AuthMode,
+        originator: String,
+    ) -> Arc<Self> {
+        Arc::new(Self::new(codex_home, preferred_auth_mode, originator))
     }
 
     /// Attempt to refresh the current auth token (if any). On success, reload

codex-rs/core/src/client.rs

@@ -41,7 +41,6 @@ use crate::model_provider_info::WireApi;
 use crate::openai_model_info::get_model_info;
 use crate::openai_tools::create_tools_json_for_responses_api;
 use crate::protocol::TokenUsage;
-use crate::token_data::PlanType;
 use crate::util::backoff;
 use codex_protocol::config_types::ReasoningEffort as ReasoningEffortConfig;
 use codex_protocol::config_types::ReasoningSummary as ReasoningSummaryConfig;
@@ -61,7 +60,7 @@ struct Error {
     message: Option<String>,
 
     // Optional fields available on "usage_limit_reached" and "usage_not_included" errors
-    plan_type: Option<PlanType>,
+    plan_type: Option<String>,
     resets_in_seconds: Option<u64>,
 }
 
@@ -85,7 +84,7 @@ impl ModelClient {
         summary: ReasoningSummaryConfig,
         conversation_id: ConversationId,
     ) -> Self {
-        let client = create_client();
+        let client = create_client(&config.responses_originator_header);
 
         Self {
             config,
@@ -305,7 +304,7 @@ impl ModelClient {
                                 // token.
                                 let plan_type = error
                                     .plan_type
-                                    .or_else(|| auth.as_ref().and_then(|a| a.get_plan_type()));
+                                    .or_else(|| auth.and_then(|a| a.get_plan_type()));
                                 let resets_in_seconds = error.resets_in_seconds;
                                 return Err(CodexErr::UsageLimitReached(UsageLimitReachedError {
                                     plan_type,
@@ -1038,37 +1037,4 @@ mod tests {
         let delay = try_parse_retry_after(&err);
         assert_eq!(delay, Some(Duration::from_secs_f64(1.898)));
     }
-
-    #[test]
-    fn error_response_deserializes_old_schema_known_plan_type_and_serializes_back() {
-        use crate::token_data::KnownPlan;
-        use crate::token_data::PlanType;
-
-        let json = r#"{"error":{"type":"usage_limit_reached","plan_type":"pro","resets_in_seconds":3600}}"#;
-        let resp: ErrorResponse =
-            serde_json::from_str(json).expect("should deserialize old schema");
-
-        assert!(matches!(
-            resp.error.plan_type,
-            Some(PlanType::Known(KnownPlan::Pro))
-        ));
-
-        let plan_json = serde_json::to_string(&resp.error.plan_type).expect("serialize plan_type");
-        assert_eq!(plan_json, "\"pro\"");
-    }
-
-    #[test]
-    fn error_response_deserializes_old_schema_unknown_plan_type_and_serializes_back() {
-        use crate::token_data::PlanType;
-
-        let json =
-            r#"{"error":{"type":"usage_limit_reached","plan_type":"vip","resets_in_seconds":60}}"#;
-        let resp: ErrorResponse =
-            serde_json::from_str(json).expect("should deserialize old schema");
-
-        assert!(matches!(resp.error.plan_type, Some(PlanType::Unknown(ref s)) if s == "vip"));
-
-        let plan_json = serde_json::to_string(&resp.error.plan_type).expect("serialize plan_type");
-        assert_eq!(plan_json, "\"vip\"");
-    }
 }

codex-rs/core/src/codex.rs

@@ -9,26 +9,21 @@ use std::sync::atomic::AtomicU64;
 use std::time::Duration;
 
 use crate::AuthManager;
-use crate::config_edit::CONFIG_KEY_EFFORT;
-use crate::config_edit::CONFIG_KEY_MODEL;
-use crate::config_edit::persist_non_null_overrides;
 use crate::event_mapping::map_response_item_to_event_messages;
+use crate::rollout::RolloutItem;
+use crate::rollout::recorder::RolloutItemSliceExt;
 use async_channel::Receiver;
 use async_channel::Sender;
 use codex_apply_patch::ApplyPatchAction;
 use codex_apply_patch::MaybeApplyPatchVerified;
 use codex_apply_patch::maybe_parse_apply_patch_verified;
 use codex_protocol::mcp_protocol::ConversationId;
-use codex_protocol::protocol::CompactedItem;
 use codex_protocol::protocol::ConversationPathResponseEvent;
-use codex_protocol::protocol::RolloutItem;
 use codex_protocol::protocol::TaskStartedEvent;
 use codex_protocol::protocol::TurnAbortReason;
 use codex_protocol::protocol::TurnAbortedEvent;
-use codex_protocol::protocol::TurnContextItem;
 use futures::prelude::*;
 use mcp_types::CallToolResult;
-use serde::Deserialize;
 use serde::Serialize;
 use serde_json;
 use tokio::sync::oneshot;
@@ -51,6 +46,7 @@ use crate::client_common::ResponseEvent;
 use crate::config::Config;
 use crate::config_types::ShellEnvironmentPolicy;
 use crate::conversation_history::ConversationHistory;
+use crate::conversation_manager::InitialHistory;
 use crate::environment_context::EnvironmentContext;
 use crate::error::CodexErr;
 use crate::error::Result as CodexResult;
@@ -109,13 +105,11 @@ use crate::protocol::TokenUsageInfo;
 use crate::protocol::TurnDiffEvent;
 use crate::protocol::WebSearchBeginEvent;
 use crate::rollout::RolloutRecorder;
-use crate::rollout::RolloutRecorderParams;
 use crate::safety::SafetyCheck;
 use crate::safety::assess_command_safety;
 use crate::safety::assess_safety_for_untrusted_command;
 use crate::shell;
 use crate::turn_diff_tracker::TurnDiffTracker;
-use crate::unified_exec::UnifiedExecSessionManager;
 use crate::user_instructions::UserInstructions;
 use crate::user_notification::UserNotification;
 use crate::util::backoff;
@@ -128,7 +122,6 @@ use codex_protocol::models::LocalShellAction;
 use codex_protocol::models::ResponseInputItem;
 use codex_protocol::models::ResponseItem;
 use codex_protocol::models::ShellToolCallParams;
-use codex_protocol::protocol::InitialHistory;
 
 // A convenience extension trait for acquiring mutex locks where poisoning is
 // unrecoverable and should abort the program. This avoids scattered `.unwrap()`
@@ -214,7 +207,12 @@ impl Codex {
         let conversation_id = session.conversation_id;
 
         // This task will run until Op::Shutdown is received.
-        tokio::spawn(submission_loop(session, turn_context, config, rx_sub));
+        tokio::spawn(submission_loop(
+            session.clone(),
+            turn_context,
+            config,
+            rx_sub,
+        ));
         let codex = Codex {
             next_id: AtomicU64::new(0),
             tx_sub,
@@ -279,7 +277,6 @@ pub(crate) struct Session {
     /// Manager for external MCP servers/tools.
     mcp_connection_manager: McpConnectionManager,
     session_manager: ExecSessionManager,
-    unified_exec_manager: UnifiedExecSessionManager,
 
     /// External notifier command (will be passed as args to exec()). When
     /// `None` this feature is disabled.
@@ -380,18 +377,9 @@ impl Session {
             return Err(anyhow::anyhow!("cwd is not absolute: {cwd:?}"));
         }
 
-        let (conversation_id, rollout_params) = match &initial_history {
-            InitialHistory::New | InitialHistory::Forked(_) => {
-                let conversation_id = ConversationId::default();
-                (
-                    conversation_id,
-                    RolloutRecorderParams::new(conversation_id, user_instructions.clone()),
-                )
-            }
-            InitialHistory::Resumed(resumed_history) => (
-                resumed_history.conversation_id,
-                RolloutRecorderParams::resume(resumed_history.rollout_path.clone()),
-            ),
+        let conversation_id = match &initial_history {
+            InitialHistory::New | InitialHistory::Forked(_) => ConversationId::default(),
+            InitialHistory::Resumed(resumed_history) => resumed_history.conversation_id,
         };
 
         // Error messages to dispatch after SessionConfigured is sent.
@@ -403,7 +391,7 @@ impl Session {
         // - spin up MCP connection manager
         // - perform default shell discovery
         // - load history metadata
-        let rollout_fut = RolloutRecorder::new(&config, rollout_params);
+        let rollout_fut = RolloutRecorder::new(&config, conversation_id, user_instructions.clone());
 
         let mcp_fut = McpConnectionManager::new(config.mcp_servers.clone());
         let default_shell_fut = shell::default_user_shell();
@@ -417,7 +405,6 @@ impl Session {
             error!("failed to initialize rollout recorder: {e:#}");
             anyhow::anyhow!("failed to initialize rollout recorder: {e:#}")
         })?;
-        let rollout_path = rollout_recorder.rollout_path.clone();
         // Create the mutable state for the Session.
         let state = State {
             history: ConversationHistory::new(),
@@ -471,7 +458,6 @@ impl Session {
                 include_web_search_request: config.tools_web_search_request,
                 use_streamable_shell_tool: config.use_experimental_streamable_shell_tool,
                 include_view_image_tool: config.include_view_image_tool,
-                experimental_unified_exec_tool: config.use_experimental_unified_exec_tool,
             }),
             user_instructions,
             base_instructions,
@@ -485,7 +471,6 @@ impl Session {
             tx_event: tx_event.clone(),
             mcp_connection_manager,
             session_manager: ExecSessionManager::default(),
-            unified_exec_manager: UnifiedExecSessionManager::default(),
             notify,
             state: Mutex::new(state),
             rollout: Mutex::new(Some(rollout_recorder)),
@@ -496,9 +481,10 @@ impl Session {
 
         // Dispatch the SessionConfiguredEvent first and then report any errors.
         // If resuming, include converted initial messages in the payload so UIs can render them immediately.
-        let initial_messages = initial_history.get_event_msgs();
-        sess.record_initial_history(&turn_context, initial_history)
-            .await;
+        let initial_messages = Some(
+            sess.apply_initial_history(&turn_context, initial_history.clone())
+                .await,
+        );
 
         let events = std::iter::once(Event {
             id: INITIAL_SUBMIT_ID.to_owned(),
@@ -508,7 +494,6 @@ impl Session {
                 history_log_id,
                 history_entry_count,
                 initial_messages,
-                rollout_path,
             }),
         })
         .chain(post_session_configured_error_events.into_iter());
@@ -536,42 +521,82 @@ impl Session {
         }
     }
 
-    async fn record_initial_history(
+    async fn apply_initial_history(
         &self,
         turn_context: &TurnContext,
         conversation_history: InitialHistory,
-    ) {
+    ) -> Vec<EventMsg> {
         match conversation_history {
-            InitialHistory::New => {
-                // Build and record initial items (user instructions + environment context)
-                let items = self.build_initial_context(turn_context);
-                self.record_conversation_items(&items).await;
+            InitialHistory::New => self.record_initial_history_new(turn_context).await,
+            InitialHistory::Forked(items) => {
+                self.record_conversation_items_internal(&items, true).await;
+                items
+                    .into_iter()
+                    .flat_map(|ri| {
+                        map_response_item_to_event_messages(&ri, self.show_raw_agent_reasoning)
+                    })
+                    .filter(|m| matches!(m, EventMsg::UserMessage(_)))
+                    .collect()
             }
-            InitialHistory::Resumed(_) | InitialHistory::Forked(_) => {
-                let rollout_items = conversation_history.get_rollout_items();
-                let persist = matches!(conversation_history, InitialHistory::Forked(_));
-
-                // Always add response items to conversation history
-                let response_items = conversation_history.get_response_items();
-                if !response_items.is_empty() {
-                    self.record_into_history(&response_items);
-                }
-
-                // If persisting, persist all rollout items as-is (recorder filters)
-                if persist && !rollout_items.is_empty() {
-                    self.persist_rollout_items(&rollout_items).await;
-                }
+            InitialHistory::Resumed(resumed_history) => {
+                self.record_initial_history_resumed(resumed_history.history)
+                    .await
             }
         }
     }
 
-    /// Persist the event to rollout and send it to clients.
+    async fn record_initial_history_new(&self, turn_context: &TurnContext) -> Vec<EventMsg> {
+        // record the initial user instructions and environment context,
+        // regardless of whether we restored items.
+        // TODO: Those items shouldn't be "user messages" IMO. Maybe developer messages.
+        let mut conversation_items = Vec::<ResponseItem>::with_capacity(2);
+        if let Some(user_instructions) = turn_context.user_instructions.as_deref() {
+            conversation_items.push(UserInstructions::new(user_instructions.to_string()).into());
+        }
+        conversation_items.push(ResponseItem::from(EnvironmentContext::new(
+            Some(turn_context.cwd.clone()),
+            Some(turn_context.approval_policy),
+            Some(turn_context.sandbox_policy.clone()),
+            Some(self.user_shell.clone()),
+        )));
+        for item in conversation_items {
+            self.record_conversation_item(item).await;
+        }
+        vec![]
+    }
+
+    async fn record_initial_history_from_items(&self, items: Vec<ResponseItem>) {
+        self.record_conversation_items_internal(&items, false).await;
+    }
+
+    async fn record_initial_history_resumed(&self, items: Vec<RolloutItem>) -> Vec<EventMsg> {
+        // Record transcript (without persisting again)
+        let responses: Vec<ResponseItem> = items.as_slice().get_response_items();
+        if !responses.is_empty() {
+            self.record_conversation_items_internal(&responses, true)
+                .await;
+        }
+
+        items.as_slice().get_events()
+    }
+
+    /// Sends the given event to the client and records it to the rollout (if enabled).
+    /// Any send/record errors are logged and swallowed.
     pub(crate) async fn send_event(&self, event: Event) {
-        // Persist the event into rollout (recorder filters as needed)
-        let rollout_items = vec![RolloutItem::EventMsg(event.msg.clone())];
-        self.persist_rollout_items(&rollout_items).await;
+        let event_to_record = event.clone();
         if let Err(e) = self.tx_event.send(event).await {
-            error!("failed to send tool call event: {e}");
+            error!("failed to send event: {e}");
+        }
+        let recorder = {
+            let guard = self.rollout.lock_unchecked();
+            guard.as_ref().cloned()
+        };
+        if let Some(rec) = recorder
+            && let Err(e) = rec
+                .record_items(crate::rollout::RolloutItem::Event(event_to_record))
+                .await
+        {
+            error!("failed to record rollout event: {e:#}");
         }
     }
 
@@ -659,76 +684,61 @@ impl Session {
         state.approved_commands.insert(cmd);
     }
 
-    /// Records input items: always append to conversation history and
-    /// persist these response items to rollout.
+    /// Records items to both the rollout and the chat completions/ZDR
+    /// transcript, if enabled.
     async fn record_conversation_items(&self, items: &[ResponseItem]) {
-        self.record_into_history(items);
-        self.persist_rollout_response_items(items).await;
+        self.record_conversation_items_internal(items, true).await;
     }
 
-    /// Append ResponseItems to the in-memory conversation history only.
-    fn record_into_history(&self, items: &[ResponseItem]) {
-        self.state
-            .lock_unchecked()
-            .history
-            .record_items(items.iter());
+    async fn record_conversation_item(&self, item: ResponseItem) {
+        let items = [item];
+        self.record_conversation_items_internal(&items, true).await;
     }
 
-    async fn persist_rollout_response_items(&self, items: &[ResponseItem]) {
-        let rollout_items: Vec<RolloutItem> = items
-            .iter()
-            .cloned()
-            .map(RolloutItem::ResponseItem)
-            .collect();
-        self.persist_rollout_items(&rollout_items).await;
-    }
-
-    fn build_initial_context(&self, turn_context: &TurnContext) -> Vec<ResponseItem> {
-        let mut items = Vec::<ResponseItem>::with_capacity(2);
-        if let Some(user_instructions) = turn_context.user_instructions.as_deref() {
-            items.push(UserInstructions::new(user_instructions.to_string()).into());
+    async fn record_conversation_items_internal(&self, items: &[ResponseItem], persist: bool) {
+        debug!("Recording items for conversation: {items:?}");
+        if persist {
+            // Record snapshot of these items into rollout
+            for item in items {
+                self.record_state_snapshot(RolloutItem::ResponseItem(item.clone()))
+                    .await;
+            }
         }
-        items.push(ResponseItem::from(EnvironmentContext::new(
-            Some(turn_context.cwd.clone()),
-            Some(turn_context.approval_policy),
-            Some(turn_context.sandbox_policy.clone()),
-            Some(self.user_shell.clone()),
-        )));
-        items
+
+        self.state.lock_unchecked().history.record_items(items);
     }
 
-    async fn persist_rollout_items(&self, items: &[RolloutItem]) {
+    async fn record_state_snapshot(&self, item: RolloutItem) {
         let recorder = {
             let guard = self.rollout.lock_unchecked();
             guard.as_ref().cloned()
         };
+
         if let Some(rec) = recorder
-            && let Err(e) = rec.record_items(items).await
+            && let Err(e) = rec.record_items(item).await
         {
             error!("failed to record rollout items: {e:#}");
         }
     }
 
-    /// Record a user input item to conversation history and also persist a
-    /// corresponding UserMessage EventMsg to rollout.
-    async fn record_input_and_rollout_usermsg(&self, response_input: &ResponseInputItem) {
-        let response_item: ResponseItem = response_input.clone().into();
-        // Add to conversation history and persist response item to rollout
-        self.record_conversation_items(std::slice::from_ref(&response_item))
-            .await;
+    /// Records a user input into conversation history AND a corresponding UserMessage event in rollout.
+    /// Does not send events to the UI.
+    async fn record_user_input(&self, sub_id: &str, response_item: ResponseItem) {
+        // Record the message/tool input in conversation history/rollout state
+        self.record_conversation_item(response_item.clone()).await;
 
-        // Derive user message events and persist only UserMessage to rollout
-        let msgs =
-            map_response_item_to_event_messages(&response_item, self.show_raw_agent_reasoning);
-        let user_msgs: Vec<RolloutItem> = msgs
-            .into_iter()
-            .filter_map(|m| match m {
-                EventMsg::UserMessage(ev) => Some(RolloutItem::EventMsg(EventMsg::UserMessage(ev))),
-                _ => None,
-            })
-            .collect();
-        if !user_msgs.is_empty() {
-            self.persist_rollout_items(&user_msgs).await;
+        // Derive and record a UserMessage event alongside it in the rollout
+        let user_events =
+            map_response_item_to_event_messages(&response_item, self.show_raw_agent_reasoning)
+                .into_iter()
+                .filter(|m| matches!(m, EventMsg::UserMessage(_)));
+
+        for msg in user_events {
+            let event = Event {
+                id: sub_id.to_string(),
+                msg,
+            };
+            self.record_state_snapshot(RolloutItem::Event(event)).await;
         }
     }
 
@@ -1069,7 +1079,7 @@ impl AgentTask {
                 id: self.sub_id,
                 msg: EventMsg::TurnAborted(TurnAbortedEvent { reason }),
             };
-            let sess = self.sess;
+            let sess = self.sess.clone();
             tokio::spawn(async move {
                 sess.send_event(event).await;
             });
@@ -1105,10 +1115,10 @@ async fn submission_loop(
                 let provider = prev.client.get_provider();
 
                 // Effective model + family
-                let (effective_model, effective_family) = if let Some(ref m) = model {
+                let (effective_model, effective_family) = if let Some(m) = model {
                     let fam =
-                        find_family_for_model(m).unwrap_or_else(|| config.model_family.clone());
-                    (m.clone(), fam)
+                        find_family_for_model(&m).unwrap_or_else(|| config.model_family.clone());
+                    (m, fam)
                 } else {
                     (prev.client.get_model(), prev.client.get_model_family())
                 };
@@ -1151,7 +1161,6 @@ async fn submission_loop(
                     include_web_search_request: config.tools_web_search_request,
                     use_streamable_shell_tool: config.use_experimental_streamable_shell_tool,
                     include_view_image_tool: config.include_view_image_tool,
-                    experimental_unified_exec_tool: config.use_experimental_unified_exec_tool,
                 });
 
                 let new_turn_context = TurnContext {
@@ -1167,31 +1176,14 @@ async fn submission_loop(
 
                 // Install the new persistent context for subsequent tasks/turns.
                 turn_context = Arc::new(new_turn_context);
-
-                // Optionally persist changes to model / effort
-                let effort_str = effort.map(|_| effective_effort.to_string());
-
-                if let Err(e) = persist_non_null_overrides(
-                    &config.codex_home,
-                    config.active_profile.as_deref(),
-                    &[
-                        (&[CONFIG_KEY_MODEL], model.as_deref()),
-                        (&[CONFIG_KEY_EFFORT], effort_str.as_deref()),
-                    ],
-                )
-                .await
-                {
-                    warn!("failed to persist overrides: {e:#}");
-                }
-
                 if cwd.is_some() || approval_policy.is_some() || sandbox_policy.is_some() {
-                    sess.record_conversation_items(&[ResponseItem::from(EnvironmentContext::new(
+                    sess.record_conversation_item(ResponseItem::from(EnvironmentContext::new(
                         cwd,
                         approval_policy,
                         sandbox_policy,
                         // Shell is not configurable from turn to turn
                         None,
-                    ))])
+                    )))
                     .await;
                 }
             }
@@ -1254,8 +1246,6 @@ async fn submission_loop(
                             use_streamable_shell_tool: config
                                 .use_experimental_streamable_shell_tool,
                             include_view_image_tool: config.include_view_image_tool,
-                            experimental_unified_exec_tool: config
-                                .use_experimental_unified_exec_tool,
                         }),
                         user_instructions: turn_context.user_instructions.clone(),
                         base_instructions: turn_context.base_instructions.clone(),
@@ -1296,7 +1286,7 @@ async fn submission_loop(
 
             Op::GetHistoryEntryRequest { offset, log_id } => {
                 let config = config.clone();
-                let sess_clone = sess.clone();
+                let sess_for_spawn = sess.clone();
                 let sub_id = sub.id.clone();
 
                 tokio::spawn(async move {
@@ -1324,7 +1314,7 @@ async fn submission_loop(
                         ),
                     };
 
-                    sess_clone.send_event(event).await;
+                    sess_for_spawn.send_event(event).await;
                 });
             }
             Op::ListMcpTools => {
@@ -1402,29 +1392,23 @@ async fn submission_loop(
                 sess.send_event(event).await;
                 break;
             }
-            Op::GetPath => {
+            Op::GetConversationPath => {
                 let sub_id = sub.id.clone();
-                // Flush rollout writes before returning the path so readers observe a consistent file.
-                let (path, rec_opt) = {
-                    let guard = sess.rollout.lock_unchecked();
-                    match guard.as_ref() {
-                        Some(rec) => (rec.get_rollout_path(), Some(rec.clone())),
-                        None => {
-                            error!("rollout recorder not found");
-                            continue;
-                        }
-                    }
-                };
-                if let Some(rec) = rec_opt
-                    && let Err(e) = rec.flush().await
-                {
-                    warn!("failed to flush rollout recorder before GetHistory: {e}");
+                // Ensure rollout file is flushed so consumers can read it immediately.
+                let rec_opt = { sess.rollout.lock_unchecked().as_ref().cloned() };
+                if let Some(rec) = rec_opt {
+                    let _ = rec.flush().await;
                 }
                 let event = Event {
                     id: sub_id.clone(),
-                    msg: EventMsg::ConversationPath(ConversationPathResponseEvent {
+                    msg: EventMsg::ConversationHistory(ConversationPathResponseEvent {
                         conversation_id: sess.conversation_id,
-                        path,
+                        path: sess
+                            .rollout
+                            .lock_unchecked()
+                            .as_ref()
+                            .map(|r| r.path().to_path_buf())
+                            .unwrap_or_default(),
                     }),
                 };
                 sess.send_event(event).await;
@@ -1459,6 +1443,10 @@ async fn run_task(
     if input.is_empty() {
         return;
     }
+    let initial_input_for_turn: ResponseInputItem = ResponseInputItem::from(input);
+    // Record the user's input and corresponding event into the rollout
+    let user_input_response: ResponseItem = ResponseItem::from(initial_input_for_turn.clone());
+    sess.record_user_input(&sub_id, user_input_response).await;
     let event = Event {
         id: sub_id.clone(),
         msg: EventMsg::TaskStarted(TaskStartedEvent {
@@ -1467,10 +1455,6 @@ async fn run_task(
     };
     sess.send_event(event).await;
 
-    let initial_input_for_turn: ResponseInputItem = ResponseInputItem::from(input);
-    sess.record_input_and_rollout_usermsg(&initial_input_for_turn)
-        .await;
-
     let mut last_agent_message: Option<String> = None;
     // Although from the perspective of codex.rs, TurnDiffTracker has the lifecycle of a Task which contains
     // many turns, from the perspective of the user, it is a single turn.
@@ -1485,7 +1469,9 @@ async fn run_task(
             .into_iter()
             .map(ResponseItem::from)
             .collect::<Vec<ResponseItem>>();
-        sess.record_conversation_items(&pending_input).await;
+        for item in pending_input.iter() {
+            sess.record_user_input(&sub_id, item.clone()).await;
+        }
 
         // Construct the input that we will send to the model. When using the
         // Chat completions API (or ZDR clients), the model needs the full
@@ -1612,8 +1598,9 @@ async fn run_task(
 
                 // Only attempt to take the lock if there is something to record.
                 if !items_to_record_in_conversation_history.is_empty() {
-                    sess.record_conversation_items(&items_to_record_in_conversation_history)
-                        .await;
+                    for item in items_to_record_in_conversation_history.iter().cloned() {
+                        sess.record_conversation_item(item).await;
+                    }
                 }
 
                 if responses.is_empty() {
@@ -1767,7 +1754,7 @@ async fn try_run_turn(
                 }
             })
             .map(|call_id| ResponseItem::CustomToolCallOutput {
-                call_id,
+                call_id: call_id.clone(),
                 output: "aborted".to_string(),
             })
             .collect::<Vec<_>>()
@@ -1783,15 +1770,6 @@ async fn try_run_turn(
         })
     };
 
-    let rollout_item = RolloutItem::TurnContext(TurnContextItem {
-        cwd: turn_context.cwd.clone(),
-        approval_policy: turn_context.approval_policy,
-        sandbox_policy: turn_context.sandbox_policy.clone(),
-        model: turn_context.client.get_model(),
-        effort: turn_context.client.get_reasoning_effort(),
-        summary: turn_context.client.get_reasoning_summary(),
-    });
-    sess.persist_rollout_items(&[rollout_item]).await;
     let mut stream = turn_context.client.clone().stream(&prompt).await?;
 
     let mut output = Vec::new();
@@ -1833,13 +1811,11 @@ async fn try_run_turn(
                 output.push(ProcessedResponseItem { item, response });
             }
             ResponseEvent::WebSearchCallBegin { call_id } => {
-                let _ = sess
-                    .tx_event
-                    .send(Event {
-                        id: sub_id.to_string(),
-                        msg: EventMsg::WebSearchBegin(WebSearchBeginEvent { call_id }),
-                    })
-                    .await;
+                sess.send_event(Event {
+                    id: sub_id.to_string(),
+                    msg: EventMsg::WebSearchBegin(WebSearchBeginEvent { call_id }),
+                })
+                .await;
             }
             ResponseEvent::Completed {
                 response_id: _,
@@ -1855,12 +1831,11 @@ async fn try_run_turn(
                     st.token_info = info.clone();
                     info
                 };
-                let _ = sess
-                    .send_event(Event {
-                        id: sub_id.to_string(),
-                        msg: EventMsg::TokenCount(crate::protocol::TokenCountEvent { info }),
-                    })
-                    .await;
+                sess.send_event(Event {
+                    id: sub_id.to_string(),
+                    msg: EventMsg::TokenCount(crate::protocol::TokenCountEvent { info }),
+                })
+                .await;
 
                 let unified_diff = turn_diff_tracker.get_unified_diff();
                 if let Ok(Some(unified_diff)) = unified_diff {
@@ -1974,14 +1949,10 @@ async fn run_compact_task(
 
     sess.remove_task(&sub_id);
 
-    let rollout_item = {
+    {
         let mut state = sess.state.lock_unchecked();
         state.history.keep_last_messages(1);
-        RolloutItem::Compacted(CompactedItem {
-            message: state.history.last_agent_message(),
-        })
-    };
-    sess.persist_rollout_items(&[rollout_item]).await;
+    }
 
     let event = Event {
         id: sub_id.clone(),
@@ -2115,72 +2086,6 @@ async fn handle_response_item(
     Ok(output)
 }
 
-async fn handle_unified_exec_tool_call(
-    sess: &Session,
-    call_id: String,
-    session_id: Option<String>,
-    arguments: Vec<String>,
-    timeout_ms: Option<u64>,
-) -> ResponseInputItem {
-    let parsed_session_id = if let Some(session_id) = session_id {
-        match session_id.parse::<i32>() {
-            Ok(parsed) => Some(parsed),
-            Err(output) => {
-                return ResponseInputItem::FunctionCallOutput {
-                    call_id: call_id.to_string(),
-                    output: FunctionCallOutputPayload {
-                        content: format!("invalid session_id: {session_id} due to error {output}"),
-                        success: Some(false),
-                    },
-                };
-            }
-        }
-    } else {
-        None
-    };
-
-    let request = crate::unified_exec::UnifiedExecRequest {
-        session_id: parsed_session_id,
-        input_chunks: &arguments,
-        timeout_ms,
-    };
-
-    let result = sess.unified_exec_manager.handle_request(request).await;
-
-    let output_payload = match result {
-        Ok(value) => {
-            #[derive(Serialize)]
-            struct SerializedUnifiedExecResult<'a> {
-                session_id: Option<String>,
-                output: &'a str,
-            }
-
-            match serde_json::to_string(&SerializedUnifiedExecResult {
-                session_id: value.session_id.map(|id| id.to_string()),
-                output: &value.output,
-            }) {
-                Ok(serialized) => FunctionCallOutputPayload {
-                    content: serialized,
-                    success: Some(true),
-                },
-                Err(err) => FunctionCallOutputPayload {
-                    content: format!("failed to serialize unified exec output: {err}"),
-                    success: Some(false),
-                },
-            }
-        }
-        Err(err) => FunctionCallOutputPayload {
-            content: format!("unified exec failed: {err}"),
-            success: Some(false),
-        },
-    };
-
-    ResponseInputItem::FunctionCallOutput {
-        call_id,
-        output: output_payload,
-    }
-}
-
 async fn handle_function_call(
     sess: &Session,
     turn_context: &TurnContext,
@@ -2208,38 +2113,6 @@ async fn handle_function_call(
             )
             .await
         }
-        "unified_exec" => {
-            #[derive(Deserialize)]
-            struct UnifiedExecArgs {
-                input: Vec<String>,
-                #[serde(default)]
-                session_id: Option<String>,
-                #[serde(default)]
-                timeout_ms: Option<u64>,
-            }
-
-            let args = match serde_json::from_str::<UnifiedExecArgs>(&arguments) {
-                Ok(args) => args,
-                Err(err) => {
-                    return ResponseInputItem::FunctionCallOutput {
-                        call_id,
-                        output: FunctionCallOutputPayload {
-                            content: format!("failed to parse function arguments: {err}"),
-                            success: Some(false),
-                        },
-                    };
-                }
-            };
-
-            handle_unified_exec_tool_call(
-                sess,
-                call_id,
-                args.session_id,
-                args.input,
-                args.timeout_ms,
-            )
-            .await
-        }
         "view_image" => {
             #[derive(serde::Deserialize)]
             struct SeeImageArgs {
@@ -2718,20 +2591,6 @@ async fn handle_sandbox_error(
     let sub_id = exec_command_context.sub_id.clone();
     let cwd = exec_command_context.cwd.clone();
 
-    // if the command timed out, we can simply return this failure to the model
-    if matches!(error, SandboxErr::Timeout) {
-        return ResponseInputItem::FunctionCallOutput {
-            call_id,
-            output: FunctionCallOutputPayload {
-                content: format!(
-                    "command timed out after {} milliseconds",
-                    params.timeout_duration().as_millis()
-                ),
-                success: Some(false),
-            },
-        };
-    }
-
     // Early out if either the user never wants to be asked for approval, or
     // we're letting the model manage escalation requests. Otherwise, continue
     match turn_context.approval_policy {
@@ -2749,6 +2608,20 @@ async fn handle_sandbox_error(
         AskForApproval::UnlessTrusted | AskForApproval::OnFailure => (),
     }
 
+    // similarly, if the command timed out, we can simply return this failure to the model
+    if matches!(error, SandboxErr::Timeout) {
+        return ResponseInputItem::FunctionCallOutput {
+            call_id,
+            output: FunctionCallOutputPayload {
+                content: format!(
+                    "command timed out after {} milliseconds",
+                    params.timeout_duration().as_millis()
+                ),
+                success: Some(false),
+            },
+        };
+    }
+
     // Note that when `error` is `SandboxErr::Denied`, it could be a false
     // positive. That is, it may have exited with a non-zero exit code, not
     // because the sandbox denied it, but because that is its expected behavior,
@@ -3007,15 +2880,6 @@ async fn drain_to_completed(
     sub_id: &str,
     prompt: &Prompt,
 ) -> CodexResult<()> {
-    let rollout_item = RolloutItem::TurnContext(TurnContextItem {
-        cwd: turn_context.cwd.clone(),
-        approval_policy: turn_context.approval_policy,
-        sandbox_policy: turn_context.sandbox_policy.clone(),
-        model: turn_context.client.get_model(),
-        effort: turn_context.client.get_reasoning_effort(),
-        summary: turn_context.client.get_reasoning_summary(),
-    });
-    sess.persist_rollout_items(&[rollout_item]).await;
     let mut stream = turn_context.client.clone().stream(prompt).await?;
     loop {
         let maybe_event = stream.next().await;
@@ -3046,13 +2910,11 @@ async fn drain_to_completed(
                     info
                 };
 
-                sess.tx_event
-                    .send(Event {
-                        id: sub_id.to_string(),
-                        msg: EventMsg::TokenCount(crate::protocol::TokenCountEvent { info }),
-                    })
-                    .await
-                    .ok();
+                sess.send_event(Event {
+                    id: sub_id.to_string(),
+                    msg: EventMsg::TokenCount(crate::protocol::TokenCountEvent { info }),
+                })
+                .await;
 
                 return Ok(());
             }
@@ -3149,7 +3011,7 @@ mod tests {
             exit_code: 0,
             stdout: StreamOutput::new(String::new()),
             stderr: StreamOutput::new(String::new()),
-            aggregated_output: StreamOutput::new(full),
+            aggregated_output: StreamOutput::new(full.clone()),
             duration: StdDuration::from_secs(1),
         };
 
@@ -3183,7 +3045,7 @@ mod tests {
     fn model_truncation_respects_byte_budget() {
         // Construct a large output (about 100kB) so byte budget dominates
         let big_line = "x".repeat(100);
-        let full = std::iter::repeat_n(big_line, 1000)
+        let full = std::iter::repeat_n(big_line.clone(), 1000)
             .collect::<Vec<_>>()
             .join("\n");
 

codex-rs/core/src/config.rs

@@ -15,11 +15,11 @@ use crate::model_provider_info::built_in_model_providers;
 use crate::openai_model_info::get_model_info;
 use crate::protocol::AskForApproval;
 use crate::protocol::SandboxPolicy;
-use anyhow::Context;
 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::mcp_protocol::AuthMode;
 use codex_protocol::mcp_protocol::Tools;
 use codex_protocol::mcp_protocol::UserSavedConfig;
 use dirs::home_dir;
@@ -32,14 +32,15 @@ use toml::Value as TomlValue;
 use toml_edit::DocumentMut;
 
 const OPENAI_DEFAULT_MODEL: &str = "gpt-5";
-pub const GPT5_HIGH_MODEL: &str = "gpt-5-high";
 
 /// 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
 /// the context window.
 pub(crate) const PROJECT_DOC_MAX_BYTES: usize = 32 * 1024; // 32 KiB
 
-pub(crate) const CONFIG_TOML_FILE: &str = "config.toml";
+const CONFIG_TOML_FILE: &str = "config.toml";
+
+const DEFAULT_RESPONSES_ORIGINATOR_HEADER: &str = "codex_cli_rs";
 
 /// Application configuration loaded from disk and merged with overrides.
 #[derive(Debug, Clone, PartialEq)]
@@ -130,6 +131,9 @@ pub struct Config {
     /// output will be hyperlinked using the specified URI scheme.
     pub file_opener: UriBasedFileOpener,
 
+    /// Collection of settings that are specific to the TUI.
+    pub tui: Tui,
+
     /// Path to the `codex-linux-sandbox` executable. This must be set if
     /// [`crate::exec::SandboxType::LinuxSeccomp`] is used. Note that this
     /// cannot be set in the config file: it must be set in code via
@@ -165,17 +169,16 @@ pub struct Config {
 
     pub tools_web_search_request: bool,
 
-    pub use_experimental_streamable_shell_tool: bool,
+    /// The value for the `originator` header included with Responses API requests.
+    pub responses_originator_header: String,
 
-    /// If set to `true`, used only the experimental unified exec tool.
-    pub use_experimental_unified_exec_tool: bool,
+    /// If set to `true`, the API key will be signed with the `originator` header.
+    pub preferred_auth_method: AuthMode,
+
+    pub use_experimental_streamable_shell_tool: bool,
 
     /// Include the `view_image` tool that lets the agent attach a local image path to context.
     pub include_view_image_tool: bool,
-
-    /// The active profile name used to derive this `Config` (if any).
-    pub active_profile: Option<String>,
-
     /// When true, disables burst-paste detection for typed input entirely.
     /// All characters are inserted as they are received, and no buffering
     /// or placeholder replacement will occur for fast keypress bursts.
@@ -259,7 +262,17 @@ pub fn load_config_as_toml(codex_home: &Path) -> std::io::Result<TomlValue> {
     }
 }
 
-fn set_project_trusted_inner(doc: &mut DocumentMut, project_path: &Path) -> anyhow::Result<()> {
+/// Patch `CODEX_HOME/config.toml` project state.
+/// Use with caution.
+pub fn set_project_trusted(codex_home: &Path, project_path: &Path) -> anyhow::Result<()> {
+    let config_path = codex_home.join(CONFIG_TOML_FILE);
+    // Parse existing config if present; otherwise start a new document.
+    let mut doc = match std::fs::read_to_string(config_path.clone()) {
+        Ok(s) => s.parse::<DocumentMut>()?,
+        Err(e) if e.kind() == std::io::ErrorKind::NotFound => DocumentMut::new(),
+        Err(e) => return Err(e.into()),
+    };
+
     // Ensure we render a human-friendly structure:
     //
     // [projects]
@@ -275,26 +288,14 @@ fn set_project_trusted_inner(doc: &mut DocumentMut, project_path: &Path) -> anyh
     // Ensure top-level `projects` exists as a non-inline, explicit table. If it
     // exists but was previously represented as a non-table (e.g., inline),
     // replace it with an explicit table.
+    let mut created_projects_table = false;
     {
         let root = doc.as_table_mut();
-        // If `projects` exists but isn't a standard table (e.g., it's an inline table),
-        // convert it to an explicit table while preserving existing entries.
-        let existing_projects = root.get("projects").cloned();
-        if existing_projects.as_ref().is_none_or(|i| !i.is_table()) {
-            let mut projects_tbl = toml_edit::Table::new();
-            projects_tbl.set_implicit(true);
-
-            // If there was an existing inline table, migrate its entries to explicit tables.
-            if let Some(inline_tbl) = existing_projects.as_ref().and_then(|i| i.as_inline_table()) {
-                for (k, v) in inline_tbl.iter() {
-                    if let Some(inner_tbl) = v.as_inline_table() {
-                        let new_tbl = inner_tbl.clone().into_table();
-                        projects_tbl.insert(k, toml_edit::Item::Table(new_tbl));
-                    }
-                }
-            }
-
-            root.insert("projects", toml_edit::Item::Table(projects_tbl));
+        let needs_table = !root.contains_key("projects")
+            || root.get("projects").and_then(|i| i.as_table()).is_none();
+        if needs_table {
+            root.insert("projects", toml_edit::table());
+            created_projects_table = true;
         }
     }
     let Some(projects_tbl) = doc["projects"].as_table_mut() else {
@@ -303,6 +304,12 @@ fn set_project_trusted_inner(doc: &mut DocumentMut, project_path: &Path) -> anyh
         ));
     };
 
+    // If we created the `projects` table ourselves, keep it implicit so we
+    // don't render a standalone `[projects]` header.
+    if created_projects_table {
+        projects_tbl.set_implicit(true);
+    }
+
     // Ensure the per-project entry is its own explicit table. If it exists but
     // is not a table (e.g., an inline table), replace it with an explicit table.
     let needs_proj_table = !projects_tbl.contains_key(project_key.as_str())
@@ -321,21 +328,6 @@ fn set_project_trusted_inner(doc: &mut DocumentMut, project_path: &Path) -> anyh
     };
     proj_tbl.set_implicit(false);
     proj_tbl["trust_level"] = toml_edit::value("trusted");
-    Ok(())
-}
-
-/// Patch `CODEX_HOME/config.toml` project state.
-/// Use with caution.
-pub fn set_project_trusted(codex_home: &Path, project_path: &Path) -> anyhow::Result<()> {
-    let config_path = codex_home.join(CONFIG_TOML_FILE);
-    // Parse existing config if present; otherwise start a new document.
-    let mut doc = match std::fs::read_to_string(config_path.clone()) {
-        Ok(s) => s.parse::<DocumentMut>()?,
-        Err(e) if e.kind() == std::io::ErrorKind::NotFound => DocumentMut::new(),
-        Err(e) => return Err(e.into()),
-    };
-
-    set_project_trusted_inner(&mut doc, project_path)?;
 
     // ensure codex_home exists
     std::fs::create_dir_all(codex_home)?;
@@ -350,107 +342,6 @@ pub fn set_project_trusted(codex_home: &Path, project_path: &Path) -> anyhow::Re
     Ok(())
 }
 
-fn ensure_profile_table<'a>(
-    doc: &'a mut DocumentMut,
-    profile_name: &str,
-) -> anyhow::Result<&'a mut toml_edit::Table> {
-    let mut created_profiles_table = false;
-    {
-        let root = doc.as_table_mut();
-        let needs_table = !root.contains_key("profiles")
-            || root
-                .get("profiles")
-                .and_then(|item| item.as_table())
-                .is_none();
-        if needs_table {
-            root.insert("profiles", toml_edit::table());
-            created_profiles_table = true;
-        }
-    }
-
-    let Some(profiles_table) = doc["profiles"].as_table_mut() else {
-        return Err(anyhow::anyhow!(
-            "profiles table missing after initialization"
-        ));
-    };
-
-    if created_profiles_table {
-        profiles_table.set_implicit(true);
-    }
-
-    let needs_profile_table = !profiles_table.contains_key(profile_name)
-        || profiles_table
-            .get(profile_name)
-            .and_then(|item| item.as_table())
-            .is_none();
-    if needs_profile_table {
-        profiles_table.insert(profile_name, toml_edit::table());
-    }
-
-    let Some(profile_table) = profiles_table
-        .get_mut(profile_name)
-        .and_then(|item| item.as_table_mut())
-    else {
-        return Err(anyhow::anyhow!(format!(
-            "profile table missing for {profile_name}"
-        )));
-    };
-
-    profile_table.set_implicit(false);
-    Ok(profile_table)
-}
-
-// TODO(jif) refactor config persistence.
-pub async fn persist_model_selection(
-    codex_home: &Path,
-    active_profile: Option<&str>,
-    model: &str,
-    effort: Option<ReasoningEffort>,
-) -> anyhow::Result<()> {
-    let config_path = codex_home.join(CONFIG_TOML_FILE);
-    let serialized = match tokio::fs::read_to_string(&config_path).await {
-        Ok(contents) => contents,
-        Err(err) if err.kind() == std::io::ErrorKind::NotFound => String::new(),
-        Err(err) => return Err(err.into()),
-    };
-
-    let mut doc = if serialized.is_empty() {
-        DocumentMut::new()
-    } else {
-        serialized.parse::<DocumentMut>()?
-    };
-
-    if let Some(profile_name) = active_profile {
-        let profile_table = ensure_profile_table(&mut doc, profile_name)?;
-        profile_table["model"] = toml_edit::value(model);
-        if let Some(effort) = effort {
-            profile_table["model_reasoning_effort"] = toml_edit::value(effort.to_string());
-        }
-    } else {
-        let table = doc.as_table_mut();
-        table["model"] = toml_edit::value(model);
-        if let Some(effort) = effort {
-            table["model_reasoning_effort"] = toml_edit::value(effort.to_string());
-        }
-    }
-
-    // TODO(jif) refactor the home creation
-    tokio::fs::create_dir_all(codex_home)
-        .await
-        .with_context(|| {
-            format!(
-                "failed to create Codex home directory at {}",
-                codex_home.display()
-            )
-        })?;
-
-    tokio::fs::write(&config_path, doc.to_string())
-        .await
-        .with_context(|| format!("failed to persist config.toml at {}", config_path.display()))?;
-
-    Ok(())
-}
-
 /// Apply a single dotted-path override onto a TOML value.
 fn apply_toml_override(root: &mut TomlValue, path: &str, value: TomlValue) {
     use toml::value::Table;
@@ -586,10 +477,15 @@ pub struct ConfigToml {
     pub experimental_instructions_file: Option<PathBuf>,
 
     pub experimental_use_exec_command_tool: Option<bool>,
-    pub experimental_use_unified_exec_tool: Option<bool>,
+
+    /// The value for the `originator` header included with Responses API requests.
+    pub responses_originator_header_internal_override: Option<String>,
 
     pub projects: Option<HashMap<String, ProjectConfig>>,
 
+    /// If set to `true`, the API key will be signed with the `originator` header.
+    pub preferred_auth_method: Option<AuthMode>,
+
     /// Nested tools section for feature toggles
     pub tools: Option<ToolsToml>,
 
@@ -765,11 +661,7 @@ impl Config {
             tools_web_search_request: override_tools_web_search_request,
         } = overrides;
 
-        let active_profile_name = config_profile_key
-            .as_ref()
-            .or(cfg.profile.as_ref())
-            .cloned();
-        let config_profile = match active_profile_name.as_ref() {
+        let config_profile = match config_profile_key.as_ref().or(cfg.profile.as_ref()) {
             Some(key) => cfg
                 .profiles
                 .get(key)
@@ -881,6 +773,10 @@ impl Config {
             Self::get_base_instructions(experimental_instructions_path, &resolved_cwd)?;
         let base_instructions = base_instructions.or(file_base_instructions);
 
+        let responses_originator_header: String = cfg
+            .responses_originator_header_internal_override
+            .unwrap_or(DEFAULT_RESPONSES_ORIGINATOR_HEADER.to_owned());
+
         let config = Self {
             model,
             model_family,
@@ -904,6 +800,7 @@ impl Config {
             codex_home,
             history,
             file_opener: cfg.file_opener.unwrap_or(UriBasedFileOpener::VsCode),
+            tui: cfg.tui.unwrap_or_default(),
             codex_linux_sandbox_exe,
 
             hide_agent_reasoning: cfg.hide_agent_reasoning.unwrap_or(false),
@@ -929,14 +826,12 @@ impl Config {
             include_plan_tool: include_plan_tool.unwrap_or(false),
             include_apply_patch_tool: include_apply_patch_tool.unwrap_or(false),
             tools_web_search_request,
+            responses_originator_header,
+            preferred_auth_method: cfg.preferred_auth_method.unwrap_or(AuthMode::ChatGPT),
             use_experimental_streamable_shell_tool: cfg
                 .experimental_use_exec_command_tool
                 .unwrap_or(false),
-            use_experimental_unified_exec_tool: cfg
-                .experimental_use_unified_exec_tool
-                .unwrap_or(false),
             include_view_image_tool,
-            active_profile: active_profile_name,
             disable_paste_burst: cfg.disable_paste_burst.unwrap_or(false),
         };
         Ok(config)
@@ -1047,7 +942,6 @@ mod tests {
 
     use super::*;
     use pretty_assertions::assert_eq;
-
     use tempfile::TempDir;
 
     #[test]
@@ -1138,145 +1032,6 @@ exclude_slash_tmp = true
         );
     }
 
-    #[tokio::test]
-    async fn persist_model_selection_updates_defaults() -> anyhow::Result<()> {
-        let codex_home = TempDir::new()?;
-
-        persist_model_selection(
-            codex_home.path(),
-            None,
-            "gpt-5-high-new",
-            Some(ReasoningEffort::High),
-        )
-        .await?;
-
-        let serialized =
-            tokio::fs::read_to_string(codex_home.path().join(CONFIG_TOML_FILE)).await?;
-        let parsed: ConfigToml = toml::from_str(&serialized)?;
-
-        assert_eq!(parsed.model.as_deref(), Some("gpt-5-high-new"));
-        assert_eq!(parsed.model_reasoning_effort, Some(ReasoningEffort::High));
-
-        Ok(())
-    }
-
-    #[tokio::test]
-    async fn persist_model_selection_overwrites_existing_model() -> anyhow::Result<()> {
-        let codex_home = TempDir::new()?;
-        let config_path = codex_home.path().join(CONFIG_TOML_FILE);
-
-        tokio::fs::write(
-            &config_path,
-            r#"
-model = "gpt-5"
-model_reasoning_effort = "medium"
-
-[profiles.dev]
-model = "gpt-4.1"
-"#,
-        )
-        .await?;
-
-        persist_model_selection(
-            codex_home.path(),
-            None,
-            "o4-mini",
-            Some(ReasoningEffort::High),
-        )
-        .await?;
-
-        let serialized = tokio::fs::read_to_string(config_path).await?;
-        let parsed: ConfigToml = toml::from_str(&serialized)?;
-
-        assert_eq!(parsed.model.as_deref(), Some("o4-mini"));
-        assert_eq!(parsed.model_reasoning_effort, Some(ReasoningEffort::High));
-        assert_eq!(
-            parsed
-                .profiles
-                .get("dev")
-                .and_then(|profile| profile.model.as_deref()),
-            Some("gpt-4.1"),
-        );
-
-        Ok(())
-    }
-
-    #[tokio::test]
-    async fn persist_model_selection_updates_profile() -> anyhow::Result<()> {
-        let codex_home = TempDir::new()?;
-
-        persist_model_selection(
-            codex_home.path(),
-            Some("dev"),
-            "gpt-5-high-new",
-            Some(ReasoningEffort::Low),
-        )
-        .await?;
-
-        let serialized =
-            tokio::fs::read_to_string(codex_home.path().join(CONFIG_TOML_FILE)).await?;
-        let parsed: ConfigToml = toml::from_str(&serialized)?;
-        let profile = parsed
-            .profiles
-            .get("dev")
-            .expect("profile should be created");
-
-        assert_eq!(profile.model.as_deref(), Some("gpt-5-high-new"));
-        assert_eq!(profile.model_reasoning_effort, Some(ReasoningEffort::Low));
-
-        Ok(())
-    }
-
-    #[tokio::test]
-    async fn persist_model_selection_updates_existing_profile() -> anyhow::Result<()> {
-        let codex_home = TempDir::new()?;
-        let config_path = codex_home.path().join(CONFIG_TOML_FILE);
-
-        tokio::fs::write(
-            &config_path,
-            r#"
-[profiles.dev]
-model = "gpt-4"
-model_reasoning_effort = "medium"
-
-[profiles.prod]
-model = "gpt-5"
-"#,
-        )
-        .await?;
-
-        persist_model_selection(
-            codex_home.path(),
-            Some("dev"),
-            "o4-high",
-            Some(ReasoningEffort::Medium),
-        )
-        .await?;
-
-        let serialized = tokio::fs::read_to_string(config_path).await?;
-        let parsed: ConfigToml = toml::from_str(&serialized)?;
-
-        let dev_profile = parsed
-            .profiles
-            .get("dev")
-            .expect("dev profile should survive updates");
-        assert_eq!(dev_profile.model.as_deref(), Some("o4-high"));
-        assert_eq!(
-            dev_profile.model_reasoning_effort,
-            Some(ReasoningEffort::Medium)
-        );
-
-        assert_eq!(
-            parsed
-                .profiles
-                .get("prod")
-                .and_then(|profile| profile.model.as_deref()),
-            Some("gpt-5"),
-        );
-
-        Ok(())
-    }
-
     struct PrecedenceTestFixture {
         cwd: TempDir,
         codex_home: TempDir,
@@ -1435,6 +1190,7 @@ model_verbosity = "high"
                 codex_home: fixture.codex_home(),
                 history: History::default(),
                 file_opener: UriBasedFileOpener::VsCode,
+                tui: Tui::default(),
                 codex_linux_sandbox_exe: None,
                 hide_agent_reasoning: false,
                 show_raw_agent_reasoning: false,
@@ -1447,10 +1203,10 @@ model_verbosity = "high"
                 include_plan_tool: false,
                 include_apply_patch_tool: false,
                 tools_web_search_request: false,
+                responses_originator_header: "codex_cli_rs".to_string(),
+                preferred_auth_method: AuthMode::ChatGPT,
                 use_experimental_streamable_shell_tool: false,
-                use_experimental_unified_exec_tool: false,
                 include_view_image_tool: true,
-                active_profile: Some("o3".to_string()),
                 disable_paste_burst: false,
             },
             o3_profile_config
@@ -1491,6 +1247,7 @@ model_verbosity = "high"
             codex_home: fixture.codex_home(),
             history: History::default(),
             file_opener: UriBasedFileOpener::VsCode,
+            tui: Tui::default(),
             codex_linux_sandbox_exe: None,
             hide_agent_reasoning: false,
             show_raw_agent_reasoning: false,
@@ -1503,10 +1260,10 @@ model_verbosity = "high"
             include_plan_tool: false,
             include_apply_patch_tool: false,
             tools_web_search_request: false,
+            responses_originator_header: "codex_cli_rs".to_string(),
+            preferred_auth_method: AuthMode::ChatGPT,
             use_experimental_streamable_shell_tool: false,
-            use_experimental_unified_exec_tool: false,
             include_view_image_tool: true,
-            active_profile: Some("gpt3".to_string()),
             disable_paste_burst: false,
         };
 
@@ -1562,6 +1319,7 @@ model_verbosity = "high"
             codex_home: fixture.codex_home(),
             history: History::default(),
             file_opener: UriBasedFileOpener::VsCode,
+            tui: Tui::default(),
             codex_linux_sandbox_exe: None,
             hide_agent_reasoning: false,
             show_raw_agent_reasoning: false,
@@ -1574,10 +1332,10 @@ model_verbosity = "high"
             include_plan_tool: false,
             include_apply_patch_tool: false,
             tools_web_search_request: false,
+            responses_originator_header: "codex_cli_rs".to_string(),
+            preferred_auth_method: AuthMode::ChatGPT,
             use_experimental_streamable_shell_tool: false,
-            use_experimental_unified_exec_tool: false,
             include_view_image_tool: true,
-            active_profile: Some("zdr".to_string()),
             disable_paste_burst: false,
         };
 
@@ -1619,6 +1377,7 @@ model_verbosity = "high"
             codex_home: fixture.codex_home(),
             history: History::default(),
             file_opener: UriBasedFileOpener::VsCode,
+            tui: Tui::default(),
             codex_linux_sandbox_exe: None,
             hide_agent_reasoning: false,
             show_raw_agent_reasoning: false,
@@ -1631,10 +1390,10 @@ model_verbosity = "high"
             include_plan_tool: false,
             include_apply_patch_tool: false,
             tools_web_search_request: false,
+            responses_originator_header: "codex_cli_rs".to_string(),
+            preferred_auth_method: AuthMode::ChatGPT,
             use_experimental_streamable_shell_tool: false,
-            use_experimental_unified_exec_tool: false,
             include_view_image_tool: true,
-            active_profile: Some("gpt5".to_string()),
             disable_paste_burst: false,
         };
 
@@ -1645,14 +1404,17 @@ model_verbosity = "high"
 
     #[test]
     fn test_set_project_trusted_writes_explicit_tables() -> anyhow::Result<()> {
-        let project_dir = Path::new("/some/path");
-        let mut doc = DocumentMut::new();
+        let codex_home = TempDir::new().unwrap();
+        let project_dir = TempDir::new().unwrap();
 
-        set_project_trusted_inner(&mut doc, project_dir)?;
+        // Call the function under test
+        set_project_trusted(codex_home.path(), project_dir.path())?;
 
-        let contents = doc.to_string();
+        // Read back the generated config.toml and assert exact contents
+        let config_path = codex_home.path().join(CONFIG_TOML_FILE);
+        let contents = std::fs::read_to_string(&config_path)?;
 
-        let raw_path = project_dir.to_string_lossy();
+        let raw_path = project_dir.path().to_string_lossy();
         let path_str = if raw_path.contains('\\') {
             format!("'{raw_path}'")
         } else {
@@ -1670,10 +1432,12 @@ trust_level = "trusted"
 
     #[test]
     fn test_set_project_trusted_converts_inline_to_explicit() -> anyhow::Result<()> {
-        let project_dir = Path::new("/some/path");
+        let codex_home = TempDir::new().unwrap();
+        let project_dir = TempDir::new().unwrap();
 
         // Seed config.toml with an inline project entry under [projects]
-        let raw_path = project_dir.to_string_lossy();
+        let config_path = codex_home.path().join(CONFIG_TOML_FILE);
+        let raw_path = project_dir.path().to_string_lossy();
         let path_str = if raw_path.contains('\\') {
             format!("'{raw_path}'")
         } else {
@@ -1685,12 +1449,13 @@ trust_level = "trusted"
 {path_str} = {{ trust_level = "untrusted" }}
 "#
         );
-        let mut doc = initial.parse::<DocumentMut>()?;
+        std::fs::create_dir_all(codex_home.path())?;
+        std::fs::write(&config_path, initial)?;
 
         // Run the function; it should convert to explicit tables and set trusted
-        set_project_trusted_inner(&mut doc, project_dir)?;
+        set_project_trusted(codex_home.path(), project_dir.path())?;
 
-        let contents = doc.to_string();
+        let contents = std::fs::read_to_string(&config_path)?;
 
         // Assert exact output after conversion to explicit table
         let expected = format!(
@@ -1705,37 +1470,5 @@ trust_level = "trusted"
         Ok(())
     }
 
-    #[test]
-    fn test_set_project_trusted_migrates_top_level_inline_projects_preserving_entries()
-    -> anyhow::Result<()> {
-        let initial = r#"toplevel = "baz"
-projects = { "/Users/mbolin/code/codex4" = { trust_level = "trusted", foo = "bar" } , "/Users/mbolin/code/codex3" = { trust_level = "trusted" } }
-model = "foo""#;
-        let mut doc = initial.parse::<DocumentMut>()?;
-
-        // Approve a new directory
-        let new_project = Path::new("/Users/mbolin/code/codex2");
-        set_project_trusted_inner(&mut doc, new_project)?;
-
-        let contents = doc.to_string();
-
-        // Since we created the [projects] table as part of migration, it is kept implicit.
-        // Expect explicit per-project tables, preserving prior entries and appending the new one.
-        let expected = r#"toplevel = "baz"
-model = "foo"
-
-[projects."/Users/mbolin/code/codex4"]
-trust_level = "trusted"
-foo = "bar"
-
-[projects."/Users/mbolin/code/codex3"]
-trust_level = "trusted"
-
-[projects."/Users/mbolin/code/codex2"]
-trust_level = "trusted"
-"#;
-        assert_eq!(contents, expected);
-
-        Ok(())
-    }
+    // No test enforcing the presence of a standalone [projects] header.
 }

codex-rs/core/src/config_edit.rs

@@ -1,582 +0,0 @@
-use crate::config::CONFIG_TOML_FILE;
-use anyhow::Result;
-use std::path::Path;
-use tempfile::NamedTempFile;
-use toml_edit::DocumentMut;
-
-pub const CONFIG_KEY_MODEL: &str = "model";
-pub const CONFIG_KEY_EFFORT: &str = "model_reasoning_effort";
-
-/// Persist overrides into `config.toml` using explicit key segments per
-/// override. This avoids ambiguity with keys that contain dots or spaces.
-pub async fn persist_overrides(
-    codex_home: &Path,
-    profile: Option<&str>,
-    overrides: &[(&[&str], &str)],
-) -> Result<()> {
-    let config_path = codex_home.join(CONFIG_TOML_FILE);
-
-    let mut doc = match tokio::fs::read_to_string(&config_path).await {
-        Ok(s) => s.parse::<DocumentMut>()?,
-        Err(e) if e.kind() == std::io::ErrorKind::NotFound => {
-            tokio::fs::create_dir_all(codex_home).await?;
-            DocumentMut::new()
-        }
-        Err(e) => return Err(e.into()),
-    };
-
-    let effective_profile = if let Some(p) = profile {
-        Some(p.to_owned())
-    } else {
-        doc.get("profile")
-            .and_then(|i| i.as_str())
-            .map(|s| s.to_string())
-    };
-
-    for (segments, val) in overrides.iter().copied() {
-        let value = toml_edit::value(val);
-        if let Some(ref name) = effective_profile {
-            if segments.first().copied() == Some("profiles") {
-                apply_toml_edit_override_segments(&mut doc, segments, value);
-            } else {
-                let mut seg_buf: Vec<&str> = Vec::with_capacity(2 + segments.len());
-                seg_buf.push("profiles");
-                seg_buf.push(name.as_str());
-                seg_buf.extend_from_slice(segments);
-                apply_toml_edit_override_segments(&mut doc, &seg_buf, value);
-            }
-        } else {
-            apply_toml_edit_override_segments(&mut doc, segments, value);
-        }
-    }
-
-    let tmp_file = NamedTempFile::new_in(codex_home)?;
-    tokio::fs::write(tmp_file.path(), doc.to_string()).await?;
-    tmp_file.persist(config_path)?;
-
-    Ok(())
-}
-
-/// Persist overrides where values may be optional. Any entries with `None`
-/// values are skipped. If all values are `None`, this becomes a no-op and
-/// returns `Ok(())` without touching the file.
-pub async fn persist_non_null_overrides(
-    codex_home: &Path,
-    profile: Option<&str>,
-    overrides: &[(&[&str], Option<&str>)],
-) -> Result<()> {
-    let filtered: Vec<(&[&str], &str)> = overrides
-        .iter()
-        .filter_map(|(k, v)| v.map(|vv| (*k, vv)))
-        .collect();
-
-    if filtered.is_empty() {
-        return Ok(());
-    }
-
-    persist_overrides(codex_home, profile, &filtered).await
-}
-
-/// Apply a single override onto a `toml_edit` document while preserving
-/// existing formatting/comments.
-/// The key is expressed as explicit segments to correctly handle keys that
-/// contain dots or spaces.
-fn apply_toml_edit_override_segments(
-    doc: &mut DocumentMut,
-    segments: &[&str],
-    value: toml_edit::Item,
-) {
-    use toml_edit::Item;
-
-    if segments.is_empty() {
-        return;
-    }
-
-    let mut current = doc.as_table_mut();
-    for seg in &segments[..segments.len() - 1] {
-        if !current.contains_key(seg) {
-            current[*seg] = Item::Table(toml_edit::Table::new());
-            if let Some(t) = current[*seg].as_table_mut() {
-                t.set_implicit(true);
-            }
-        }
-
-        let maybe_item = current.get_mut(seg);
-        let Some(item) = maybe_item else { return };
-
-        if !item.is_table() {
-            *item = Item::Table(toml_edit::Table::new());
-            if let Some(t) = item.as_table_mut() {
-                t.set_implicit(true);
-            }
-        }
-
-        let Some(tbl) = item.as_table_mut() else {
-            return;
-        };
-        current = tbl;
-    }
-
-    let last = segments[segments.len() - 1];
-    current[last] = value;
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use pretty_assertions::assert_eq;
-    use tempfile::tempdir;
-
-    /// Verifies model and effort are written at top-level when no profile is set.
-    #[tokio::test]
-    async fn set_default_model_and_effort_top_level_when_no_profile() {
-        let tmpdir = tempdir().expect("tmp");
-        let codex_home = tmpdir.path();
-
-        persist_overrides(
-            codex_home,
-            None,
-            &[
-                (&[CONFIG_KEY_MODEL], "gpt-5"),
-                (&[CONFIG_KEY_EFFORT], "high"),
-            ],
-        )
-        .await
-        .expect("persist");
-
-        let contents = read_config(codex_home).await;
-        let expected = r#"model = "gpt-5"
-model_reasoning_effort = "high"
-"#;
-        assert_eq!(contents, expected);
-    }
-
-    /// Verifies values are written under the active profile when `profile` is set.
-    #[tokio::test]
-    async fn set_defaults_update_profile_when_profile_set() {
-        let tmpdir = tempdir().expect("tmp");
-        let codex_home = tmpdir.path();
-
-        // Seed config with a profile selection but without profiles table
-        let seed = "profile = \"o3\"\n";
-        tokio::fs::write(codex_home.join(CONFIG_TOML_FILE), seed)
-            .await
-            .expect("seed write");
-
-        persist_overrides(
-            codex_home,
-            None,
-            &[
-                (&[CONFIG_KEY_MODEL], "o3"),
-                (&[CONFIG_KEY_EFFORT], "minimal"),
-            ],
-        )
-        .await
-        .expect("persist");
-
-        let contents = read_config(codex_home).await;
-        let expected = r#"profile = "o3"
-
-[profiles.o3]
-model = "o3"
-model_reasoning_effort = "minimal"
-"#;
-        assert_eq!(contents, expected);
-    }
-
-    /// Verifies profile names with dots/spaces are preserved via explicit segments.
-    #[tokio::test]
-    async fn set_defaults_update_profile_with_dot_and_space() {
-        let tmpdir = tempdir().expect("tmp");
-        let codex_home = tmpdir.path();
-
-        // Seed config with a profile name that contains a dot and a space
-        let seed = "profile = \"my.team name\"\n";
-        tokio::fs::write(codex_home.join(CONFIG_TOML_FILE), seed)
-            .await
-            .expect("seed write");
-
-        persist_overrides(
-            codex_home,
-            None,
-            &[
-                (&[CONFIG_KEY_MODEL], "o3"),
-                (&[CONFIG_KEY_EFFORT], "minimal"),
-            ],
-        )
-        .await
-        .expect("persist");
-
-        let contents = read_config(codex_home).await;
-        let expected = r#"profile = "my.team name"
-
-[profiles."my.team name"]
-model = "o3"
-model_reasoning_effort = "minimal"
-"#;
-        assert_eq!(contents, expected);
-    }
-
-    /// Verifies explicit profile override writes under that profile even without active profile.
-    #[tokio::test]
-    async fn set_defaults_update_when_profile_override_supplied() {
-        let tmpdir = tempdir().expect("tmp");
-        let codex_home = tmpdir.path();
-
-        // No profile key in config.toml
-        tokio::fs::write(codex_home.join(CONFIG_TOML_FILE), "")
-            .await
-            .expect("seed write");
-
-        // Persist with an explicit profile override
-        persist_overrides(
-            codex_home,
-            Some("o3"),
-            &[(&[CONFIG_KEY_MODEL], "o3"), (&[CONFIG_KEY_EFFORT], "high")],
-        )
-        .await
-        .expect("persist");
-
-        let contents = read_config(codex_home).await;
-        let expected = r#"[profiles.o3]
-model = "o3"
-model_reasoning_effort = "high"
-"#;
-        assert_eq!(contents, expected);
-    }
-
-    /// Verifies nested tables are created as needed when applying overrides.
-    #[tokio::test]
-    async fn persist_overrides_creates_nested_tables() {
-        let tmpdir = tempdir().expect("tmp");
-        let codex_home = tmpdir.path();
-
-        persist_overrides(
-            codex_home,
-            None,
-            &[
-                (&["a", "b", "c"], "v"),
-                (&["x"], "y"),
-                (&["profiles", "p1", CONFIG_KEY_MODEL], "gpt-5"),
-            ],
-        )
-        .await
-        .expect("persist");
-
-        let contents = read_config(codex_home).await;
-        let expected = r#"x = "y"
-
-[a.b]
-c = "v"
-
-[profiles.p1]
-model = "gpt-5"
-"#;
-        assert_eq!(contents, expected);
-    }
-
-    /// Verifies a scalar key becomes a table when nested keys are written.
-    #[tokio::test]
-    async fn persist_overrides_replaces_scalar_with_table() {
-        let tmpdir = tempdir().expect("tmp");
-        let codex_home = tmpdir.path();
-        let seed = "foo = \"bar\"\n";
-        tokio::fs::write(codex_home.join(CONFIG_TOML_FILE), seed)
-            .await
-            .expect("seed write");
-
-        persist_overrides(codex_home, None, &[(&["foo", "bar", "baz"], "ok")])
-            .await
-            .expect("persist");
-
-        let contents = read_config(codex_home).await;
-        let expected = r#"[foo.bar]
-baz = "ok"
-"#;
-        assert_eq!(contents, expected);
-    }
-
-    /// Verifies comments and spacing are preserved when writing under active profile.
-    #[tokio::test]
-    async fn set_defaults_preserve_comments() {
-        let tmpdir = tempdir().expect("tmp");
-        let codex_home = tmpdir.path();
-
-        // Seed a config with comments and spacing we expect to preserve
-        let seed = r#"# Global comment
-# Another line
-
-profile = "o3"
-
-# Profile settings
-[profiles.o3]
-# keep me
-existing = "keep"
-"#;
-        tokio::fs::write(codex_home.join(CONFIG_TOML_FILE), seed)
-            .await
-            .expect("seed write");
-
-        // Apply defaults; since profile is set, it should write under [profiles.o3]
-        persist_overrides(
-            codex_home,
-            None,
-            &[(&[CONFIG_KEY_MODEL], "o3"), (&[CONFIG_KEY_EFFORT], "high")],
-        )
-        .await
-        .expect("persist");
-
-        let contents = read_config(codex_home).await;
-        let expected = r#"# Global comment
-# Another line
-
-profile = "o3"
-
-# Profile settings
-[profiles.o3]
-# keep me
-existing = "keep"
-model = "o3"
-model_reasoning_effort = "high"
-"#;
-        assert_eq!(contents, expected);
-    }
-
-    /// Verifies comments and spacing are preserved when writing at top level.
-    #[tokio::test]
-    async fn set_defaults_preserve_global_comments() {
-        let tmpdir = tempdir().expect("tmp");
-        let codex_home = tmpdir.path();
-
-        // Seed a config WITHOUT a profile, containing comments and spacing
-        let seed = r#"# Top-level comments
-# should be preserved
-
-existing = "keep"
-"#;
-        tokio::fs::write(codex_home.join(CONFIG_TOML_FILE), seed)
-            .await
-            .expect("seed write");
-
-        // Since there is no profile, the defaults should be written at top-level
-        persist_overrides(
-            codex_home,
-            None,
-            &[
-                (&[CONFIG_KEY_MODEL], "gpt-5"),
-                (&[CONFIG_KEY_EFFORT], "minimal"),
-            ],
-        )
-        .await
-        .expect("persist");
-
-        let contents = read_config(codex_home).await;
-        let expected = r#"# Top-level comments
-# should be preserved
-
-existing = "keep"
-model = "gpt-5"
-model_reasoning_effort = "minimal"
-"#;
-        assert_eq!(contents, expected);
-    }
-
-    /// Verifies errors on invalid TOML propagate and file is not clobbered.
-    #[tokio::test]
-    async fn persist_overrides_errors_on_parse_failure() {
-        let tmpdir = tempdir().expect("tmp");
-        let codex_home = tmpdir.path();
-
-        // Write an intentionally invalid TOML file
-        let invalid = "invalid = [unclosed";
-        tokio::fs::write(codex_home.join(CONFIG_TOML_FILE), invalid)
-            .await
-            .expect("seed write");
-
-        // Attempting to persist should return an error and must not clobber the file.
-        let res = persist_overrides(codex_home, None, &[(&["x"], "y")]).await;
-        assert!(res.is_err(), "expected parse error to propagate");
-
-        // File should be unchanged
-        let contents = read_config(codex_home).await;
-        assert_eq!(contents, invalid);
-    }
-
-    /// Verifies changing model only preserves existing effort at top-level.
-    #[tokio::test]
-    async fn changing_only_model_preserves_existing_effort_top_level() {
-        let tmpdir = tempdir().expect("tmp");
-        let codex_home = tmpdir.path();
-
-        // Seed with an effort value only
-        let seed = "model_reasoning_effort = \"minimal\"\n";
-        tokio::fs::write(codex_home.join(CONFIG_TOML_FILE), seed)
-            .await
-            .expect("seed write");
-
-        // Change only the model
-        persist_overrides(codex_home, None, &[(&[CONFIG_KEY_MODEL], "o3")])
-            .await
-            .expect("persist");
-
-        let contents = read_config(codex_home).await;
-        let expected = r#"model_reasoning_effort = "minimal"
-model = "o3"
-"#;
-        assert_eq!(contents, expected);
-    }
-
-    /// Verifies changing effort only preserves existing model at top-level.
-    #[tokio::test]
-    async fn changing_only_effort_preserves_existing_model_top_level() {
-        let tmpdir = tempdir().expect("tmp");
-        let codex_home = tmpdir.path();
-
-        // Seed with a model value only
-        let seed = "model = \"gpt-5\"\n";
-        tokio::fs::write(codex_home.join(CONFIG_TOML_FILE), seed)
-            .await
-            .expect("seed write");
-
-        // Change only the effort
-        persist_overrides(codex_home, None, &[(&[CONFIG_KEY_EFFORT], "high")])
-            .await
-            .expect("persist");
-
-        let contents = read_config(codex_home).await;
-        let expected = r#"model = "gpt-5"
-model_reasoning_effort = "high"
-"#;
-        assert_eq!(contents, expected);
-    }
-
-    /// Verifies changing model only preserves existing effort in active profile.
-    #[tokio::test]
-    async fn changing_only_model_preserves_effort_in_active_profile() {
-        let tmpdir = tempdir().expect("tmp");
-        let codex_home = tmpdir.path();
-
-        // Seed with an active profile and an existing effort under that profile
-        let seed = r#"profile = "p1"
-
-[profiles.p1]
-model_reasoning_effort = "low"
-"#;
-        tokio::fs::write(codex_home.join(CONFIG_TOML_FILE), seed)
-            .await
-            .expect("seed write");
-
-        persist_overrides(codex_home, None, &[(&[CONFIG_KEY_MODEL], "o4-mini")])
-            .await
-            .expect("persist");
-
-        let contents = read_config(codex_home).await;
-        let expected = r#"profile = "p1"
-
-[profiles.p1]
-model_reasoning_effort = "low"
-model = "o4-mini"
-"#;
-        assert_eq!(contents, expected);
-    }
-
-    /// Verifies changing effort only preserves existing model in a profile override.
-    #[tokio::test]
-    async fn changing_only_effort_preserves_model_in_profile_override() {
-        let tmpdir = tempdir().expect("tmp");
-        let codex_home = tmpdir.path();
-
-        // No active profile key; we'll target an explicit override
-        let seed = r#"[profiles.team]
-model = "gpt-5"
-"#;
-        tokio::fs::write(codex_home.join(CONFIG_TOML_FILE), seed)
-            .await
-            .expect("seed write");
-
-        persist_overrides(
-            codex_home,
-            Some("team"),
-            &[(&[CONFIG_KEY_EFFORT], "minimal")],
-        )
-        .await
-        .expect("persist");
-
-        let contents = read_config(codex_home).await;
-        let expected = r#"[profiles.team]
-model = "gpt-5"
-model_reasoning_effort = "minimal"
-"#;
-        assert_eq!(contents, expected);
-    }
-
-    /// Verifies `persist_non_null_overrides` skips `None` entries and writes only present values at top-level.
-    #[tokio::test]
-    async fn persist_non_null_skips_none_top_level() {
-        let tmpdir = tempdir().expect("tmp");
-        let codex_home = tmpdir.path();
-
-        persist_non_null_overrides(
-            codex_home,
-            None,
-            &[
-                (&[CONFIG_KEY_MODEL], Some("gpt-5")),
-                (&[CONFIG_KEY_EFFORT], None),
-            ],
-        )
-        .await
-        .expect("persist");
-
-        let contents = read_config(codex_home).await;
-        let expected = "model = \"gpt-5\"\n";
-        assert_eq!(contents, expected);
-    }
-
-    /// Verifies no-op behavior when all provided overrides are `None` (no file created/modified).
-    #[tokio::test]
-    async fn persist_non_null_noop_when_all_none() {
-        let tmpdir = tempdir().expect("tmp");
-        let codex_home = tmpdir.path();
-
-        persist_non_null_overrides(
-            codex_home,
-            None,
-            &[(&["a"], None), (&["profiles", "p", "x"], None)],
-        )
-        .await
-        .expect("persist");
-
-        // Should not create config.toml on a pure no-op
-        assert!(!codex_home.join(CONFIG_TOML_FILE).exists());
-    }
-
-    /// Verifies entries are written under the specified profile and `None` entries are skipped.
-    #[tokio::test]
-    async fn persist_non_null_respects_profile_override() {
-        let tmpdir = tempdir().expect("tmp");
-        let codex_home = tmpdir.path();
-
-        persist_non_null_overrides(
-            codex_home,
-            Some("team"),
-            &[
-                (&[CONFIG_KEY_MODEL], Some("o3")),
-                (&[CONFIG_KEY_EFFORT], None),
-            ],
-        )
-        .await
-        .expect("persist");
-
-        let contents = read_config(codex_home).await;
-        let expected = r#"[profiles.team]
-model = "o3"
-"#;
-        assert_eq!(contents, expected);
-    }
-
-    // Test helper moved to bottom per review guidance.
-    async fn read_config(codex_home: &Path) -> String {
-        let p = codex_home.join(CONFIG_TOML_FILE);
-        tokio::fs::read_to_string(p).await.unwrap_or_default()
-    }
-}

codex-rs/core/src/conversation_history.rs

@@ -1,4 +1,3 @@
-use codex_protocol::models::ContentItem;
 use codex_protocol::models::ResponseItem;
 
 /// Transcript of conversation history
@@ -60,26 +59,6 @@ impl ConversationHistory {
         kept.reverse();
         self.items = kept;
     }
-
-    pub(crate) fn last_agent_message(&self) -> String {
-        for item in self.items.iter().rev() {
-            if let ResponseItem::Message { role, content, .. } = item
-                && role == "assistant"
-            {
-                return content
-                    .iter()
-                    .find_map(|ci| {
-                        if let ContentItem::OutputText { text } = ci {
-                            Some(text.clone())
-                        } else {
-                            None
-                        }
-                    })
-                    .unwrap_or_default();
-            }
-        }
-        String::new()
-    }
 }
 
 /// Anything that is not a system message or "reasoning" message is considered

codex-rs/core/src/conversation_manager.rs

@@ -10,16 +10,65 @@ use crate::error::Result as CodexResult;
 use crate::protocol::Event;
 use crate::protocol::EventMsg;
 use crate::protocol::SessionConfiguredEvent;
+use crate::rollout::RolloutItem;
 use crate::rollout::RolloutRecorder;
+use crate::rollout::recorder::RolloutItemSliceExt;
 use codex_protocol::mcp_protocol::ConversationId;
 use codex_protocol::models::ResponseItem;
-use codex_protocol::protocol::InitialHistory;
-use codex_protocol::protocol::RolloutItem;
 use std::collections::HashMap;
 use std::path::PathBuf;
 use std::sync::Arc;
 use tokio::sync::RwLock;
 
+#[derive(Debug, Clone)]
+pub struct ResumedHistory {
+    pub conversation_id: ConversationId,
+    pub history: Vec<RolloutItem>,
+    pub rollout_path: PathBuf,
+}
+
+#[derive(Debug, Clone)]
+pub enum InitialHistory {
+    New,
+    Resumed(ResumedHistory),
+    Forked(Vec<ResponseItem>),
+}
+
+impl PartialEq for InitialHistory {
+    fn eq(&self, other: &Self) -> bool {
+        match (self, other) {
+            (InitialHistory::New, InitialHistory::New) => true,
+            (InitialHistory::Forked(a), InitialHistory::Forked(b)) => a == b,
+            (InitialHistory::Resumed(_), InitialHistory::Resumed(_)) => true,
+            _ => false,
+        }
+    }
+}
+
+impl InitialHistory {
+    /// Return all response items contained in this initial history.
+    pub fn get_response_items(&self) -> Vec<ResponseItem> {
+        match self {
+            InitialHistory::New => Vec::new(),
+            InitialHistory::Forked(_) => Vec::new(),
+            InitialHistory::Resumed(items) => {
+                <[_] as RolloutItemSliceExt>::get_response_items(items.history.as_slice())
+            }
+        }
+    }
+
+    /// Return all events contained in this initial history.
+    pub fn get_events(&self) -> Vec<crate::protocol::EventMsg> {
+        match self {
+            InitialHistory::New => Vec::new(),
+            InitialHistory::Forked(_) => Vec::new(),
+            InitialHistory::Resumed(items) => {
+                <[_] as RolloutItemSliceExt>::get_events(items.history.as_slice())
+            }
+        }
+    }
+}
+
 /// Represents a newly created Codex conversation, including the first event
 /// (which is [`EventMsg::SessionConfigured`]).
 pub struct NewConversation {
@@ -133,15 +182,8 @@ impl ConversationManager {
         self.finalize_spawn(codex, conversation_id).await
     }
 
-    /// Removes the conversation from the manager's internal map, though the
-    /// conversation is stored as `Arc<CodexConversation>`, it is possible that
-    /// other references to it exist elsewhere. Returns the conversation if the
-    /// conversation was found and removed.
-    pub async fn remove_conversation(
-        &self,
-        conversation_id: &ConversationId,
-    ) -> Option<Arc<CodexConversation>> {
-        self.conversations.write().await.remove(conversation_id)
+    pub async fn remove_conversation(&self, conversation_id: ConversationId) {
+        self.conversations.write().await.remove(&conversation_id);
     }
 
     /// Fork an existing conversation by dropping the last `drop_last_messages`
@@ -150,58 +192,74 @@ impl ConversationManager {
     /// caller's `config`). The new conversation will have a fresh id.
     pub async fn fork_conversation(
         &self,
+        base_rollout_path: PathBuf,
+        _base_conversation_id: ConversationId,
         num_messages_to_drop: usize,
         config: Config,
-        path: PathBuf,
     ) -> CodexResult<NewConversation> {
-        // Compute the prefix up to the cut point.
-        let history = RolloutRecorder::get_rollout_history(&path).await?;
-        let history = truncate_after_dropping_last_messages(history, num_messages_to_drop);
+        // Read prior responses from the rollout file (tolerate both tagged and legacy formats).
+        let text = tokio::fs::read_to_string(&base_rollout_path)
+            .await
+            .map_err(|e| CodexErr::Io(std::io::Error::other(format!("read rollout: {e}"))))?;
+        let mut responses: Vec<ResponseItem> = Vec::new();
+        for line in text.lines() {
+            if line.trim().is_empty() {
+                continue;
+            }
+            let v: serde_json::Value = match serde_json::from_str(line) {
+                Ok(v) => v,
+                Err(_) => continue,
+            };
+            // Only consider response items (legacy lines have no record_type)
+            match v.get("record_type").and_then(|s| s.as_str()) {
+                Some("response") | None => {
+                    if let Ok(item) = serde_json::from_value::<ResponseItem>(v) {
+                        responses.push(item);
+                    }
+                }
+                _ => {}
+            }
+        }
+
+        let kept = truncate_after_dropping_last_messages(responses, num_messages_to_drop);
 
         // Spawn a new conversation with the computed initial history.
         let auth_manager = self.auth_manager.clone();
         let CodexSpawnOk {
             codex,
             conversation_id,
-        } = Codex::spawn(config, auth_manager, history).await?;
-
+        } = Codex::spawn(config, auth_manager, kept).await?;
         self.finalize_spawn(codex, conversation_id).await
     }
 }
 
 /// Return a prefix of `items` obtained by dropping the last `n` user messages
 /// and all items that follow them.
-fn truncate_after_dropping_last_messages(history: InitialHistory, n: usize) -> InitialHistory {
+fn truncate_after_dropping_last_messages(items: Vec<ResponseItem>, n: usize) -> InitialHistory {
     if n == 0 {
-        return InitialHistory::Forked(history.get_rollout_items());
+        return InitialHistory::Forked(items);
     }
 
-    // Work directly on rollout items, and cut the vector at the nth-from-last user message input.
-    let items: Vec<RolloutItem> = history.get_rollout_items();
-
-    // Find indices of user message inputs in rollout order.
-    let mut user_positions: Vec<usize> = Vec::new();
-    for (idx, item) in items.iter().enumerate() {
-        if let RolloutItem::ResponseItem(ResponseItem::Message { role, .. }) = item
+    // Walk backwards counting only `user` Message items, find cut index.
+    let mut count = 0usize;
+    let mut cut_index = 0usize;
+    for (idx, item) in items.iter().enumerate().rev() {
+        if let ResponseItem::Message { role, .. } = item
             && role == "user"
         {
-            user_positions.push(idx);
+            count += 1;
+            if count == n {
+                // Cut everything from this user message to the end.
+                cut_index = idx;
+                break;
+            }
         }
     }
-
-    // If fewer than n user messages exist, treat as empty.
-    if user_positions.len() < n {
-        return InitialHistory::New;
-    }
-
-    // Cut strictly before the nth-from-last user message (do not keep the nth itself).
-    let cut_idx = user_positions[user_positions.len() - n];
-    let rolled: Vec<RolloutItem> = items.into_iter().take(cut_idx).collect();
-
-    if rolled.is_empty() {
+    if cut_index == 0 {
+        // No prefix remains after dropping; start a new conversation.
         InitialHistory::New
     } else {
-        InitialHistory::Forked(rolled)
+        InitialHistory::Forked(items.into_iter().take(cut_index).collect())
     }
 }
 
@@ -256,30 +314,13 @@ mod tests {
             assistant_msg("a4"),
         ];
 
-        // Wrap as InitialHistory::Forked with response items only.
-        let initial: Vec<RolloutItem> = items
-            .iter()
-            .cloned()
-            .map(RolloutItem::ResponseItem)
-            .collect();
-        let truncated = truncate_after_dropping_last_messages(InitialHistory::Forked(initial), 1);
-        let got_items = truncated.get_rollout_items();
-        let expected_items = vec![
-            RolloutItem::ResponseItem(items[0].clone()),
-            RolloutItem::ResponseItem(items[1].clone()),
-            RolloutItem::ResponseItem(items[2].clone()),
-        ];
+        let truncated = truncate_after_dropping_last_messages(items.clone(), 1);
         assert_eq!(
-            serde_json::to_value(&got_items).unwrap(),
-            serde_json::to_value(&expected_items).unwrap()
+            truncated,
+            InitialHistory::Forked(vec![items[0].clone(), items[1].clone(), items[2].clone(),])
         );
 
-        let initial2: Vec<RolloutItem> = items
-            .iter()
-            .cloned()
-            .map(RolloutItem::ResponseItem)
-            .collect();
-        let truncated2 = truncate_after_dropping_last_messages(InitialHistory::Forked(initial2), 2);
+        let truncated2 = truncate_after_dropping_last_messages(items, 2);
         assert!(matches!(truncated2, InitialHistory::New));
     }
 }

codex-rs/core/src/default_client.rs

@@ -1,123 +1,38 @@
-use reqwest::header::HeaderValue;
-use std::sync::LazyLock;
-use std::sync::Mutex;
+pub const DEFAULT_ORIGINATOR: &str = "codex_cli_rs";
 
-/// Set this to add a suffix to the User-Agent string.
-///
-/// It is not ideal that we're using a global singleton for this.
-/// This is primarily designed to differentiate MCP clients from each other.
-/// Because there can only be one MCP server per process, it should be safe for this to be a global static.
-/// However, future users of this should use this with caution as a result.
-/// In addition, we want to be confident that this value is used for ALL clients and doing that requires a
-/// lot of wiring and it's easy to miss code paths by doing so.
-/// See https://github.com/openai/codex/pull/3388/files for an example of what that would look like.
-/// Finally, we want to make sure this is set for ALL mcp clients without needing to know a special env var
-/// or having to set data that they already specified in the mcp initialize request somewhere else.
-///
-/// A space is automatically added between the suffix and the rest of the User-Agent string.
-/// The full user agent string is returned from the mcp initialize response.
-/// Parenthesis will be added by Codex. This should only specify what goes inside of the parenthesis.
-pub static USER_AGENT_SUFFIX: LazyLock<Mutex<Option<String>>> = LazyLock::new(|| Mutex::new(None));
-
-pub const CODEX_INTERNAL_ORIGINATOR_OVERRIDE_ENV_VAR: &str = "CODEX_INTERNAL_ORIGINATOR_OVERRIDE";
-
-#[derive(Debug, Clone)]
-pub struct Originator {
-    pub value: String,
-    pub header_value: HeaderValue,
-}
-
-pub static ORIGINATOR: LazyLock<Originator> = LazyLock::new(|| {
-    let default = "codex_cli_rs";
-    let value = std::env::var(CODEX_INTERNAL_ORIGINATOR_OVERRIDE_ENV_VAR)
-        .unwrap_or_else(|_| default.to_string());
-
-    match HeaderValue::from_str(&value) {
-        Ok(header_value) => Originator {
-            value,
-            header_value,
-        },
-        Err(e) => {
-            tracing::error!("Unable to turn originator override {value} into header value: {e}");
-            Originator {
-                value: default.to_string(),
-                header_value: HeaderValue::from_static(default),
-            }
-        }
-    }
-});
-
-pub fn get_codex_user_agent() -> String {
+pub fn get_codex_user_agent(originator: Option<&str>) -> String {
     let build_version = env!("CARGO_PKG_VERSION");
     let os_info = os_info::get();
-    let prefix = format!(
+    format!(
         "{}/{build_version} ({} {}; {}) {}",
-        ORIGINATOR.value.as_str(),
+        originator.unwrap_or(DEFAULT_ORIGINATOR),
         os_info.os_type(),
         os_info.version(),
         os_info.architecture().unwrap_or("unknown"),
         crate::terminal::user_agent()
-    );
-    let suffix = USER_AGENT_SUFFIX
-        .lock()
-        .ok()
-        .and_then(|guard| guard.clone());
-    let suffix = suffix
-        .as_deref()
-        .map(str::trim)
-        .filter(|value| !value.is_empty())
-        .map_or_else(String::new, |value| format!(" ({value})"));
-
-    let candidate = format!("{prefix}{suffix}");
-    sanitize_user_agent(candidate, &prefix)
-}
-
-/// Sanitize the user agent string.
-///
-/// Invalid characters are replaced with an underscore.
-///
-/// If the user agent fails to parse, it falls back to fallback and then to ORIGINATOR.
-fn sanitize_user_agent(candidate: String, fallback: &str) -> String {
-    if HeaderValue::from_str(candidate.as_str()).is_ok() {
-        return candidate;
-    }
-
-    let sanitized: String = candidate
-        .chars()
-        .map(|ch| if matches!(ch, ' '..='~') { ch } else { '_' })
-        .collect();
-    if !sanitized.is_empty() && HeaderValue::from_str(sanitized.as_str()).is_ok() {
-        tracing::warn!(
-            "Sanitized Codex user agent because provided suffix contained invalid header characters"
-        );
-        sanitized
-    } else if HeaderValue::from_str(fallback).is_ok() {
-        tracing::warn!(
-            "Falling back to base Codex user agent because provided suffix could not be sanitized"
-        );
-        fallback.to_string()
-    } else {
-        tracing::warn!(
-            "Falling back to default Codex originator because base user agent string is invalid"
-        );
-        ORIGINATOR.value.clone()
-    }
+    )
 }
 
 /// Create a reqwest client with default `originator` and `User-Agent` headers set.
-pub fn create_client() -> reqwest::Client {
+pub fn create_client(originator: &str) -> reqwest::Client {
     use reqwest::header::HeaderMap;
+    use reqwest::header::HeaderValue;
 
     let mut headers = HeaderMap::new();
-    headers.insert("originator", ORIGINATOR.header_value.clone());
-    let ua = get_codex_user_agent();
+    let originator_value = HeaderValue::from_str(originator)
+        .unwrap_or_else(|_| HeaderValue::from_static(DEFAULT_ORIGINATOR));
+    headers.insert("originator", originator_value);
+    let ua = get_codex_user_agent(Some(originator));
 
-    reqwest::Client::builder()
+    match reqwest::Client::builder()
         // Set UA via dedicated helper to avoid header validation pitfalls
         .user_agent(ua)
         .default_headers(headers)
         .build()
-        .unwrap_or_else(|_| reqwest::Client::new())
+    {
+        Ok(client) => client,
+        Err(_) => reqwest::Client::new(),
+    }
 }
 
 #[cfg(test)]
@@ -126,7 +41,7 @@ mod tests {
 
     #[test]
     fn test_get_codex_user_agent() {
-        let user_agent = get_codex_user_agent();
+        let user_agent = get_codex_user_agent(None);
         assert!(user_agent.starts_with("codex_cli_rs/"));
     }
 
@@ -138,7 +53,8 @@ mod tests {
         use wiremock::matchers::method;
         use wiremock::matchers::path;
 
-        let client = create_client();
+        let originator = "test_originator";
+        let client = create_client(originator);
 
         // Spin up a local mock server and capture a request.
         let server = MockServer::start().await;
@@ -166,43 +82,21 @@ mod tests {
         let originator_header = headers
             .get("originator")
             .expect("originator header missing");
-        assert_eq!(originator_header.to_str().unwrap(), "codex_cli_rs");
+        assert_eq!(originator_header.to_str().unwrap(), originator);
 
         // User-Agent matches the computed Codex UA for that originator
-        let expected_ua = get_codex_user_agent();
+        let expected_ua = get_codex_user_agent(Some(originator));
         let ua_header = headers
             .get("user-agent")
             .expect("user-agent header missing");
         assert_eq!(ua_header.to_str().unwrap(), expected_ua);
     }
 
-    #[test]
-    fn test_invalid_suffix_is_sanitized() {
-        let prefix = "codex_cli_rs/0.0.0";
-        let suffix = "bad\rsuffix";
-
-        assert_eq!(
-            sanitize_user_agent(format!("{prefix} ({suffix})"), prefix),
-            "codex_cli_rs/0.0.0 (bad_suffix)"
-        );
-    }
-
-    #[test]
-    fn test_invalid_suffix_is_sanitized2() {
-        let prefix = "codex_cli_rs/0.0.0";
-        let suffix = "bad\0suffix";
-
-        assert_eq!(
-            sanitize_user_agent(format!("{prefix} ({suffix})"), prefix),
-            "codex_cli_rs/0.0.0 (bad_suffix)"
-        );
-    }
-
     #[test]
     #[cfg(target_os = "macos")]
     fn test_macos() {
         use regex_lite::Regex;
-        let user_agent = get_codex_user_agent();
+        let user_agent = get_codex_user_agent(None);
         let re = Regex::new(
             r"^codex_cli_rs/\d+\.\d+\.\d+ \(Mac OS \d+\.\d+\.\d+; (x86_64|arm64)\) (\S+)$",
         )

codex-rs/core/src/environment_context.rs

@@ -26,7 +26,6 @@ pub(crate) struct EnvironmentContext {
     pub approval_policy: Option<AskForApproval>,
     pub sandbox_mode: Option<SandboxMode>,
     pub network_access: Option<NetworkAccess>,
-    pub writable_roots: Option<Vec<PathBuf>>,
     pub shell: Option<Shell>,
 }
 
@@ -58,16 +57,6 @@ impl EnvironmentContext {
                 }
                 None => None,
             },
-            writable_roots: match sandbox_policy {
-                Some(SandboxPolicy::WorkspaceWrite { writable_roots, .. }) => {
-                    if writable_roots.is_empty() {
-                        None
-                    } else {
-                        Some(writable_roots)
-                    }
-                }
-                _ => None,
-            },
             shell,
         }
     }
@@ -83,7 +72,6 @@ impl EnvironmentContext {
     ///   <cwd>...</cwd>
     ///   <approval_policy>...</approval_policy>
     ///   <sandbox_mode>...</sandbox_mode>
-    ///   <writable_roots>...</writable_roots>
     ///   <network_access>...</network_access>
     ///   <shell>...</shell>
     /// </environment_context>
@@ -106,16 +94,6 @@ impl EnvironmentContext {
                 "  <network_access>{network_access}</network_access>"
             ));
         }
-        if let Some(writable_roots) = self.writable_roots {
-            lines.push("  <writable_roots>".to_string());
-            for writable_root in writable_roots {
-                lines.push(format!(
-                    "    <root>{}</root>",
-                    writable_root.to_string_lossy()
-                ));
-            }
-            lines.push("  </writable_roots>".to_string());
-        }
         if let Some(shell) = self.shell
             && let Some(shell_name) = shell.name()
         {
@@ -137,77 +115,3 @@ impl From<EnvironmentContext> for ResponseItem {
         }
     }
 }
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use pretty_assertions::assert_eq;
-
-    fn workspace_write_policy(writable_roots: Vec<&str>, network_access: bool) -> SandboxPolicy {
-        SandboxPolicy::WorkspaceWrite {
-            writable_roots: writable_roots.into_iter().map(PathBuf::from).collect(),
-            network_access,
-            exclude_tmpdir_env_var: false,
-            exclude_slash_tmp: false,
-        }
-    }
-
-    #[test]
-    fn serialize_workspace_write_environment_context() {
-        let context = EnvironmentContext::new(
-            Some(PathBuf::from("/repo")),
-            Some(AskForApproval::OnRequest),
-            Some(workspace_write_policy(vec!["/repo", "/tmp"], false)),
-            None,
-        );
-
-        let expected = r#"<environment_context>
-  <cwd>/repo</cwd>
-  <approval_policy>on-request</approval_policy>
-  <sandbox_mode>workspace-write</sandbox_mode>
-  <network_access>restricted</network_access>
-  <writable_roots>
-    <root>/repo</root>
-    <root>/tmp</root>
-  </writable_roots>
-</environment_context>"#;
-
-        assert_eq!(context.serialize_to_xml(), expected);
-    }
-
-    #[test]
-    fn serialize_read_only_environment_context() {
-        let context = EnvironmentContext::new(
-            None,
-            Some(AskForApproval::Never),
-            Some(SandboxPolicy::ReadOnly),
-            None,
-        );
-
-        let expected = r#"<environment_context>
-  <approval_policy>never</approval_policy>
-  <sandbox_mode>read-only</sandbox_mode>
-  <network_access>restricted</network_access>
-</environment_context>"#;
-
-        assert_eq!(context.serialize_to_xml(), expected);
-    }
-
-    #[test]
-    fn serialize_full_access_environment_context() {
-        let context = EnvironmentContext::new(
-            None,
-            Some(AskForApproval::OnFailure),
-            Some(SandboxPolicy::DangerFullAccess),
-            None,
-        );
-
-        let expected = r#"<environment_context>
-  <approval_policy>on-failure</approval_policy>
-  <sandbox_mode>danger-full-access</sandbox_mode>
-  <network_access>enabled</network_access>
-</environment_context>"#;
-
-        assert_eq!(context.serialize_to_xml(), expected);
-    }
-}

codex-rs/core/src/error.rs

@@ -1,5 +1,3 @@
-use crate::token_data::KnownPlan;
-use crate::token_data::PlanType;
 use codex_protocol::mcp_protocol::ConversationId;
 use reqwest::StatusCode;
 use serde_json;
@@ -129,58 +127,38 @@ pub enum CodexErr {
 
 #[derive(Debug)]
 pub struct UsageLimitReachedError {
-    pub(crate) plan_type: Option<PlanType>,
-    pub(crate) resets_in_seconds: Option<u64>,
+    pub plan_type: Option<String>,
+    pub resets_in_seconds: Option<u64>,
 }
 
 impl std::fmt::Display for UsageLimitReachedError {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        let message = match self.plan_type.as_ref() {
-            Some(PlanType::Known(KnownPlan::Plus)) => format!(
-                "You've hit your usage limit. Upgrade to Pro (https://openai.com/chatgpt/pricing){}",
-                retry_suffix_after_or(self.resets_in_seconds)
-            ),
-            Some(PlanType::Known(KnownPlan::Team)) | Some(PlanType::Known(KnownPlan::Business)) => {
-                format!(
-                    "You've hit your usage limit. To get more access now, send a request to your admin{}",
-                    retry_suffix_after_or(self.resets_in_seconds)
-                )
+        // Base message differs slightly for legacy ChatGPT Plus plan users.
+        if let Some(plan_type) = &self.plan_type
+            && plan_type == "plus"
+        {
+            write!(
+                f,
+                "You've hit your usage limit. Upgrade to Pro (https://openai.com/chatgpt/pricing) or try again"
+            )?;
+            if let Some(secs) = self.resets_in_seconds {
+                let reset_duration = format_reset_duration(secs);
+                write!(f, " in {reset_duration}.")?;
+            } else {
+                write!(f, " later.")?;
             }
-            Some(PlanType::Known(KnownPlan::Free)) => {
-                "To use Codex with your ChatGPT plan, upgrade to Plus: https://openai.com/chatgpt/pricing."
-                    .to_string()
+        } else {
+            write!(f, "You've hit your usage limit.")?;
+
+            if let Some(secs) = self.resets_in_seconds {
+                let reset_duration = format_reset_duration(secs);
+                write!(f, " Try again in {reset_duration}.")?;
+            } else {
+                write!(f, " Try again later.")?;
             }
-            Some(PlanType::Known(KnownPlan::Pro))
-            | Some(PlanType::Known(KnownPlan::Enterprise))
-            | Some(PlanType::Known(KnownPlan::Edu)) => format!(
-                "You've hit your usage limit.{}",
-                retry_suffix(self.resets_in_seconds)
-            ),
-            Some(PlanType::Unknown(_)) | None => format!(
-                "You've hit your usage limit.{}",
-                retry_suffix(self.resets_in_seconds)
-            ),
-        };
+        }
 
-        write!(f, "{message}")
-    }
-}
-
-fn retry_suffix(resets_in_seconds: Option<u64>) -> String {
-    if let Some(secs) = resets_in_seconds {
-        let reset_duration = format_reset_duration(secs);
-        format!(" Try again in {reset_duration}.")
-    } else {
-        " Try again later.".to_string()
-    }
-}
-
-fn retry_suffix_after_or(resets_in_seconds: Option<u64>) -> String {
-    if let Some(secs) = resets_in_seconds {
-        let reset_duration = format_reset_duration(secs);
-        format!(" or try again in {reset_duration}.")
-    } else {
-        " or try again later.".to_string()
+        Ok(())
     }
 }
 
@@ -259,7 +237,7 @@ mod tests {
     #[test]
     fn usage_limit_reached_error_formats_plus_plan() {
         let err = UsageLimitReachedError {
-            plan_type: Some(PlanType::Known(KnownPlan::Plus)),
+            plan_type: Some("plus".to_string()),
             resets_in_seconds: None,
         };
         assert_eq!(
@@ -268,18 +246,6 @@ mod tests {
         );
     }
 
-    #[test]
-    fn usage_limit_reached_error_formats_free_plan() {
-        let err = UsageLimitReachedError {
-            plan_type: Some(PlanType::Known(KnownPlan::Free)),
-            resets_in_seconds: Some(3600),
-        };
-        assert_eq!(
-            err.to_string(),
-            "To use Codex with your ChatGPT plan, upgrade to Plus: https://openai.com/chatgpt/pricing."
-        );
-    }
-
     #[test]
     fn usage_limit_reached_error_formats_default_when_none() {
         let err = UsageLimitReachedError {
@@ -292,34 +258,10 @@ mod tests {
         );
     }
 
-    #[test]
-    fn usage_limit_reached_error_formats_team_plan() {
-        let err = UsageLimitReachedError {
-            plan_type: Some(PlanType::Known(KnownPlan::Team)),
-            resets_in_seconds: Some(3600),
-        };
-        assert_eq!(
-            err.to_string(),
-            "You've hit your usage limit. To get more access now, send a request to your admin or try again in 1 hour."
-        );
-    }
-
-    #[test]
-    fn usage_limit_reached_error_formats_business_plan_without_reset() {
-        let err = UsageLimitReachedError {
-            plan_type: Some(PlanType::Known(KnownPlan::Business)),
-            resets_in_seconds: None,
-        };
-        assert_eq!(
-            err.to_string(),
-            "You've hit your usage limit. To get more access now, send a request to your admin or try again later."
-        );
-    }
-
     #[test]
     fn usage_limit_reached_error_formats_default_for_other_plans() {
         let err = UsageLimitReachedError {
-            plan_type: Some(PlanType::Known(KnownPlan::Pro)),
+            plan_type: Some("pro".to_string()),
             resets_in_seconds: None,
         };
         assert_eq!(
@@ -343,7 +285,7 @@ mod tests {
     #[test]
     fn usage_limit_reached_includes_hours_and_minutes() {
         let err = UsageLimitReachedError {
-            plan_type: Some(PlanType::Known(KnownPlan::Plus)),
+            plan_type: Some("plus".to_string()),
             resets_in_seconds: Some(3 * 3600 + 32 * 60),
         };
         assert_eq!(

codex-rs/core/src/event_mapping.rs

@@ -25,56 +25,31 @@ pub(crate) fn map_response_item_to_event_messages(
                 return Vec::new();
             }
 
-            let mut events: Vec<EventMsg> = Vec::new();
-            let mut message_parts: Vec<String> = Vec::new();
-            let mut images: Vec<String> = Vec::new();
-            let mut kind: Option<InputMessageKind> = None;
-
-            for content_item in content.iter() {
-                match content_item {
-                    ContentItem::InputText { text } => {
-                        if kind.is_none() {
-                            let trimmed = text.trim_start();
-                            kind = if trimmed.starts_with("<environment_context>") {
-                                Some(InputMessageKind::EnvironmentContext)
-                            } else if trimmed.starts_with("<user_instructions>") {
-                                Some(InputMessageKind::UserInstructions)
-                            } else {
-                                Some(InputMessageKind::Plain)
-                            };
-                        }
-                        message_parts.push(text.clone());
-                    }
-                    ContentItem::InputImage { image_url } => {
-                        images.push(image_url.clone());
-                    }
+            let events: Vec<EventMsg> = content
+                .iter()
+                .filter_map(|content_item| match content_item {
                     ContentItem::OutputText { text } => {
-                        events.push(EventMsg::AgentMessage(AgentMessageEvent {
+                        Some(EventMsg::AgentMessage(AgentMessageEvent {
                             message: text.clone(),
-                        }));
+                        }))
                     }
-                }
-            }
-
-            if !message_parts.is_empty() || !images.is_empty() {
-                let message = if message_parts.is_empty() {
-                    String::new()
-                } else {
-                    message_parts.join("")
-                };
-                let images = if images.is_empty() {
-                    None
-                } else {
-                    Some(images)
-                };
-
-                events.push(EventMsg::UserMessage(UserMessageEvent {
-                    message,
-                    kind,
-                    images,
-                }));
-            }
-
+                    ContentItem::InputText { text } => {
+                        let trimmed = text.trim_start();
+                        let kind = if trimmed.starts_with("<environment_context>") {
+                            Some(InputMessageKind::EnvironmentContext)
+                        } else if trimmed.starts_with("<user_instructions>") {
+                            Some(InputMessageKind::UserInstructions)
+                        } else {
+                            Some(InputMessageKind::Plain)
+                        };
+                        Some(EventMsg::UserMessage(UserMessageEvent {
+                            message: text.clone(),
+                            kind,
+                        }))
+                    }
+                    _ => None,
+                })
+                .collect();
             events
         }
 
@@ -121,47 +96,3 @@ pub(crate) fn map_response_item_to_event_messages(
         | ResponseItem::Other => Vec::new(),
     }
 }
-
-#[cfg(test)]
-mod tests {
-    use super::map_response_item_to_event_messages;
-    use crate::protocol::EventMsg;
-    use crate::protocol::InputMessageKind;
-    use codex_protocol::models::ContentItem;
-    use codex_protocol::models::ResponseItem;
-    use pretty_assertions::assert_eq;
-
-    #[test]
-    fn maps_user_message_with_text_and_two_images() {
-        let img1 = "https://example.com/one.png".to_string();
-        let img2 = "https://example.com/two.jpg".to_string();
-
-        let item = ResponseItem::Message {
-            id: None,
-            role: "user".to_string(),
-            content: vec![
-                ContentItem::InputText {
-                    text: "Hello world".to_string(),
-                },
-                ContentItem::InputImage {
-                    image_url: img1.clone(),
-                },
-                ContentItem::InputImage {
-                    image_url: img2.clone(),
-                },
-            ],
-        };
-
-        let events = map_response_item_to_event_messages(&item, false);
-        assert_eq!(events.len(), 1, "expected a single user message event");
-
-        match &events[0] {
-            EventMsg::UserMessage(user) => {
-                assert_eq!(user.message, "Hello world");
-                assert!(matches!(user.kind, Some(InputMessageKind::Plain)));
-                assert_eq!(user.images, Some(vec![img1, img2]));
-            }
-            other => panic!("expected UserMessage, got {other:?}"),
-        }
-    }
-}

codex-rs/core/src/exec_command/exec_command_session.rs

@@ -24,9 +24,6 @@ pub(crate) struct ExecCommandSession {
 
     /// JoinHandle for the child wait task.
     wait_handle: StdMutex<Option<JoinHandle<()>>>,
-
-    /// Tracks whether the underlying process has exited.
-    exit_status: std::sync::Arc<std::sync::atomic::AtomicBool>,
 }
 
 impl ExecCommandSession {
@@ -37,7 +34,6 @@ impl ExecCommandSession {
         reader_handle: JoinHandle<()>,
         writer_handle: JoinHandle<()>,
         wait_handle: JoinHandle<()>,
-        exit_status: std::sync::Arc<std::sync::atomic::AtomicBool>,
     ) -> Self {
         Self {
             writer_tx,
@@ -46,7 +42,6 @@ impl ExecCommandSession {
             reader_handle: StdMutex::new(Some(reader_handle)),
             writer_handle: StdMutex::new(Some(writer_handle)),
             wait_handle: StdMutex::new(Some(wait_handle)),
-            exit_status,
         }
     }
 
@@ -57,10 +52,6 @@ impl ExecCommandSession {
     pub(crate) fn output_receiver(&self) -> broadcast::Receiver<Vec<u8>> {
         self.output_tx.subscribe()
     }
-
-    pub(crate) fn has_exited(&self) -> bool {
-        self.exit_status.load(std::sync::atomic::Ordering::SeqCst)
-    }
 }
 
 impl Drop for ExecCommandSession {

codex-rs/core/src/exec_command/mod.rs

@@ -6,7 +6,6 @@ mod session_manager;
 
 pub use exec_command_params::ExecCommandParams;
 pub use exec_command_params::WriteStdinParams;
-pub(crate) use exec_command_session::ExecCommandSession;
 pub use responses_api::EXEC_COMMAND_TOOL_NAME;
 pub use responses_api::WRITE_STDIN_TOOL_NAME;
 pub use responses_api::create_exec_command_tool_for_responses_api;

codex-rs/core/src/exec_command/session_manager.rs

@@ -3,7 +3,6 @@ use std::io::ErrorKind;
 use std::io::Read;
 use std::sync::Arc;
 use std::sync::Mutex as StdMutex;
-use std::sync::atomic::AtomicBool;
 use std::sync::atomic::AtomicU32;
 
 use portable_pty::CommandBuilder;
@@ -20,7 +19,6 @@ use crate::exec_command::exec_command_params::ExecCommandParams;
 use crate::exec_command::exec_command_params::WriteStdinParams;
 use crate::exec_command::exec_command_session::ExecCommandSession;
 use crate::exec_command::session_id::SessionId;
-use crate::truncate::truncate_middle;
 use codex_protocol::models::FunctionCallOutputPayload;
 
 #[derive(Debug, Default)]
@@ -329,14 +327,11 @@ async fn create_exec_command_session(
 
     // Keep the child alive until it exits, then signal exit code.
     let (exit_tx, exit_rx) = oneshot::channel::<i32>();
-    let exit_status = Arc::new(AtomicBool::new(false));
-    let wait_exit_status = exit_status.clone();
     let wait_handle = tokio::task::spawn_blocking(move || {
         let code = match child.wait() {
             Ok(status) => status.exit_code() as i32,
             Err(_) => -1,
         };
-        wait_exit_status.store(true, std::sync::atomic::Ordering::SeqCst);
         let _ = exit_tx.send(code);
     });
 
@@ -348,11 +343,116 @@ async fn create_exec_command_session(
         reader_handle,
         writer_handle,
         wait_handle,
-        exit_status,
     );
     Ok((session, exit_rx))
 }
 
+/// Truncate the middle of a UTF-8 string to at most `max_bytes` bytes,
+/// preserving the beginning and the end. Returns the possibly truncated
+/// string and `Some(original_token_count)` (estimated at 4 bytes/token)
+/// if truncation occurred; otherwise returns the original string and `None`.
+fn truncate_middle(s: &str, max_bytes: usize) -> (String, Option<u64>) {
+    // No truncation needed
+    if s.len() <= max_bytes {
+        return (s.to_string(), None);
+    }
+    let est_tokens = (s.len() as u64).div_ceil(4);
+    if max_bytes == 0 {
+        // Cannot keep any content; still return a full marker (never truncated).
+        return (format!("…{est_tokens} tokens truncated…"), Some(est_tokens));
+    }
+
+    // Helper to truncate a string to a given byte length on a char boundary.
+    fn truncate_on_boundary(input: &str, max_len: usize) -> &str {
+        if input.len() <= max_len {
+            return input;
+        }
+        let mut end = max_len;
+        while end > 0 && !input.is_char_boundary(end) {
+            end -= 1;
+        }
+        &input[..end]
+    }
+
+    // Given a left/right budget, prefer newline boundaries; otherwise fall back
+    // to UTF-8 char boundaries.
+    fn pick_prefix_end(s: &str, left_budget: usize) -> usize {
+        if let Some(head) = s.get(..left_budget)
+            && let Some(i) = head.rfind('\n')
+        {
+            return i + 1; // keep the newline so suffix starts on a fresh line
+        }
+        truncate_on_boundary(s, left_budget).len()
+    }
+
+    fn pick_suffix_start(s: &str, right_budget: usize) -> usize {
+        let start_tail = s.len().saturating_sub(right_budget);
+        if let Some(tail) = s.get(start_tail..)
+            && let Some(i) = tail.find('\n')
+        {
+            return start_tail + i + 1; // start after newline
+        }
+        // Fall back to a char boundary at or after start_tail.
+        let mut idx = start_tail.min(s.len());
+        while idx < s.len() && !s.is_char_boundary(idx) {
+            idx += 1;
+        }
+        idx
+    }
+
+    // Refine marker length and budgets until stable. Marker is never truncated.
+    let mut guess_tokens = est_tokens; // worst-case: everything truncated
+    for _ in 0..4 {
+        let marker = format!("…{guess_tokens} tokens truncated…");
+        let marker_len = marker.len();
+        let keep_budget = max_bytes.saturating_sub(marker_len);
+        if keep_budget == 0 {
+            // No room for any content within the cap; return a full, untruncated marker
+            // that reflects the entire truncated content.
+            return (format!("…{est_tokens} tokens truncated…"), Some(est_tokens));
+        }
+
+        let left_budget = keep_budget / 2;
+        let right_budget = keep_budget - left_budget;
+        let prefix_end = pick_prefix_end(s, left_budget);
+        let mut suffix_start = pick_suffix_start(s, right_budget);
+        if suffix_start < prefix_end {
+            suffix_start = prefix_end;
+        }
+        let kept_content_bytes = prefix_end + (s.len() - suffix_start);
+        let truncated_content_bytes = s.len().saturating_sub(kept_content_bytes);
+        let new_tokens = (truncated_content_bytes as u64).div_ceil(4);
+        if new_tokens == guess_tokens {
+            let mut out = String::with_capacity(marker_len + kept_content_bytes + 1);
+            out.push_str(&s[..prefix_end]);
+            out.push_str(&marker);
+            // Place marker on its own line for symmetry when we keep line boundaries.
+            out.push('\n');
+            out.push_str(&s[suffix_start..]);
+            return (out, Some(est_tokens));
+        }
+        guess_tokens = new_tokens;
+    }
+
+    // Fallback: use last guess to build output.
+    let marker = format!("…{guess_tokens} tokens truncated…");
+    let marker_len = marker.len();
+    let keep_budget = max_bytes.saturating_sub(marker_len);
+    if keep_budget == 0 {
+        return (format!("…{est_tokens} tokens truncated…"), Some(est_tokens));
+    }
+    let left_budget = keep_budget / 2;
+    let right_budget = keep_budget - left_budget;
+    let prefix_end = pick_prefix_end(s, left_budget);
+    let suffix_start = pick_suffix_start(s, right_budget);
+    let mut out = String::with_capacity(marker_len + prefix_end + (s.len() - suffix_start) + 1);
+    out.push_str(&s[..prefix_end]);
+    out.push_str(&marker);
+    out.push('\n');
+    out.push_str(&s[suffix_start..]);
+    (out, Some(est_tokens))
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -516,4 +616,50 @@ Output:
 abc"#;
         assert_eq!(expected, text);
     }
+
+    #[test]
+    fn truncate_middle_no_newlines_fallback() {
+        // A long string with no newlines that exceeds the cap.
+        let s = "abcdefghijklmnopqrstuvwxyz0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ";
+        let max_bytes = 16; // force truncation
+        let (out, original) = truncate_middle(s, max_bytes);
+        // For very small caps, we return the full, untruncated marker,
+        // even if it exceeds the cap.
+        assert_eq!(out, "…16 tokens truncated…");
+        // Original string length is 62 bytes => ceil(62/4) = 16 tokens.
+        assert_eq!(original, Some(16));
+    }
+
+    #[test]
+    fn truncate_middle_prefers_newline_boundaries() {
+        // Build a multi-line string of 20 numbered lines (each "NNN\n").
+        let mut s = String::new();
+        for i in 1..=20 {
+            s.push_str(&format!("{i:03}\n"));
+        }
+        // Total length: 20 lines * 4 bytes per line = 80 bytes.
+        assert_eq!(s.len(), 80);
+
+        // Choose a cap that forces truncation while leaving room for
+        // a few lines on each side after accounting for the marker.
+        let max_bytes = 64;
+        // Expect exact output: first 4 lines, marker, last 4 lines, and correct token estimate (80/4 = 20).
+        assert_eq!(
+            truncate_middle(&s, max_bytes),
+            (
+                r#"001
+002
+003
+004
+…12 tokens truncated…
+017
+018
+019
+020
+"#
+                .to_string(),
+                Some(20)
+            )
+        );
+    }
 }

codex-rs/core/src/git_info.rs

@@ -3,7 +3,6 @@ use std::path::Path;
 use std::path::PathBuf;
 
 use codex_protocol::mcp_protocol::GitSha;
-use codex_protocol::protocol::GitInfo;
 use futures::future::join_all;
 use serde::Deserialize;
 use serde::Serialize;
@@ -44,6 +43,19 @@ pub fn get_git_repo_root(base_dir: &Path) -> Option<PathBuf> {
 /// Timeout for git commands to prevent freezing on large repositories
 const GIT_COMMAND_TIMEOUT: TokioDuration = TokioDuration::from_secs(5);
 
+#[derive(Serialize, Deserialize, Clone, Debug)]
+pub struct GitInfo {
+    /// Current commit hash (SHA)
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub commit_hash: Option<String>,
+    /// Current branch name
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub branch: Option<String>,
+    /// Repository URL (if available from remote)
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub repository_url: Option<String>,
+}
+
 #[derive(Serialize, Deserialize, Clone, Debug)]
 pub struct GitDiffToRemote {
     pub sha: GitSha,
@@ -802,7 +814,7 @@ mod tests {
     async fn resolve_root_git_project_for_trust_regular_repo_returns_repo_root() {
         let temp_dir = TempDir::new().expect("Failed to create temp dir");
         let repo_path = create_test_git_repo(&temp_dir).await;
-        let expected = std::fs::canonicalize(&repo_path).unwrap();
+        let expected = std::fs::canonicalize(&repo_path).unwrap().to_path_buf();
 
         assert_eq!(
             resolve_root_git_project_for_trust(&repo_path),
@@ -810,7 +822,10 @@ mod tests {
         );
         let nested = repo_path.join("sub/dir");
         std::fs::create_dir_all(&nested).unwrap();
-        assert_eq!(resolve_root_git_project_for_trust(&nested), Some(expected));
+        assert_eq!(
+            resolve_root_git_project_for_trust(&nested),
+            Some(expected.clone())
+        );
     }
 
     #[tokio::test]

codex-rs/core/src/internal_storage.rs

@@ -1,68 +0,0 @@
-use anyhow::Context;
-use serde::Deserialize;
-use serde::Serialize;
-use std::path::Path;
-use std::path::PathBuf;
-
-pub(crate) const INTERNAL_STORAGE_FILE: &str = "internal_storage.json";
-
-#[derive(Debug, Default, Clone, Serialize, Deserialize)]
-pub struct InternalStorage {
-    #[serde(skip)]
-    storage_path: PathBuf,
-    #[serde(default)]
-    pub gpt_5_high_model_prompt_seen: bool,
-}
-
-// TODO(jif) generalise all the file writers and build proper async channel inserters.
-impl InternalStorage {
-    pub fn load(codex_home: &Path) -> Self {
-        let storage_path = codex_home.join(INTERNAL_STORAGE_FILE);
-
-        match std::fs::read_to_string(&storage_path) {
-            Ok(serialized) => match serde_json::from_str::<Self>(&serialized) {
-                Ok(mut storage) => {
-                    storage.storage_path = storage_path;
-                    storage
-                }
-                Err(error) => {
-                    tracing::warn!("failed to parse internal storage: {error:?}");
-                    Self::empty(storage_path)
-                }
-            },
-            Err(error) => {
-                tracing::warn!("failed to read internal storage: {error:?}");
-                Self::empty(storage_path)
-            }
-        }
-    }
-
-    fn empty(storage_path: PathBuf) -> Self {
-        Self {
-            storage_path,
-            ..Default::default()
-        }
-    }
-
-    pub async fn persist(&self) -> anyhow::Result<()> {
-        let serialized = serde_json::to_string_pretty(self)?;
-
-        if let Some(parent) = self.storage_path.parent() {
-            tokio::fs::create_dir_all(parent).await.with_context(|| {
-                format!(
-                    "failed to create internal storage directory at {}",
-                    parent.display()
-                )
-            })?;
-        }
-
-        tokio::fs::write(&self.storage_path, serialized)
-            .await
-            .with_context(|| {
-                format!(
-                    "failed to persist internal storage at {}",
-                    self.storage_path.display()
-                )
-            })
-    }
-}

codex-rs/core/src/lib.rs

@@ -16,7 +16,6 @@ mod codex_conversation;
 pub mod token_data;
 pub use codex_conversation::CodexConversation;
 pub mod config;
-pub mod config_edit;
 pub mod config_profile;
 pub mod config_types;
 mod conversation_history;
@@ -28,7 +27,6 @@ mod exec_command;
 pub mod exec_env;
 mod flags;
 pub mod git_info;
-pub mod internal_storage;
 mod is_safe_command;
 pub mod landlock;
 mod mcp_connection_manager;
@@ -36,8 +34,6 @@ mod mcp_tool_call;
 mod message_history;
 mod model_provider_info;
 pub mod parse_command;
-mod truncate;
-mod unified_exec;
 mod user_instructions;
 pub use model_provider_info::BUILT_IN_OSS_MODEL_PROVIDER_ID;
 pub use model_provider_info::ModelProviderInfo;
@@ -46,7 +42,6 @@ pub use model_provider_info::built_in_model_providers;
 pub use model_provider_info::create_oss_provider_with_base_url;
 mod conversation_manager;
 mod event_mapping;
-pub use codex_protocol::protocol::InitialHistory;
 pub use conversation_manager::ConversationManager;
 pub use conversation_manager::NewConversation;
 // Re-export common auth types for workspace consumers
@@ -66,16 +61,13 @@ pub mod spawn;
 pub mod terminal;
 mod tool_apply_patch;
 pub mod turn_diff_tracker;
-pub use rollout::ARCHIVED_SESSIONS_SUBDIR;
 pub use rollout::RolloutRecorder;
-pub use rollout::SESSIONS_SUBDIR;
 pub use rollout::SessionMeta;
 pub use rollout::list::ConversationItem;
 pub use rollout::list::ConversationsPage;
 pub use rollout::list::Cursor;
 mod user_notification;
 pub mod util;
-
 pub use apply_patch::CODEX_APPLY_PATCH_ARG1;
 pub use safety::get_platform_sandbox;
 // Re-export the protocol types from the standalone `codex-protocol` crate so existing

codex-rs/core/src/mcp_connection_manager.rs

@@ -163,10 +163,6 @@ impl McpConnectionManager {
                                 name: "codex-mcp-client".to_owned(),
                                 version: env!("CARGO_PKG_VERSION").to_owned(),
                                 title: Some("Codex".into()),
-                                // This field is used by Codex when it is an MCP
-                                // server: it should not be used when Codex is
-                                // an MCP client.
-                                user_agent: None,
                             },
                             protocol_version: mcp_types::MCP_SCHEMA_VERSION.to_owned(),
                         };

codex-rs/core/src/model_family.rs

@@ -103,7 +103,7 @@ pub fn find_family_for_model(slug: &str) -> Option<ModelFamily> {
             slug, "gpt-4.1",
             needs_special_apply_patch_instructions: true,
         )
-    } else if slug.starts_with("gpt-oss") || slug.starts_with("openai/gpt-oss") {
+    } else if slug.starts_with("gpt-oss") {
         model_family!(slug, "gpt-oss", apply_patch_tool_type: Some(ApplyPatchToolType::Function))
     } else if slug.starts_with("gpt-4o") {
         simple_model_family!(slug, "gpt-4o")

codex-rs/core/src/model_provider_info.rs

@@ -80,10 +80,7 @@ pub struct ModelProviderInfo {
     /// the connection as lost.
     pub stream_idle_timeout_ms: Option<u64>,
 
-    /// Does this provider require an OpenAI API Key or ChatGPT login token? If true,
-    /// user is presented with login screen on first run, and login preference and token/key
-    /// are stored in auth.json. If false (which is the default), login screen is skipped,
-    /// and API key (if needed) comes from the "env_key" environment variable.
+    /// Whether this provider requires some form of standard authentication (API key, ChatGPT token).
     #[serde(default)]
     pub requires_openai_auth: bool,
 }

codex-rs/core/src/openai_model_info.rs

@@ -78,7 +78,7 @@ pub(crate) fn get_model_info(model_family: &ModelFamily) -> Option<ModelInfo> {
             max_output_tokens: 4_096,
         }),
 
-        _ if slug.starts_with("gpt-5") => Some(ModelInfo {
+        "gpt-5" => Some(ModelInfo {
             context_window: 272_000,
             max_output_tokens: 128_000,
         }),

codex-rs/core/src/openai_tools.rs

@@ -70,7 +70,6 @@ pub(crate) struct ToolsConfig {
     pub apply_patch_tool_type: Option<ApplyPatchToolType>,
     pub web_search_request: bool,
     pub include_view_image_tool: bool,
-    pub experimental_unified_exec_tool: bool,
 }
 
 pub(crate) struct ToolsConfigParams<'a> {
@@ -82,7 +81,6 @@ pub(crate) struct ToolsConfigParams<'a> {
     pub(crate) include_web_search_request: bool,
     pub(crate) use_streamable_shell_tool: bool,
     pub(crate) include_view_image_tool: bool,
-    pub(crate) experimental_unified_exec_tool: bool,
 }
 
 impl ToolsConfig {
@@ -96,7 +94,6 @@ impl ToolsConfig {
             include_web_search_request,
             use_streamable_shell_tool,
             include_view_image_tool,
-            experimental_unified_exec_tool,
         } = params;
         let mut shell_type = if *use_streamable_shell_tool {
             ConfigShellToolType::StreamableShell
@@ -129,7 +126,6 @@ impl ToolsConfig {
             apply_patch_tool_type,
             web_search_request: *include_web_search_request,
             include_view_image_tool: *include_view_image_tool,
-            experimental_unified_exec_tool: *experimental_unified_exec_tool,
         }
     }
 }
@@ -204,53 +200,6 @@ fn create_shell_tool() -> OpenAiTool {
     })
 }
 
-fn create_unified_exec_tool() -> OpenAiTool {
-    let mut properties = BTreeMap::new();
-    properties.insert(
-        "input".to_string(),
-        JsonSchema::Array {
-            items: Box::new(JsonSchema::String { description: None }),
-            description: Some(
-                "When no session_id is provided, treat the array as the command and arguments \
-                 to launch. When session_id is set, concatenate the strings (in order) and write \
-                 them to the session's stdin."
-                    .to_string(),
-            ),
-        },
-    );
-    properties.insert(
-        "session_id".to_string(),
-        JsonSchema::String {
-            description: Some(
-                "Identifier for an existing interactive session. If omitted, a new command \
-                 is spawned."
-                    .to_string(),
-            ),
-        },
-    );
-    properties.insert(
-        "timeout_ms".to_string(),
-        JsonSchema::Number {
-            description: Some(
-                "Maximum time in milliseconds to wait for output after writing the input."
-                    .to_string(),
-            ),
-        },
-    );
-
-    OpenAiTool::Function(ResponsesApiTool {
-        name: "unified_exec".to_string(),
-        description:
-            "Runs a command in a PTY. Provide a session_id to reuse an existing interactive session.".to_string(),
-        strict: false,
-        parameters: JsonSchema::Object {
-            properties,
-            required: Some(vec!["input".to_string()]),
-            additional_properties: Some(false),
-        },
-    })
-}
-
 fn create_shell_tool_for_sandbox(sandbox_policy: &SandboxPolicy) -> OpenAiTool {
     let mut properties = BTreeMap::new();
     properties.insert(
@@ -291,20 +240,17 @@ fn create_shell_tool_for_sandbox(sandbox_policy: &SandboxPolicy) -> OpenAiTool {
     let description = match sandbox_policy {
         SandboxPolicy::WorkspaceWrite {
             network_access,
+            writable_roots,
             ..
         } => {
-            let network_line = if !network_access {
-                "\n    - Commands that require network access"
-            } else {
-                ""
-            };
-
             format!(
                 r#"
 The shell tool is used to execute shell commands.
 - When invoking the shell tool, your call will be running in a sandbox, and some shell commands will require escalated privileges:
   - Types of actions that require escalated privileges:
-    - Writing files other than those in the writable roots (see the environment context for the allowed directories){network_line}
+    - Writing files other than those in the writable roots
+      - writable roots:
+{}{}
   - Examples of commands that require escalated privileges:
     - git commit
     - npm install or pnpm install
@@ -313,6 +259,12 @@ The shell tool is used to execute shell commands.
 - When invoking a command that will require escalated privileges:
   - Provide the with_escalated_permissions parameter with the boolean value true
   - Include a short, 1 sentence explanation for why we need to run with_escalated_permissions in the justification parameter."#,
+                writable_roots.iter().map(|wr| format!("        - {}", wr.to_string_lossy())).collect::<Vec<String>>().join("\n"),
+                if !network_access {
+                    "\n    - Commands that require network access\n"
+                } else {
+                    ""
+                }
             )
         }
         SandboxPolicy::DangerFullAccess => {
@@ -582,27 +534,23 @@ pub(crate) fn get_openai_tools(
 ) -> Vec<OpenAiTool> {
     let mut tools: Vec<OpenAiTool> = Vec::new();
 
-    if config.experimental_unified_exec_tool {
-        tools.push(create_unified_exec_tool());
-    } else {
-        match &config.shell_type {
-            ConfigShellToolType::DefaultShell => {
-                tools.push(create_shell_tool());
-            }
-            ConfigShellToolType::ShellWithRequest { sandbox_policy } => {
-                tools.push(create_shell_tool_for_sandbox(sandbox_policy));
-            }
-            ConfigShellToolType::LocalShell => {
-                tools.push(OpenAiTool::LocalShell {});
-            }
-            ConfigShellToolType::StreamableShell => {
-                tools.push(OpenAiTool::Function(
-                    crate::exec_command::create_exec_command_tool_for_responses_api(),
-                ));
-                tools.push(OpenAiTool::Function(
-                    crate::exec_command::create_write_stdin_tool_for_responses_api(),
-                ));
-            }
+    match &config.shell_type {
+        ConfigShellToolType::DefaultShell => {
+            tools.push(create_shell_tool());
+        }
+        ConfigShellToolType::ShellWithRequest { sandbox_policy } => {
+            tools.push(create_shell_tool_for_sandbox(sandbox_policy));
+        }
+        ConfigShellToolType::LocalShell => {
+            tools.push(OpenAiTool::LocalShell {});
+        }
+        ConfigShellToolType::StreamableShell => {
+            tools.push(OpenAiTool::Function(
+                crate::exec_command::create_exec_command_tool_for_responses_api(),
+            ));
+            tools.push(OpenAiTool::Function(
+                crate::exec_command::create_write_stdin_tool_for_responses_api(),
+            ));
         }
     }
 
@@ -629,8 +577,10 @@ pub(crate) fn get_openai_tools(
     if config.include_view_image_tool {
         tools.push(create_view_image_tool());
     }
+
     if let Some(mcp_tools) = mcp_tools {
         // Ensure deterministic ordering to maximize prompt cache hits.
+        // HashMap iteration order is non-deterministic, so sort by fully-qualified tool name.
         let mut entries: Vec<(String, mcp_types::Tool)> = mcp_tools.into_iter().collect();
         entries.sort_by(|a, b| a.0.cmp(&b.0));
 
@@ -692,13 +642,12 @@ mod tests {
             include_web_search_request: true,
             use_streamable_shell_tool: false,
             include_view_image_tool: true,
-            experimental_unified_exec_tool: true,
         });
         let tools = get_openai_tools(&config, Some(HashMap::new()));
 
         assert_eq_tool_names(
             &tools,
-            &["unified_exec", "update_plan", "web_search", "view_image"],
+            &["local_shell", "update_plan", "web_search", "view_image"],
         );
     }
 
@@ -714,13 +663,12 @@ mod tests {
             include_web_search_request: true,
             use_streamable_shell_tool: false,
             include_view_image_tool: true,
-            experimental_unified_exec_tool: true,
         });
         let tools = get_openai_tools(&config, Some(HashMap::new()));
 
         assert_eq_tool_names(
             &tools,
-            &["unified_exec", "update_plan", "web_search", "view_image"],
+            &["shell", "update_plan", "web_search", "view_image"],
         );
     }
 
@@ -736,7 +684,6 @@ mod tests {
             include_web_search_request: true,
             use_streamable_shell_tool: false,
             include_view_image_tool: true,
-            experimental_unified_exec_tool: true,
         });
         let tools = get_openai_tools(
             &config,
@@ -779,7 +726,7 @@ mod tests {
         assert_eq_tool_names(
             &tools,
             &[
-                "unified_exec",
+                "shell",
                 "web_search",
                 "view_image",
                 "test_server/do_something_cool",
@@ -842,7 +789,6 @@ mod tests {
             include_web_search_request: false,
             use_streamable_shell_tool: false,
             include_view_image_tool: true,
-            experimental_unified_exec_tool: true,
         });
 
         // Intentionally construct a map with keys that would sort alphabetically.
@@ -895,11 +841,11 @@ mod tests {
         ]);
 
         let tools = get_openai_tools(&config, Some(tools_map));
-        // Expect unified_exec first, followed by MCP tools sorted by fully-qualified name.
+        // Expect shell first, followed by MCP tools sorted by fully-qualified name.
         assert_eq_tool_names(
             &tools,
             &[
-                "unified_exec",
+                "shell",
                 "view_image",
                 "test_server/cool",
                 "test_server/do",
@@ -920,7 +866,6 @@ mod tests {
             include_web_search_request: true,
             use_streamable_shell_tool: false,
             include_view_image_tool: true,
-            experimental_unified_exec_tool: true,
         });
 
         let tools = get_openai_tools(
@@ -948,7 +893,7 @@ mod tests {
 
         assert_eq_tool_names(
             &tools,
-            &["unified_exec", "web_search", "view_image", "dash/search"],
+            &["shell", "web_search", "view_image", "dash/search"],
         );
 
         assert_eq!(
@@ -983,7 +928,6 @@ mod tests {
             include_web_search_request: true,
             use_streamable_shell_tool: false,
             include_view_image_tool: true,
-            experimental_unified_exec_tool: true,
         });
 
         let tools = get_openai_tools(
@@ -1009,7 +953,7 @@ mod tests {
 
         assert_eq_tool_names(
             &tools,
-            &["unified_exec", "web_search", "view_image", "dash/paginate"],
+            &["shell", "web_search", "view_image", "dash/paginate"],
         );
         assert_eq!(
             tools[3],
@@ -1041,7 +985,6 @@ mod tests {
             include_web_search_request: true,
             use_streamable_shell_tool: false,
             include_view_image_tool: true,
-            experimental_unified_exec_tool: true,
         });
 
         let tools = get_openai_tools(
@@ -1065,10 +1008,7 @@ mod tests {
             )])),
         );
 
-        assert_eq_tool_names(
-            &tools,
-            &["unified_exec", "web_search", "view_image", "dash/tags"],
-        );
+        assert_eq_tool_names(&tools, &["shell", "web_search", "view_image", "dash/tags"]);
         assert_eq!(
             tools[3],
             OpenAiTool::Function(ResponsesApiTool {
@@ -1102,7 +1042,6 @@ mod tests {
             include_web_search_request: true,
             use_streamable_shell_tool: false,
             include_view_image_tool: true,
-            experimental_unified_exec_tool: true,
         });
 
         let tools = get_openai_tools(
@@ -1126,10 +1065,7 @@ mod tests {
             )])),
         );
 
-        assert_eq_tool_names(
-            &tools,
-            &["unified_exec", "web_search", "view_image", "dash/value"],
-        );
+        assert_eq_tool_names(&tools, &["shell", "web_search", "view_image", "dash/value"]);
         assert_eq!(
             tools[3],
             OpenAiTool::Function(ResponsesApiTool {
@@ -1169,8 +1105,11 @@ mod tests {
 The shell tool is used to execute shell commands.
 - When invoking the shell tool, your call will be running in a sandbox, and some shell commands will require escalated privileges:
   - Types of actions that require escalated privileges:
-    - Writing files other than those in the writable roots (see the environment context for the allowed directories)
+    - Writing files other than those in the writable roots
+      - writable roots:
+        - workspace
     - Commands that require network access
+
   - Examples of commands that require escalated privileges:
     - git commit
     - npm install or pnpm install

codex-rs/core/src/parse_command.rs

@@ -868,7 +868,7 @@ pub fn parse_command_impl(command: &[String]) -> Vec<ParsedCommand> {
     let parts = if contains_connectors(&normalized) {
         split_on_connectors(&normalized)
     } else {
-        vec![normalized]
+        vec![normalized.clone()]
     };
 
     // Preserve left-to-right execution order for all commands, including bash -c/-lc
@@ -1201,7 +1201,10 @@ fn parse_bash_lc_commands(original: &[String]) -> Option<Vec<ParsedCommand>> {
                                     name,
                                 }
                             } else {
-                                ParsedCommand::Read { cmd, name }
+                                ParsedCommand::Read {
+                                    cmd: cmd.clone(),
+                                    name,
+                                }
                             }
                         } else {
                             ParsedCommand::Read {
@@ -1212,7 +1215,10 @@ fn parse_bash_lc_commands(original: &[String]) -> Option<Vec<ParsedCommand>> {
                     }
                     ParsedCommand::ListFiles { path, cmd, .. } => {
                         if had_connectors {
-                            ParsedCommand::ListFiles { cmd, path }
+                            ParsedCommand::ListFiles {
+                                cmd: cmd.clone(),
+                                path,
+                            }
                         } else {
                             ParsedCommand::ListFiles {
                                 cmd: shlex_join(&script_tokens),
@@ -1224,7 +1230,11 @@ fn parse_bash_lc_commands(original: &[String]) -> Option<Vec<ParsedCommand>> {
                         query, path, cmd, ..
                     } => {
                         if had_connectors {
-                            ParsedCommand::Search { cmd, query, path }
+                            ParsedCommand::Search {
+                                cmd: cmd.clone(),
+                                query,
+                                path,
+                            }
                         } else {
                             ParsedCommand::Search {
                                 cmd: shlex_join(&script_tokens),

codex-rs/core/src/project_doc.rs

@@ -115,7 +115,7 @@ pub fn discover_project_doc_paths(config: &Config) -> std::io::Result<Vec<PathBu
     // Build chain from cwd upwards and detect git root.
     let mut chain: Vec<PathBuf> = vec![dir.clone()];
     let mut git_root: Option<PathBuf> = None;
-    let mut cursor = dir;
+    let mut cursor = dir.clone();
     while let Some(parent) = cursor.parent() {
         let git_marker = cursor.join(".git");
         let git_exists = match std::fs::metadata(&git_marker) {

codex-rs/core/src/rollout/list.rs

@@ -10,9 +10,7 @@ use time::macros::format_description;
 use uuid::Uuid;
 
 use super::SESSIONS_SUBDIR;
-use crate::protocol::EventMsg;
-use codex_protocol::protocol::RolloutItem;
-use codex_protocol::protocol::RolloutLine;
+use super::recorder::SessionMetaWithGit;
 
 /// Returned page of conversation summaries.
 #[derive(Debug, Default, PartialEq)]
@@ -37,7 +35,7 @@ pub struct ConversationItem {
 }
 
 /// Hard cap to bound worst‑case work per request.
-const MAX_SCAN_FILES: usize = 100;
+const MAX_SCAN_FILES: usize = 10_000;
 const HEAD_RECORD_LIMIT: usize = 10;
 
 /// Pagination cursor identifying a file by timestamp and UUID.
@@ -170,14 +168,10 @@ async fn traverse_directories_for_paths(
                     if items.len() == page_size {
                         break 'outer;
                     }
-                    // Read head and simultaneously detect message events within the same
-                    // first N JSONL records to avoid a second file read.
-                    let (head, saw_session_meta, saw_user_event) =
-                        read_head_and_flags(&path, HEAD_RECORD_LIMIT)
-                            .await
-                            .unwrap_or((Vec::new(), false, false));
-                    // Apply filters: must have session meta and at least one user message event
-                    if saw_session_meta && saw_user_event {
+                    let head = read_first_jsonl_records(&path, HEAD_RECORD_LIMIT)
+                        .await
+                        .unwrap_or_default();
+                    if should_include_session(&head) {
                         items.push(ConversationItem { path, head });
                     }
                 }
@@ -282,19 +276,16 @@ fn parse_timestamp_uuid_from_filename(name: &str) -> Option<(OffsetDateTime, Uui
     Some((ts, uuid))
 }
 
-async fn read_head_and_flags(
+async fn read_first_jsonl_records(
     path: &Path,
     max_records: usize,
-) -> io::Result<(Vec<serde_json::Value>, bool, bool)> {
+) -> io::Result<Vec<serde_json::Value>> {
     use tokio::io::AsyncBufReadExt;
 
     let file = tokio::fs::File::open(path).await?;
     let reader = tokio::io::BufReader::new(file);
     let mut lines = reader.lines();
     let mut head: Vec<serde_json::Value> = Vec::new();
-    let mut saw_session_meta = false;
-    let mut saw_user_event = false;
-
     while head.len() < max_records {
         let line_opt = lines.next_line().await?;
         let Some(line) = line_opt else { break };
@@ -302,35 +293,43 @@ async fn read_head_and_flags(
         if trimmed.is_empty() {
             continue;
         }
-
-        let parsed: Result<RolloutLine, _> = serde_json::from_str(trimmed);
-        let Ok(rollout_line) = parsed else { continue };
-
-        match rollout_line.item {
-            RolloutItem::SessionMeta(session_meta_line) => {
-                if let Ok(val) = serde_json::to_value(session_meta_line) {
-                    head.push(val);
-                    saw_session_meta = true;
-                }
-            }
-            RolloutItem::ResponseItem(item) => {
-                if let Ok(val) = serde_json::to_value(item) {
-                    head.push(val);
-                }
-            }
-            RolloutItem::TurnContext(_) => {
-                // Not included in `head`; skip.
-            }
-            RolloutItem::Compacted(_) => {
-                // Not included in `head`; skip.
-            }
-            RolloutItem::EventMsg(ev) => {
-                if matches!(ev, EventMsg::UserMessage(_)) {
-                    saw_user_event = true;
-                }
-            }
+        if let Ok(v) = serde_json::from_str::<serde_json::Value>(trimmed) {
+            head.push(v);
         }
     }
-
-    Ok((head, saw_session_meta, saw_user_event))
+    Ok(head)
+}
+
+/// Return true if this conversation should be included in the listing.
+///
+/// Current rule: include only when the first JSON object is a session meta record
+/// (i.e., has `{"record_type": "session_meta", ...}`), which is how rollout
+/// files are written. Empty or malformed heads are excluded.
+fn should_include_session(head: &[serde_json::Value]) -> bool {
+    let Some(first) = head.first() else {
+        return false;
+    };
+    passes_session_meta_filter(first)
+}
+
+/// Validate that the first record is a fully‑formed session meta line.
+///
+/// Requirements:
+/// - `record_type == "session_meta"`
+/// - Remaining fields (after removing `record_type`) deserialize into
+///   `SessionMetaWithGit`.
+fn passes_session_meta_filter(first: &serde_json::Value) -> bool {
+    let Some(obj) = first.as_object() else {
+        return false;
+    };
+    let record_type = obj.get("record_type").and_then(|v| v.as_str());
+    if record_type != Some("session_meta") {
+        return false;
+    }
+
+    // Remove the marker field and validate the remainder matches SessionMetaWithGit
+    let mut cleaned = obj.clone();
+    cleaned.remove("record_type");
+    let val = serde_json::Value::Object(cleaned);
+    serde_json::from_value::<SessionMetaWithGit>(val).is_ok()
 }

codex-rs/core/src/rollout/mod.rs

@@ -1,15 +1,15 @@
 //! Rollout module: persistence and discovery of session rollout files.
 
-pub const SESSIONS_SUBDIR: &str = "sessions";
-pub const ARCHIVED_SESSIONS_SUBDIR: &str = "archived_sessions";
+pub(crate) const SESSIONS_SUBDIR: &str = "sessions";
 
 pub mod list;
 pub(crate) mod policy;
 pub mod recorder;
 
-pub use codex_protocol::protocol::SessionMeta;
+pub use recorder::RolloutItem;
 pub use recorder::RolloutRecorder;
-pub use recorder::RolloutRecorderParams;
+pub use recorder::SessionMeta;
+pub use recorder::SessionStateSnapshot;
 
 #[cfg(test)]
 pub mod tests;

codex-rs/core/src/rollout/policy.rs

@@ -1,23 +1,10 @@
-use crate::protocol::EventMsg;
-use crate::protocol::RolloutItem;
 use codex_protocol::models::ResponseItem;
-
-/// Whether a rollout `item` should be persisted in rollout files.
-#[inline]
-pub(crate) fn is_persisted_response_item(item: &RolloutItem) -> bool {
-    match item {
-        RolloutItem::ResponseItem(item) => should_persist_response_item(item),
-        RolloutItem::EventMsg(ev) => should_persist_event_msg(ev),
-        // Persist Codex executive markers so we can analyze flows (e.g., compaction, API turns).
-        RolloutItem::Compacted(_) | RolloutItem::TurnContext(_) | RolloutItem::SessionMeta(_) => {
-            true
-        }
-    }
-}
+use codex_protocol::protocol::Event;
+use codex_protocol::protocol::EventMsg;
 
 /// Whether a `ResponseItem` should be persisted in rollout files.
 #[inline]
-pub(crate) fn should_persist_response_item(item: &ResponseItem) -> bool {
+pub(crate) fn is_persisted_response_item(item: &ResponseItem) -> bool {
     match item {
         ResponseItem::Message { .. }
         | ResponseItem::Reasoning { .. }
@@ -30,43 +17,41 @@ pub(crate) fn should_persist_response_item(item: &ResponseItem) -> bool {
     }
 }
 
-/// Whether an `EventMsg` should be persisted in rollout files.
-#[inline]
-pub(crate) fn should_persist_event_msg(ev: &EventMsg) -> bool {
-    match ev {
-        EventMsg::UserMessage(_)
-        | EventMsg::AgentMessage(_)
-        | EventMsg::AgentReasoning(_)
-        | EventMsg::AgentReasoningRawContent(_)
-        | EventMsg::TokenCount(_) => true,
-        EventMsg::Error(_)
-        | EventMsg::TaskStarted(_)
-        | EventMsg::TaskComplete(_)
-        | EventMsg::AgentMessageDelta(_)
+pub(crate) fn is_persisted_event(event: &Event) -> bool {
+    match event.msg {
+        EventMsg::ExecApprovalRequest(_)
+        | EventMsg::ApplyPatchApprovalRequest(_)
         | EventMsg::AgentReasoningDelta(_)
         | EventMsg::AgentReasoningRawContentDelta(_)
-        | EventMsg::AgentReasoningSectionBreak(_)
-        | EventMsg::SessionConfigured(_)
+        | EventMsg::ExecCommandOutputDelta(_)
+        | EventMsg::GetHistoryEntryResponse(_)
+        | EventMsg::AgentMessageDelta(_)
+        | EventMsg::TaskStarted(_)
+        | EventMsg::TaskComplete(_)
         | EventMsg::McpToolCallBegin(_)
         | EventMsg::McpToolCallEnd(_)
         | EventMsg::WebSearchBegin(_)
         | EventMsg::WebSearchEnd(_)
         | EventMsg::ExecCommandBegin(_)
-        | EventMsg::ExecCommandOutputDelta(_)
         | EventMsg::ExecCommandEnd(_)
-        | EventMsg::ExecApprovalRequest(_)
-        | EventMsg::ApplyPatchApprovalRequest(_)
-        | EventMsg::BackgroundEvent(_)
-        | EventMsg::StreamError(_)
         | EventMsg::PatchApplyBegin(_)
         | EventMsg::PatchApplyEnd(_)
         | EventMsg::TurnDiff(_)
-        | EventMsg::GetHistoryEntryResponse(_)
+        | EventMsg::BackgroundEvent(_)
         | EventMsg::McpListToolsResponse(_)
         | EventMsg::ListCustomPromptsResponse(_)
+        | EventMsg::ShutdownComplete
+        | EventMsg::ConversationHistory(_)
         | EventMsg::PlanUpdate(_)
         | EventMsg::TurnAborted(_)
-        | EventMsg::ShutdownComplete
-        | EventMsg::ConversationPath(_) => false,
+        | EventMsg::StreamError(_)
+        | EventMsg::Error(_)
+        | EventMsg::AgentReasoningSectionBreak(_)
+        | EventMsg::SessionConfigured(_) => false,
+        EventMsg::UserMessage(_)
+        | EventMsg::AgentMessage(_)
+        | EventMsg::AgentReasoning(_)
+        | EventMsg::AgentReasoningRawContent(_)
+        | EventMsg::TokenCount(_) => true,
     }
 }

codex-rs/core/src/rollout/recorder.rs

@@ -7,9 +7,10 @@ use std::path::Path;
 use std::path::PathBuf;
 
 use codex_protocol::mcp_protocol::ConversationId;
+use codex_protocol::protocol::Event;
+use codex_protocol::protocol::EventMsg;
 use serde::Deserialize;
 use serde::Serialize;
-use serde_json::Value;
 use time::OffsetDateTime;
 use time::format_description::FormatItem;
 use time::macros::format_description;
@@ -26,17 +27,33 @@ use super::list::Cursor;
 use super::list::get_conversations;
 use super::policy::is_persisted_response_item;
 use crate::config::Config;
-use crate::default_client::ORIGINATOR;
+use crate::conversation_manager::InitialHistory;
+use crate::conversation_manager::ResumedHistory;
+use crate::git_info::GitInfo;
 use crate::git_info::collect_git_info;
+use crate::rollout::policy::is_persisted_event;
 use codex_protocol::models::ResponseItem;
-use codex_protocol::protocol::InitialHistory;
-use codex_protocol::protocol::ResumedHistory;
-use codex_protocol::protocol::RolloutItem;
-use codex_protocol::protocol::RolloutLine;
-use codex_protocol::protocol::SessionMeta;
-use codex_protocol::protocol::SessionMetaLine;
 
-#[derive(Serialize, Deserialize, Default, Clone)]
+#[derive(Serialize, Deserialize, Clone, Default, Debug)]
+pub struct SessionMeta {
+    pub id: ConversationId,
+    pub timestamp: String,
+    pub cwd: String,
+    pub originator: String,
+    pub cli_version: String,
+    pub instructions: Option<String>,
+}
+
+// SessionMetaWithGit is used in writes and reads; ensure it implements Debug.
+#[derive(Serialize, Deserialize, Clone, Debug)]
+pub struct SessionMetaWithGit {
+    #[serde(flatten)]
+    meta: SessionMeta,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    git: Option<GitInfo>,
+}
+
+#[derive(Serialize, Deserialize, Default, Clone, Debug)]
 pub struct SessionStateSnapshot {}
 
 #[derive(Serialize, Deserialize, Default, Clone)]
@@ -61,45 +78,99 @@ pub struct SavedSession {
 #[derive(Clone)]
 pub struct RolloutRecorder {
     tx: Sender<RolloutCmd>,
-    pub(crate) rollout_path: PathBuf,
+    path: PathBuf,
 }
 
-#[derive(Clone)]
-pub enum RolloutRecorderParams {
-    Create {
-        conversation_id: ConversationId,
-        instructions: Option<String>,
+#[derive(Serialize, Deserialize, Debug, Clone)]
+#[serde(tag = "record_type", rename_all = "snake_case")]
+enum TaggedLine {
+    Response {
+        #[serde(flatten)]
+        item: ResponseItem,
     },
-    Resume {
-        path: PathBuf,
+    Event {
+        #[serde(flatten)]
+        event: Event,
     },
+    SessionMeta {
+        #[serde(flatten)]
+        meta: SessionMetaWithGit,
+    },
+    PrevSessionMeta {
+        #[serde(flatten)]
+        meta: SessionMetaWithGit,
+    },
+    State {
+        #[serde(flatten)]
+        state: SessionStateSnapshot,
+    },
+}
+
+#[derive(Serialize, Deserialize, Debug, Clone)]
+struct TimestampedLine {
+    timestamp: String,
+    #[serde(flatten)]
+    record: TaggedLine,
+}
+
+#[derive(Debug, Clone)]
+pub enum RolloutItem {
+    ResponseItem(ResponseItem),
+    Event(Event),
+    SessionMeta(SessionMetaWithGit),
+}
+
+impl From<ResponseItem> for RolloutItem {
+    fn from(item: ResponseItem) -> Self {
+        RolloutItem::ResponseItem(item)
+    }
+}
+
+impl From<Event> for RolloutItem {
+    fn from(event: Event) -> Self {
+        RolloutItem::Event(event)
+    }
+}
+
+/// Convenience helpers to extract typed items from a list of rollout items.
+pub trait RolloutItemSliceExt {
+    fn get_response_items(&self) -> Vec<ResponseItem>;
+    fn get_events(&self) -> Vec<EventMsg>;
+}
+
+impl RolloutItemSliceExt for [RolloutItem] {
+    fn get_response_items(&self) -> Vec<ResponseItem> {
+        self.iter()
+            .filter_map(|it| match it {
+                RolloutItem::ResponseItem(ri) => Some(ri.clone()),
+                _ => None,
+            })
+            .collect()
+    }
+
+    fn get_events(&self) -> Vec<EventMsg> {
+        self.iter()
+            .filter_map(|it| match it {
+                RolloutItem::Event(ev) => Some(ev.msg.clone()),
+                _ => None,
+            })
+            .collect()
+    }
 }
 
 enum RolloutCmd {
-    AddItems(Vec<RolloutItem>),
-    /// Ensure all prior writes are processed; respond when flushed.
-    Flush {
-        ack: oneshot::Sender<()>,
-    },
-    Shutdown {
-        ack: oneshot::Sender<()>,
-    },
-}
-
-impl RolloutRecorderParams {
-    pub fn new(conversation_id: ConversationId, instructions: Option<String>) -> Self {
-        Self::Create {
-            conversation_id,
-            instructions,
-        }
-    }
-
-    pub fn resume(path: PathBuf) -> Self {
-        Self::Resume { path }
-    }
+    AddResponseItems(Vec<ResponseItem>),
+    AddEvents(Vec<Event>),
+    AddSessionMeta(SessionMetaWithGit),
+    Flush { ack: oneshot::Sender<()> },
+    Shutdown { ack: oneshot::Sender<()> },
 }
 
 impl RolloutRecorder {
+    pub fn path(&self) -> &Path {
+        &self.path
+    }
+    #[allow(dead_code)]
     /// List conversations (rollout files) under the provided Codex home directory.
     pub async fn list_conversations(
         codex_home: &Path,
@@ -112,145 +183,157 @@ impl RolloutRecorder {
     /// Attempt to create a new [`RolloutRecorder`]. If the sessions directory
     /// cannot be created or the rollout file cannot be opened we return the
     /// error so the caller can decide whether to disable persistence.
-    pub async fn new(config: &Config, params: RolloutRecorderParams) -> std::io::Result<Self> {
-        let (file, rollout_path, meta) = match params {
-            RolloutRecorderParams::Create {
-                conversation_id,
+    pub async fn new(
+        config: &Config,
+        conversation_id: ConversationId,
+        instructions: Option<String>,
+    ) -> std::io::Result<Self> {
+        let LogFileInfo {
+            file,
+            conversation_id: session_id,
+            timestamp,
+            path,
+        } = create_log_file(config, conversation_id)?;
+
+        let timestamp_format: &[FormatItem] =
+            format_description!("[year]-[month]-[day]T[hour]:[minute]:[second]Z");
+        let timestamp = timestamp
+            .to_offset(time::UtcOffset::UTC)
+            .format(timestamp_format)
+            .map_err(|e| IoError::other(format!("failed to format timestamp: {e}")))?;
+
+        let cwd = config.cwd.to_path_buf();
+
+        let (tx, rx) = mpsc::channel(100);
+
+        tokio::task::spawn(rollout_writer(
+            tokio::fs::File::from_std(file),
+            rx,
+            Some(SessionMeta {
+                timestamp,
+                id: session_id,
+                cwd: config.cwd.to_string_lossy().to_string(),
+                originator: config.responses_originator_header.clone(),
+                cli_version: env!("CARGO_PKG_VERSION").to_string(),
                 instructions,
-            } => {
-                let LogFileInfo {
-                    file,
-                    path,
-                    conversation_id: session_id,
-                    timestamp,
-                } = create_log_file(config, conversation_id)?;
+            }),
+            cwd,
+        ));
 
-                let timestamp_format: &[FormatItem] = format_description!(
-                    "[year]-[month]-[day]T[hour]:[minute]:[second].[subsecond digits:3]Z"
-                );
-                let timestamp = timestamp
-                    .to_offset(time::UtcOffset::UTC)
-                    .format(timestamp_format)
-                    .map_err(|e| IoError::other(format!("failed to format timestamp: {e}")))?;
-
-                (
-                    tokio::fs::File::from_std(file),
-                    path,
-                    Some(SessionMeta {
-                        id: session_id,
-                        timestamp,
-                        cwd: config.cwd.clone(),
-                        originator: ORIGINATOR.value.clone(),
-                        cli_version: env!("CARGO_PKG_VERSION").to_string(),
-                        instructions,
-                    }),
-                )
-            }
-            RolloutRecorderParams::Resume { path } => (
-                tokio::fs::OpenOptions::new()
-                    .append(true)
-                    .open(&path)
-                    .await?,
-                path,
-                None,
-            ),
-        };
-
-        // Clone the cwd for the spawned task to collect git info asynchronously
-        let cwd = config.cwd.clone();
-
-        // A reasonably-sized bounded channel. If the buffer fills up the send
-        // future will yield, which is fine – we only need to ensure we do not
-        // perform *blocking* I/O on the caller's thread.
-        let (tx, rx) = mpsc::channel::<RolloutCmd>(256);
-
-        // Spawn a Tokio task that owns the file handle and performs async
-        // writes. Using `tokio::fs::File` keeps everything on the async I/O
-        // driver instead of blocking the runtime.
-        tokio::task::spawn(rollout_writer(file, rx, meta, cwd));
-
-        Ok(Self { tx, rollout_path })
+        Ok(Self { tx, path })
     }
 
-    pub(crate) async fn record_items(&self, items: &[RolloutItem]) -> std::io::Result<()> {
-        let mut filtered = Vec::new();
-        for item in items {
-            // Note that function calls may look a bit strange if they are
-            // "fully qualified MCP tool calls," so we could consider
-            // reformatting them in that case.
-            if is_persisted_response_item(item) {
-                filtered.push(item.clone());
-            }
+    pub(crate) async fn record_items(&self, item: RolloutItem) -> std::io::Result<()> {
+        match item {
+            RolloutItem::ResponseItem(item) => self.record_response_item(&item).await,
+            RolloutItem::Event(event) => self.record_event(&event).await,
+            RolloutItem::SessionMeta(meta) => self.record_session_meta(&meta).await,
         }
-        if filtered.is_empty() {
+    }
+
+    /// Ensure all writes up to this point have been processed by the writer task.
+    ///
+    /// This is a sequencing barrier for readers that plan to open and read the
+    /// rollout file immediately after calling this method. The background writer
+    /// processes the channel serially; when it dequeues `Flush`, all prior
+    /// `AddResponseItems`/`AddEvents`/`AddSessionMeta` have already been written
+    /// via `write_line`, which calls `file.flush()` (OS‐buffer flush).
+    pub async fn flush(&self) -> std::io::Result<()> {
+        let (tx_done, rx_done) = oneshot::channel();
+        self.tx
+            .send(RolloutCmd::Flush { ack: tx_done })
+            .await
+            .map_err(|e| IoError::other(format!("failed to queue rollout flush: {e}")))?;
+        rx_done
+            .await
+            .map_err(|e| IoError::other(format!("failed waiting for rollout flush: {e}")))
+    }
+
+    async fn record_response_item(&self, item: &ResponseItem) -> std::io::Result<()> {
+        // Note that function calls may look a bit strange if they are
+        // "fully qualified MCP tool calls," so we could consider
+        // reformatting them in that case.
+        if !is_persisted_response_item(item) {
             return Ok(());
         }
         self.tx
-            .send(RolloutCmd::AddItems(filtered))
+            .send(RolloutCmd::AddResponseItems(vec![item.clone()]))
             .await
             .map_err(|e| IoError::other(format!("failed to queue rollout items: {e}")))
     }
 
-    /// Flush all queued writes and wait until they are committed by the writer task.
-    pub async fn flush(&self) -> std::io::Result<()> {
-        let (tx, rx) = oneshot::channel();
+    async fn record_event(&self, event: &Event) -> std::io::Result<()> {
+        if !is_persisted_event(event) {
+            return Ok(());
+        }
         self.tx
-            .send(RolloutCmd::Flush { ack: tx })
+            .send(RolloutCmd::AddEvents(vec![event.clone()]))
             .await
-            .map_err(|e| IoError::other(format!("failed to queue rollout flush: {e}")))?;
-        rx.await
-            .map_err(|e| IoError::other(format!("failed waiting for rollout flush: {e}")))
+            .map_err(|e| IoError::other(format!("failed to queue rollout event: {e}")))
     }
 
-    pub(crate) async fn get_rollout_history(path: &Path) -> std::io::Result<InitialHistory> {
+    async fn record_session_meta(&self, meta: &SessionMetaWithGit) -> std::io::Result<()> {
+        self.tx
+            .send(RolloutCmd::AddSessionMeta(meta.clone()))
+            .await
+            .map_err(|e| IoError::other(format!("failed to queue rollout session meta: {e}")))
+    }
+
+    pub async fn get_rollout_history(path: &Path) -> std::io::Result<InitialHistory> {
         info!("Resuming rollout from {path:?}");
         tracing::error!("Resuming rollout from {path:?}");
         let text = tokio::fs::read_to_string(path).await?;
-        if text.trim().is_empty() {
-            return Err(IoError::other("empty session file"));
-        }
+        let mut lines = text.lines();
+        let first_line = lines
+            .next()
+            .ok_or_else(|| IoError::other("empty session file"))?;
+        let conversation_id = if let Ok(TimestampedLine {
+            record: TaggedLine::SessionMeta { meta },
+            ..
+        }) = serde_json::from_str::<TimestampedLine>(first_line)
+        {
+            Some(meta.meta.id)
+        } else if let Ok(meta) = serde_json::from_str::<SessionMetaWithGit>(first_line) {
+            Some(meta.meta.id)
+        } else if let Ok(meta) = serde_json::from_str::<SessionMeta>(first_line) {
+            Some(meta.id)
+        } else {
+            return Err(IoError::other(
+                "failed to parse first line of rollout file as SessionMeta",
+            ));
+        };
 
         let mut items: Vec<RolloutItem> = Vec::new();
-        let mut conversation_id: Option<ConversationId> = None;
-        for line in text.lines() {
+        for line in lines {
             if line.trim().is_empty() {
                 continue;
             }
-            let v: Value = match serde_json::from_str(line) {
-                Ok(v) => v,
-                Err(e) => {
-                    warn!("failed to parse line as JSON: {line:?}, error: {e}");
-                    continue;
-                }
-            };
-
-            // Parse the rollout line structure
-            match serde_json::from_value::<RolloutLine>(v.clone()) {
-                Ok(rollout_line) => match rollout_line.item {
-                    RolloutItem::SessionMeta(session_meta_line) => {
-                        // Use the FIRST SessionMeta encountered in the file as the canonical
-                        // conversation id and main session information. Keep all items intact.
-                        if conversation_id.is_none() {
-                            conversation_id = Some(session_meta_line.meta.id);
-                        }
-                        items.push(RolloutItem::SessionMeta(session_meta_line));
-                    }
-                    RolloutItem::ResponseItem(item) => {
+            match serde_json::from_str::<TimestampedLine>(line) {
+                Ok(TimestampedLine {
+                    record: TaggedLine::State { .. },
+                    ..
+                }) => {}
+                Ok(TimestampedLine {
+                    record: TaggedLine::Event { event },
+                    ..
+                }) => items.push(RolloutItem::Event(event)),
+                Ok(TimestampedLine {
+                    record: TaggedLine::SessionMeta { meta },
+                    ..
+                })
+                | Ok(TimestampedLine {
+                    record: TaggedLine::PrevSessionMeta { meta },
+                    ..
+                }) => items.push(RolloutItem::SessionMeta(meta)),
+                Ok(TimestampedLine {
+                    record: TaggedLine::Response { item },
+                    ..
+                }) => {
+                    if is_persisted_response_item(&item) {
                         items.push(RolloutItem::ResponseItem(item));
                     }
-                    RolloutItem::Compacted(item) => {
-                        items.push(RolloutItem::Compacted(item));
-                    }
-                    RolloutItem::TurnContext(item) => {
-                        items.push(RolloutItem::TurnContext(item));
-                    }
-                    RolloutItem::EventMsg(_ev) => {
-                        items.push(RolloutItem::EventMsg(_ev));
-                    }
-                },
-                Err(e) => {
-                    warn!("failed to parse rollout line: {v:?}, error: {e}");
                 }
+                Err(_) => warn!("failed to parse rollout line: {line}"),
             }
         }
 
@@ -274,10 +357,6 @@ impl RolloutRecorder {
         }))
     }
 
-    pub(crate) fn get_rollout_path(&self) -> PathBuf {
-        self.rollout_path.clone()
-    }
-
     pub async fn shutdown(&self) -> std::io::Result<()> {
         let (tx_done, rx_done) = oneshot::channel();
         match self.tx.send(RolloutCmd::Shutdown { ack: tx_done }).await {
@@ -298,14 +377,14 @@ struct LogFileInfo {
     /// Opened file handle to the rollout file.
     file: File,
 
-    /// Full path to the rollout file.
-    path: PathBuf,
-
     /// Session ID (also embedded in filename).
     conversation_id: ConversationId,
 
     /// Timestamp for the start of the session.
     timestamp: OffsetDateTime,
+
+    /// Full filesystem path to the rollout file.
+    path: PathBuf,
 }
 
 fn create_log_file(
@@ -313,8 +392,7 @@ fn create_log_file(
     conversation_id: ConversationId,
 ) -> std::io::Result<LogFileInfo> {
     // Resolve ~/.codex/sessions/YYYY/MM/DD and create it if missing.
-    let timestamp = OffsetDateTime::now_local()
-        .map_err(|e| IoError::other(format!("failed to get local time: {e}")))?;
+    let timestamp = OffsetDateTime::now_utc();
     let mut dir = config.codex_home.clone();
     dir.push(SESSIONS_SUBDIR);
     dir.push(timestamp.year().to_string());
@@ -340,9 +418,9 @@ fn create_log_file(
 
     Ok(LogFileInfo {
         file,
-        path,
         conversation_id,
         timestamp,
+        path,
     })
 }
 
@@ -357,35 +435,43 @@ async fn rollout_writer(
     // If we have a meta, collect git info asynchronously and write meta first
     if let Some(session_meta) = meta.take() {
         let git_info = collect_git_info(&cwd).await;
-        let session_meta_line = SessionMetaLine {
+        let session_meta_with_git = SessionMetaWithGit {
             meta: session_meta,
             git: git_info,
         };
-
-        // Write the SessionMeta as the first item in the file, wrapped in a rollout line
+        // Write the SessionMeta as the first item in the file
         writer
-            .write_rollout_item(RolloutItem::SessionMeta(session_meta_line))
+            .write_tagged(TaggedLine::SessionMeta {
+                meta: session_meta_with_git,
+            })
             .await?;
     }
 
     // Process rollout commands
     while let Some(cmd) = rx.recv().await {
         match cmd {
-            RolloutCmd::AddItems(items) => {
+            RolloutCmd::AddResponseItems(items) => {
                 for item in items {
                     if is_persisted_response_item(&item) {
-                        writer.write_rollout_item(item).await?;
+                        writer.write_tagged(TaggedLine::Response { item }).await?;
                     }
                 }
             }
-            RolloutCmd::Flush { ack } => {
-                // Ensure underlying file is flushed and then ack.
-                if let Err(e) = writer.file.flush().await {
-                    let _ = ack.send(());
-                    return Err(e);
+            RolloutCmd::AddEvents(events) => {
+                for event in events {
+                    writer.write_tagged(TaggedLine::Event { event }).await?;
                 }
+            }
+            // Sequencing barrier: by the time we handle `Flush`, all previously
+            // queued writes have been applied and flushed to OS buffers.
+            RolloutCmd::Flush { ack } => {
                 let _ = ack.send(());
             }
+            RolloutCmd::AddSessionMeta(meta) => {
+                writer
+                    .write_tagged(TaggedLine::PrevSessionMeta { meta })
+                    .await?;
+            }
             RolloutCmd::Shutdown { ack } => {
                 let _ = ack.send(());
             }
@@ -400,20 +486,6 @@ struct JsonlWriter {
 }
 
 impl JsonlWriter {
-    async fn write_rollout_item(&mut self, rollout_item: RolloutItem) -> std::io::Result<()> {
-        let timestamp_format: &[FormatItem] = format_description!(
-            "[year]-[month]-[day]T[hour]:[minute]:[second].[subsecond digits:3]Z"
-        );
-        let timestamp = OffsetDateTime::now_utc()
-            .format(timestamp_format)
-            .map_err(|e| IoError::other(format!("failed to format timestamp: {e}")))?;
-
-        let line = RolloutLine {
-            timestamp,
-            item: rollout_item,
-        };
-        self.write_line(&line).await
-    }
     async fn write_line(&mut self, item: &impl serde::Serialize) -> std::io::Result<()> {
         let mut json = serde_json::to_string(item)?;
         json.push('\n');
@@ -421,4 +493,12 @@ impl JsonlWriter {
         self.file.flush().await?;
         Ok(())
     }
+
+    async fn write_tagged(&mut self, record: TaggedLine) -> std::io::Result<()> {
+        let timestamp = time::OffsetDateTime::now_utc()
+            .format(&time::format_description::well_known::Rfc3339)
+            .map_err(|e| IoError::other(format!("failed to format timestamp: {e}")))?;
+        let line = TimestampedLine { timestamp, record };
+        self.write_line(&line).await
+    }
 }

codex-rs/core/src/rollout/tests.rs

@@ -41,31 +41,16 @@ fn write_session_file(
     let mut file = File::create(file_path)?;
 
     let meta = serde_json::json!({
+        "record_type": "session_meta",
         "timestamp": ts_str,
-        "type": "session_meta",
-        "payload": {
-            "id": uuid,
-            "timestamp": ts_str,
-            "instructions": null,
-            "cwd": ".",
-            "originator": "test_originator",
-            "cli_version": "test_version"
-        }
+        "id": uuid.to_string(),
+        "cwd": "/",
+        "originator": "test",
+        "cli_version": "0.0.0",
+        "instructions": null
     });
     writeln!(file, "{meta}")?;
 
-    // Include at least one user message event to satisfy listing filters
-    let user_event = serde_json::json!({
-        "timestamp": ts_str,
-        "type": "event_msg",
-        "payload": {
-            "type": "user_message",
-            "message": "Hello from user",
-            "kind": "plain"
-        }
-    });
-    writeln!(file, "{user_event}")?;
-
     for i in 0..num_records {
         let rec = serde_json::json!({
             "record_type": "response",
@@ -76,6 +61,18 @@ fn write_session_file(
     Ok((dt, uuid))
 }
 
+fn expected_session_meta(ts: &str, uuid: Uuid) -> serde_json::Value {
+    serde_json::json!({
+        "record_type": "session_meta",
+        "timestamp": ts,
+        "id": uuid.to_string(),
+        "cwd": "/",
+        "originator": "test",
+        "cli_version": "0.0.0",
+        "instructions": null
+    })
+}
+
 #[tokio::test]
 async fn test_list_conversations_latest_first() {
     let temp = TempDir::new().unwrap();
@@ -113,30 +110,24 @@ async fn test_list_conversations_latest_first() {
         .join("01")
         .join(format!("rollout-2025-01-01T12-00-00-{u1}.jsonl"));
 
-    let head_3 = vec![serde_json::json!({
-        "id": u3,
-        "timestamp": "2025-01-03T12-00-00",
-        "instructions": null,
-        "cwd": ".",
-        "originator": "test_originator",
-        "cli_version": "test_version"
-    })];
-    let head_2 = vec![serde_json::json!({
-        "id": u2,
-        "timestamp": "2025-01-02T12-00-00",
-        "instructions": null,
-        "cwd": ".",
-        "originator": "test_originator",
-        "cli_version": "test_version"
-    })];
-    let head_1 = vec![serde_json::json!({
-        "id": u1,
-        "timestamp": "2025-01-01T12-00-00",
-        "instructions": null,
-        "cwd": ".",
-        "originator": "test_originator",
-        "cli_version": "test_version"
-    })];
+    let head_3 = vec![
+        expected_session_meta("2025-01-03T12-00-00", u3),
+        serde_json::json!({"record_type": "response", "index": 0}),
+        serde_json::json!({"record_type": "response", "index": 1}),
+        serde_json::json!({"record_type": "response", "index": 2}),
+    ];
+    let head_2 = vec![
+        expected_session_meta("2025-01-02T12-00-00", u2),
+        serde_json::json!({"record_type": "response", "index": 0}),
+        serde_json::json!({"record_type": "response", "index": 1}),
+        serde_json::json!({"record_type": "response", "index": 2}),
+    ];
+    let head_1 = vec![
+        expected_session_meta("2025-01-01T12-00-00", u1),
+        serde_json::json!({"record_type": "response", "index": 0}),
+        serde_json::json!({"record_type": "response", "index": 1}),
+        serde_json::json!({"record_type": "response", "index": 2}),
+    ];
 
     let expected_cursor: Cursor =
         serde_json::from_str(&format!("\"2025-01-01T12-00-00|{u1}\"")).unwrap();
@@ -196,22 +187,14 @@ async fn test_pagination_cursor() {
         .join("03")
         .join("04")
         .join(format!("rollout-2025-03-04T09-00-00-{u4}.jsonl"));
-    let head_5 = vec![serde_json::json!({
-        "id": u5,
-        "timestamp": "2025-03-05T09-00-00",
-        "instructions": null,
-        "cwd": ".",
-        "originator": "test_originator",
-        "cli_version": "test_version"
-    })];
-    let head_4 = vec![serde_json::json!({
-        "id": u4,
-        "timestamp": "2025-03-04T09-00-00",
-        "instructions": null,
-        "cwd": ".",
-        "originator": "test_originator",
-        "cli_version": "test_version"
-    })];
+    let head_5 = vec![
+        expected_session_meta("2025-03-05T09-00-00", u5),
+        serde_json::json!({"record_type": "response", "index": 0}),
+    ];
+    let head_4 = vec![
+        expected_session_meta("2025-03-04T09-00-00", u4),
+        serde_json::json!({"record_type": "response", "index": 0}),
+    ];
     let expected_cursor1: Cursor =
         serde_json::from_str(&format!("\"2025-03-04T09-00-00|{u4}\"")).unwrap();
     let expected_page1 = ConversationsPage {
@@ -246,22 +229,14 @@ async fn test_pagination_cursor() {
         .join("03")
         .join("02")
         .join(format!("rollout-2025-03-02T09-00-00-{u2}.jsonl"));
-    let head_3 = vec![serde_json::json!({
-        "id": u3,
-        "timestamp": "2025-03-03T09-00-00",
-        "instructions": null,
-        "cwd": ".",
-        "originator": "test_originator",
-        "cli_version": "test_version"
-    })];
-    let head_2 = vec![serde_json::json!({
-        "id": u2,
-        "timestamp": "2025-03-02T09-00-00",
-        "instructions": null,
-        "cwd": ".",
-        "originator": "test_originator",
-        "cli_version": "test_version"
-    })];
+    let head_3 = vec![
+        expected_session_meta("2025-03-03T09-00-00", u3),
+        serde_json::json!({"record_type": "response", "index": 0}),
+    ];
+    let head_2 = vec![
+        expected_session_meta("2025-03-02T09-00-00", u2),
+        serde_json::json!({"record_type": "response", "index": 0}),
+    ];
     let expected_cursor2: Cursor =
         serde_json::from_str(&format!("\"2025-03-02T09-00-00|{u2}\"")).unwrap();
     let expected_page2 = ConversationsPage {
@@ -290,14 +265,10 @@ async fn test_pagination_cursor() {
         .join("03")
         .join("01")
         .join(format!("rollout-2025-03-01T09-00-00-{u1}.jsonl"));
-    let head_1 = vec![serde_json::json!({
-        "id": u1,
-        "timestamp": "2025-03-01T09-00-00",
-        "instructions": null,
-        "cwd": ".",
-        "originator": "test_originator",
-        "cli_version": "test_version"
-    })];
+    let head_1 = vec![
+        expected_session_meta("2025-03-01T09-00-00", u1),
+        serde_json::json!({"record_type": "response", "index": 0}),
+    ];
     let expected_cursor3: Cursor =
         serde_json::from_str(&format!("\"2025-03-01T09-00-00|{u1}\"")).unwrap();
     let expected_page3 = ConversationsPage {
@@ -305,7 +276,7 @@ async fn test_pagination_cursor() {
             path: p1,
             head: head_1,
         }],
-        next_cursor: Some(expected_cursor3),
+        next_cursor: Some(expected_cursor3.clone()),
         num_scanned_files: 5, // scanned 05, 04 (anchor), 03, 02 (anchor), 01
         reached_scan_cap: false,
     };
@@ -333,18 +304,15 @@ async fn test_get_conversation_contents() {
         .join("04")
         .join("01")
         .join(format!("rollout-2025-04-01T10-30-00-{uuid}.jsonl"));
-    let expected_head = vec![serde_json::json!({
-        "id": uuid,
-        "timestamp": ts,
-        "instructions": null,
-        "cwd": ".",
-        "originator": "test_originator",
-        "cli_version": "test_version"
-    })];
+    let expected_head = vec![
+        expected_session_meta(ts, uuid),
+        serde_json::json!({"record_type": "response", "index": 0}),
+        serde_json::json!({"record_type": "response", "index": 1}),
+    ];
     let expected_cursor: Cursor = serde_json::from_str(&format!("\"{ts}|{uuid}\"")).unwrap();
     let expected_page = ConversationsPage {
         items: vec![ConversationItem {
-            path: expected_path,
+            path: expected_path.clone(),
             head: expected_head,
         }],
         next_cursor: Some(expected_cursor),
@@ -354,15 +322,10 @@ async fn test_get_conversation_contents() {
     assert_eq!(page, expected_page);
 
     // Entire file contents equality
-    let meta = serde_json::json!({"timestamp": ts, "type": "session_meta", "payload": {"id": uuid, "timestamp": ts, "instructions": null, "cwd": ".", "originator": "test_originator", "cli_version": "test_version"}});
-    let user_event = serde_json::json!({
-        "timestamp": ts,
-        "type": "event_msg",
-        "payload": {"type": "user_message", "message": "Hello from user", "kind": "plain"}
-    });
+    let meta = expected_session_meta(ts, uuid);
     let rec0 = serde_json::json!({"record_type": "response", "index": 0});
     let rec1 = serde_json::json!({"record_type": "response", "index": 1});
-    let expected_content = format!("{meta}\n{user_event}\n{rec0}\n{rec1}\n");
+    let expected_content = format!("{meta}\n{rec0}\n{rec1}\n");
     assert_eq!(content, expected_content);
 }
 
@@ -394,16 +357,7 @@ async fn test_stable_ordering_same_second_pagination() {
         .join("07")
         .join("01")
         .join(format!("rollout-2025-07-01T00-00-00-{u2}.jsonl"));
-    let head = |u: Uuid| -> Vec<serde_json::Value> {
-        vec![serde_json::json!({
-            "id": u,
-            "timestamp": ts,
-            "instructions": null,
-            "cwd": ".",
-            "originator": "test_originator",
-            "cli_version": "test_version"
-        })]
-    };
+    let head = |u: Uuid| -> Vec<serde_json::Value> { vec![expected_session_meta(ts, u)] };
     let expected_cursor1: Cursor = serde_json::from_str(&format!("\"{ts}|{u2}\"")).unwrap();
     let expected_page1 = ConversationsPage {
         items: vec![
@@ -437,7 +391,7 @@ async fn test_stable_ordering_same_second_pagination() {
             path: p1,
             head: head(u1),
         }],
-        next_cursor: Some(expected_cursor2),
+        next_cursor: Some(expected_cursor2.clone()),
         num_scanned_files: 3, // scanned u3, u2 (anchor), u1
         reached_scan_cap: false,
     };

codex-rs/core/src/safety.rs

@@ -293,7 +293,7 @@ mod tests {
         // With the parent dir explicitly added as a writable root, the
         // outside write should be permitted.
         let policy_with_parent = SandboxPolicy::WorkspaceWrite {
-            writable_roots: vec![parent],
+            writable_roots: vec![parent.clone()],
             network_access: false,
             exclude_tmpdir_env_var: true,
             exclude_slash_tmp: true,

codex-rs/core/src/seatbelt.rs

@@ -153,7 +153,7 @@ mod tests {
         // Build a policy that only includes the two test roots as writable and
         // does not automatically include defaults TMPDIR or /tmp.
         let policy = SandboxPolicy::WorkspaceWrite {
-            writable_roots: vec![root_with_git, root_without_git],
+            writable_roots: vec![root_with_git.clone(), root_without_git.clone()],
             network_access: false,
             exclude_tmpdir_env_var: true,
             exclude_slash_tmp: true,

codex-rs/core/src/seatbelt_base_policy.sbpl

@@ -69,8 +69,3 @@
 ; Added on top of Chrome profile
 ; Needed for python multiprocessing on MacOS for the SemLock
 (allow ipc-posix-sem)
-
-; needed to look up user info, see https://crbug.com/792228
-(allow mach-lookup
-  (global-name "com.apple.system.opendirectoryd.libinfo")
-)

codex-rs/core/src/shell.rs

@@ -326,7 +326,10 @@ mod tests {
                 .format_default_shell_invocation(input.iter().map(|s| s.to_string()).collect());
             let expected_cmd = expected_cmd
                 .iter()
-                .map(|s| s.replace("BASHRC_PATH", bashrc_path.to_str().unwrap()))
+                .map(|s| {
+                    s.replace("BASHRC_PATH", bashrc_path.to_str().unwrap())
+                        .to_string()
+                })
                 .collect();
 
             assert_eq!(actual_cmd, Some(expected_cmd));
@@ -432,7 +435,10 @@ mod macos_tests {
                 .format_default_shell_invocation(input.iter().map(|s| s.to_string()).collect());
             let expected_cmd = expected_cmd
                 .iter()
-                .map(|s| s.replace("ZSHRC_PATH", zshrc_path.to_str().unwrap()))
+                .map(|s| {
+                    s.replace("ZSHRC_PATH", zshrc_path.to_str().unwrap())
+                        .to_string()
+                })
                 .collect();
 
             assert_eq!(actual_cmd, Some(expected_cmd));

codex-rs/core/src/token_data.rs

@@ -3,6 +3,8 @@ use serde::Deserialize;
 use serde::Serialize;
 use thiserror::Error;
 
+use codex_protocol::mcp_protocol::AuthMode;
+
 #[derive(Deserialize, Serialize, Clone, Debug, PartialEq, Default)]
 pub struct TokenData {
     /// Flat info parsed from the JWT in auth.json.
@@ -20,6 +22,36 @@ pub struct TokenData {
     pub account_id: Option<String>,
 }
 
+impl TokenData {
+    /// Returns true if this is a plan that should use the traditional
+    /// "metered" billing via an API key.
+    pub(crate) fn should_use_api_key(
+        &self,
+        preferred_auth_method: AuthMode,
+        is_openai_email: bool,
+    ) -> bool {
+        if preferred_auth_method == AuthMode::ApiKey {
+            return true;
+        }
+        // If the email is an OpenAI email, use AuthMode::ChatGPT unless preferred_auth_method is AuthMode::ApiKey.
+        if is_openai_email {
+            return false;
+        }
+
+        self.id_token
+            .chatgpt_plan_type
+            .as_ref()
+            .is_none_or(|plan| plan.is_plan_that_should_use_api_key())
+    }
+
+    pub fn is_openai_email(&self) -> bool {
+        self.id_token
+            .email
+            .as_deref()
+            .is_some_and(|email| email.trim().to_ascii_lowercase().ends_with("@openai.com"))
+    }
+}
+
 /// Flat subset of useful claims in id_token from auth.json.
 #[derive(Debug, Clone, PartialEq, Eq, Default, Serialize, Deserialize)]
 pub struct IdTokenInfo {
@@ -47,6 +79,28 @@ pub(crate) enum PlanType {
     Unknown(String),
 }
 
+impl PlanType {
+    fn is_plan_that_should_use_api_key(&self) -> bool {
+        match self {
+            Self::Known(known) => {
+                use KnownPlan::*;
+                !matches!(known, Free | Plus | Pro | Team)
+            }
+            Self::Unknown(_) => {
+                // Unknown plans should use the API key.
+                true
+            }
+        }
+    }
+
+    pub fn as_string(&self) -> String {
+        match self {
+            Self::Known(known) => format!("{known:?}").to_lowercase(),
+            Self::Unknown(s) => s.clone(),
+        }
+    }
+}
+
 #[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
 #[serde(rename_all = "lowercase")]
 pub(crate) enum KnownPlan {

codex-rs/core/src/truncate.rs

@@ -1,180 +0,0 @@
-//! Utilities for truncating large chunks of output while preserving a prefix
-//! and suffix on UTF-8 boundaries.
-
-/// Truncate the middle of a UTF-8 string to at most `max_bytes` bytes,
-/// preserving the beginning and the end. Returns the possibly truncated
-/// string and `Some(original_token_count)` (estimated at 4 bytes/token)
-/// if truncation occurred; otherwise returns the original string and `None`.
-pub(crate) fn truncate_middle(s: &str, max_bytes: usize) -> (String, Option<u64>) {
-    if s.len() <= max_bytes {
-        return (s.to_string(), None);
-    }
-
-    let est_tokens = (s.len() as u64).div_ceil(4);
-    if max_bytes == 0 {
-        return (format!("…{est_tokens} tokens truncated…"), Some(est_tokens));
-    }
-
-    fn truncate_on_boundary(input: &str, max_len: usize) -> &str {
-        if input.len() <= max_len {
-            return input;
-        }
-        let mut end = max_len;
-        while end > 0 && !input.is_char_boundary(end) {
-            end -= 1;
-        }
-        &input[..end]
-    }
-
-    fn pick_prefix_end(s: &str, left_budget: usize) -> usize {
-        if let Some(head) = s.get(..left_budget)
-            && let Some(i) = head.rfind('\n')
-        {
-            return i + 1;
-        }
-        truncate_on_boundary(s, left_budget).len()
-    }
-
-    fn pick_suffix_start(s: &str, right_budget: usize) -> usize {
-        let start_tail = s.len().saturating_sub(right_budget);
-        if let Some(tail) = s.get(start_tail..)
-            && let Some(i) = tail.find('\n')
-        {
-            return start_tail + i + 1;
-        }
-
-        let mut idx = start_tail.min(s.len());
-        while idx < s.len() && !s.is_char_boundary(idx) {
-            idx += 1;
-        }
-        idx
-    }
-
-    let mut guess_tokens = est_tokens;
-    for _ in 0..4 {
-        let marker = format!("…{guess_tokens} tokens truncated…");
-        let marker_len = marker.len();
-        let keep_budget = max_bytes.saturating_sub(marker_len);
-        if keep_budget == 0 {
-            return (format!("…{est_tokens} tokens truncated…"), Some(est_tokens));
-        }
-
-        let left_budget = keep_budget / 2;
-        let right_budget = keep_budget - left_budget;
-        let prefix_end = pick_prefix_end(s, left_budget);
-        let mut suffix_start = pick_suffix_start(s, right_budget);
-        if suffix_start < prefix_end {
-            suffix_start = prefix_end;
-        }
-
-        let kept_content_bytes = prefix_end + (s.len() - suffix_start);
-        let truncated_content_bytes = s.len().saturating_sub(kept_content_bytes);
-        let new_tokens = (truncated_content_bytes as u64).div_ceil(4);
-
-        if new_tokens == guess_tokens {
-            let mut out = String::with_capacity(marker_len + kept_content_bytes + 1);
-            out.push_str(&s[..prefix_end]);
-            out.push_str(&marker);
-            out.push('\n');
-            out.push_str(&s[suffix_start..]);
-            return (out, Some(est_tokens));
-        }
-
-        guess_tokens = new_tokens;
-    }
-
-    let marker = format!("…{guess_tokens} tokens truncated…");
-    let marker_len = marker.len();
-    let keep_budget = max_bytes.saturating_sub(marker_len);
-    if keep_budget == 0 {
-        return (format!("…{est_tokens} tokens truncated…"), Some(est_tokens));
-    }
-
-    let left_budget = keep_budget / 2;
-    let right_budget = keep_budget - left_budget;
-    let prefix_end = pick_prefix_end(s, left_budget);
-    let suffix_start = pick_suffix_start(s, right_budget);
-
-    let mut out = String::with_capacity(marker_len + prefix_end + (s.len() - suffix_start) + 1);
-    out.push_str(&s[..prefix_end]);
-    out.push_str(&marker);
-    out.push('\n');
-    out.push_str(&s[suffix_start..]);
-    (out, Some(est_tokens))
-}
-
-#[cfg(test)]
-mod tests {
-    use super::truncate_middle;
-
-    #[test]
-    fn truncate_middle_no_newlines_fallback() {
-        let s = "abcdefghijklmnopqrstuvwxyz0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ*";
-        let max_bytes = 32;
-        let (out, original) = truncate_middle(s, max_bytes);
-        assert!(out.starts_with("abc"));
-        assert!(out.contains("tokens truncated"));
-        assert!(out.ends_with("XYZ*"));
-        assert_eq!(original, Some((s.len() as u64).div_ceil(4)));
-    }
-
-    #[test]
-    fn truncate_middle_prefers_newline_boundaries() {
-        let mut s = String::new();
-        for i in 1..=20 {
-            s.push_str(&format!("{i:03}\n"));
-        }
-        assert_eq!(s.len(), 80);
-
-        let max_bytes = 64;
-        let (out, tokens) = truncate_middle(&s, max_bytes);
-        assert!(out.starts_with("001\n002\n003\n004\n"));
-        assert!(out.contains("tokens truncated"));
-        assert!(out.ends_with("017\n018\n019\n020\n"));
-        assert_eq!(tokens, Some(20));
-    }
-
-    #[test]
-    fn truncate_middle_handles_utf8_content() {
-        let s = "😀😀😀😀😀😀😀😀😀😀\nsecond line with ascii text\n";
-        let max_bytes = 32;
-        let (out, tokens) = truncate_middle(s, max_bytes);
-
-        assert!(out.contains("tokens truncated"));
-        assert!(!out.contains('\u{fffd}'));
-        assert_eq!(tokens, Some((s.len() as u64).div_ceil(4)));
-    }
-
-    #[test]
-    fn truncate_middle_prefers_newline_boundaries_2() {
-        // Build a multi-line string of 20 numbered lines (each "NNN\n").
-        let mut s = String::new();
-        for i in 1..=20 {
-            s.push_str(&format!("{i:03}\n"));
-        }
-        // Total length: 20 lines * 4 bytes per line = 80 bytes.
-        assert_eq!(s.len(), 80);
-
-        // Choose a cap that forces truncation while leaving room for
-        // a few lines on each side after accounting for the marker.
-        let max_bytes = 64;
-        // Expect exact output: first 4 lines, marker, last 4 lines, and correct token estimate (80/4 = 20).
-        assert_eq!(
-            truncate_middle(&s, max_bytes),
-            (
-                r#"001
-002
-003
-004
-…12 tokens truncated…
-017
-018
-019
-020
-"#
-                .to_string(),
-                Some(20)
-            )
-        );
-    }
-}

codex-rs/core/src/turn_diff_tracker.rs

@@ -678,7 +678,7 @@ index {left_oid}..{right_oid}
         let dest = dir.path().join("dest.txt");
         let mut acc = TurnDiffTracker::new();
         let mv = HashMap::from([(
-            src,
+            src.clone(),
             FileChange::Update {
                 unified_diff: "".into(),
                 move_path: Some(dest.clone()),

codex-rs/core/src/unified_exec/errors.rs

@@ -1,22 +0,0 @@
-use thiserror::Error;
-
-#[derive(Debug, Error)]
-pub(crate) enum UnifiedExecError {
-    #[error("Failed to create unified exec session: {pty_error}")]
-    CreateSession {
-        #[source]
-        pty_error: anyhow::Error,
-    },
-    #[error("Unknown session id {session_id}")]
-    UnknownSessionId { session_id: i32 },
-    #[error("failed to write to stdin")]
-    WriteToStdin,
-    #[error("missing command line for unified exec request")]
-    MissingCommandLine,
-}
-
-impl UnifiedExecError {
-    pub(crate) fn create_session(error: anyhow::Error) -> Self {
-        Self::CreateSession { pty_error: error }
-    }
-}

codex-rs/core/src/unified_exec/mod.rs

@@ -1,633 +0,0 @@
-use portable_pty::CommandBuilder;
-use portable_pty::PtySize;
-use portable_pty::native_pty_system;
-use std::collections::HashMap;
-use std::collections::VecDeque;
-use std::io::ErrorKind;
-use std::io::Read;
-use std::sync::Arc;
-use std::sync::Mutex as StdMutex;
-use std::sync::atomic::AtomicBool;
-use std::sync::atomic::AtomicI32;
-use std::sync::atomic::Ordering;
-use tokio::sync::Mutex;
-use tokio::sync::Notify;
-use tokio::sync::mpsc;
-use tokio::task::JoinHandle;
-use tokio::time::Duration;
-use tokio::time::Instant;
-
-use crate::exec_command::ExecCommandSession;
-use crate::truncate::truncate_middle;
-
-mod errors;
-
-pub(crate) use errors::UnifiedExecError;
-
-const DEFAULT_TIMEOUT_MS: u64 = 1_000;
-const MAX_TIMEOUT_MS: u64 = 60_000;
-const UNIFIED_EXEC_OUTPUT_MAX_BYTES: usize = 128 * 1024; // 128 KiB
-
-#[derive(Debug)]
-pub(crate) struct UnifiedExecRequest<'a> {
-    pub session_id: Option<i32>,
-    pub input_chunks: &'a [String],
-    pub timeout_ms: Option<u64>,
-}
-
-#[derive(Debug, Clone, PartialEq)]
-pub(crate) struct UnifiedExecResult {
-    pub session_id: Option<i32>,
-    pub output: String,
-}
-
-#[derive(Debug, Default)]
-pub(crate) struct UnifiedExecSessionManager {
-    next_session_id: AtomicI32,
-    sessions: Mutex<HashMap<i32, ManagedUnifiedExecSession>>,
-}
-
-#[derive(Debug)]
-struct ManagedUnifiedExecSession {
-    session: ExecCommandSession,
-    output_buffer: OutputBuffer,
-    /// Notifies waiters whenever new output has been appended to
-    /// `output_buffer`, allowing clients to poll for fresh data.
-    output_notify: Arc<Notify>,
-    output_task: JoinHandle<()>,
-}
-
-#[derive(Debug, Default)]
-struct OutputBufferState {
-    chunks: VecDeque<Vec<u8>>,
-    total_bytes: usize,
-}
-
-impl OutputBufferState {
-    fn push_chunk(&mut self, chunk: Vec<u8>) {
-        self.total_bytes = self.total_bytes.saturating_add(chunk.len());
-        self.chunks.push_back(chunk);
-
-        let mut excess = self
-            .total_bytes
-            .saturating_sub(UNIFIED_EXEC_OUTPUT_MAX_BYTES);
-
-        while excess > 0 {
-            match self.chunks.front_mut() {
-                Some(front) if excess >= front.len() => {
-                    excess -= front.len();
-                    self.total_bytes = self.total_bytes.saturating_sub(front.len());
-                    self.chunks.pop_front();
-                }
-                Some(front) => {
-                    front.drain(..excess);
-                    self.total_bytes = self.total_bytes.saturating_sub(excess);
-                    break;
-                }
-                None => break,
-            }
-        }
-    }
-
-    fn drain(&mut self) -> Vec<Vec<u8>> {
-        let drained: Vec<Vec<u8>> = self.chunks.drain(..).collect();
-        self.total_bytes = 0;
-        drained
-    }
-}
-
-type OutputBuffer = Arc<Mutex<OutputBufferState>>;
-type OutputHandles = (OutputBuffer, Arc<Notify>);
-
-impl ManagedUnifiedExecSession {
-    fn new(session: ExecCommandSession) -> Self {
-        let output_buffer = Arc::new(Mutex::new(OutputBufferState::default()));
-        let output_notify = Arc::new(Notify::new());
-        let mut receiver = session.output_receiver();
-        let buffer_clone = Arc::clone(&output_buffer);
-        let notify_clone = Arc::clone(&output_notify);
-        let output_task = tokio::spawn(async move {
-            while let Ok(chunk) = receiver.recv().await {
-                let mut guard = buffer_clone.lock().await;
-                guard.push_chunk(chunk);
-                drop(guard);
-                notify_clone.notify_waiters();
-            }
-        });
-
-        Self {
-            session,
-            output_buffer,
-            output_notify,
-            output_task,
-        }
-    }
-
-    fn writer_sender(&self) -> mpsc::Sender<Vec<u8>> {
-        self.session.writer_sender()
-    }
-
-    fn output_handles(&self) -> OutputHandles {
-        (
-            Arc::clone(&self.output_buffer),
-            Arc::clone(&self.output_notify),
-        )
-    }
-
-    fn has_exited(&self) -> bool {
-        self.session.has_exited()
-    }
-}
-
-impl Drop for ManagedUnifiedExecSession {
-    fn drop(&mut self) {
-        self.output_task.abort();
-    }
-}
-
-impl UnifiedExecSessionManager {
-    pub async fn handle_request(
-        &self,
-        request: UnifiedExecRequest<'_>,
-    ) -> Result<UnifiedExecResult, UnifiedExecError> {
-        let (timeout_ms, timeout_warning) = match request.timeout_ms {
-            Some(requested) if requested > MAX_TIMEOUT_MS => (
-                MAX_TIMEOUT_MS,
-                Some(format!(
-                    "Warning: requested timeout {requested}ms exceeds maximum of {MAX_TIMEOUT_MS}ms; clamping to {MAX_TIMEOUT_MS}ms.\n"
-                )),
-            ),
-            Some(requested) => (requested, None),
-            None => (DEFAULT_TIMEOUT_MS, None),
-        };
-
-        let mut new_session: Option<ManagedUnifiedExecSession> = None;
-        let session_id;
-        let writer_tx;
-        let output_buffer;
-        let output_notify;
-
-        if let Some(existing_id) = request.session_id {
-            let mut sessions = self.sessions.lock().await;
-            match sessions.get(&existing_id) {
-                Some(session) => {
-                    if session.has_exited() {
-                        sessions.remove(&existing_id);
-                        return Err(UnifiedExecError::UnknownSessionId {
-                            session_id: existing_id,
-                        });
-                    }
-                    let (buffer, notify) = session.output_handles();
-                    session_id = existing_id;
-                    writer_tx = session.writer_sender();
-                    output_buffer = buffer;
-                    output_notify = notify;
-                }
-                None => {
-                    return Err(UnifiedExecError::UnknownSessionId {
-                        session_id: existing_id,
-                    });
-                }
-            }
-            drop(sessions);
-        } else {
-            let command = request.input_chunks.to_vec();
-            let new_id = self.next_session_id.fetch_add(1, Ordering::SeqCst);
-            let session = create_unified_exec_session(&command).await?;
-            let managed_session = ManagedUnifiedExecSession::new(session);
-            let (buffer, notify) = managed_session.output_handles();
-            writer_tx = managed_session.writer_sender();
-            output_buffer = buffer;
-            output_notify = notify;
-            session_id = new_id;
-            new_session = Some(managed_session);
-        };
-
-        if request.session_id.is_some() {
-            let joined_input = request.input_chunks.join(" ");
-            if !joined_input.is_empty() && writer_tx.send(joined_input.into_bytes()).await.is_err()
-            {
-                return Err(UnifiedExecError::WriteToStdin);
-            }
-        }
-
-        let mut collected: Vec<u8> = Vec::with_capacity(4096);
-        let start = Instant::now();
-        let deadline = start + Duration::from_millis(timeout_ms);
-
-        loop {
-            let drained_chunks;
-            let mut wait_for_output = None;
-            {
-                let mut guard = output_buffer.lock().await;
-                drained_chunks = guard.drain();
-                if drained_chunks.is_empty() {
-                    wait_for_output = Some(output_notify.notified());
-                }
-            }
-
-            if drained_chunks.is_empty() {
-                let remaining = deadline.saturating_duration_since(Instant::now());
-                if remaining == Duration::ZERO {
-                    break;
-                }
-
-                let notified = wait_for_output.unwrap_or_else(|| output_notify.notified());
-                tokio::pin!(notified);
-                tokio::select! {
-                    _ = &mut notified => {}
-                    _ = tokio::time::sleep(remaining) => break,
-                }
-                continue;
-            }
-
-            for chunk in drained_chunks {
-                collected.extend_from_slice(&chunk);
-            }
-
-            if Instant::now() >= deadline {
-                break;
-            }
-        }
-
-        let (output, _maybe_tokens) = truncate_middle(
-            &String::from_utf8_lossy(&collected),
-            UNIFIED_EXEC_OUTPUT_MAX_BYTES,
-        );
-        let output = if let Some(warning) = timeout_warning {
-            format!("{warning}{output}")
-        } else {
-            output
-        };
-
-        let should_store_session = if let Some(session) = new_session.as_ref() {
-            !session.has_exited()
-        } else if request.session_id.is_some() {
-            let mut sessions = self.sessions.lock().await;
-            if let Some(existing) = sessions.get(&session_id) {
-                if existing.has_exited() {
-                    sessions.remove(&session_id);
-                    false
-                } else {
-                    true
-                }
-            } else {
-                false
-            }
-        } else {
-            true
-        };
-
-        if should_store_session {
-            if let Some(session) = new_session {
-                self.sessions.lock().await.insert(session_id, session);
-            }
-            Ok(UnifiedExecResult {
-                session_id: Some(session_id),
-                output,
-            })
-        } else {
-            Ok(UnifiedExecResult {
-                session_id: None,
-                output,
-            })
-        }
-    }
-}
-
-async fn create_unified_exec_session(
-    command: &[String],
-) -> Result<ExecCommandSession, UnifiedExecError> {
-    if command.is_empty() {
-        return Err(UnifiedExecError::MissingCommandLine);
-    }
-
-    let pty_system = native_pty_system();
-
-    let pair = pty_system
-        .openpty(PtySize {
-            rows: 24,
-            cols: 80,
-            pixel_width: 0,
-            pixel_height: 0,
-        })
-        .map_err(UnifiedExecError::create_session)?;
-
-    // Safe thanks to the check at the top of the function.
-    let mut command_builder = CommandBuilder::new(command[0].clone());
-    for arg in &command[1..] {
-        command_builder.arg(arg);
-    }
-
-    let mut child = pair
-        .slave
-        .spawn_command(command_builder)
-        .map_err(UnifiedExecError::create_session)?;
-    let killer = child.clone_killer();
-
-    let (writer_tx, mut writer_rx) = mpsc::channel::<Vec<u8>>(128);
-    let (output_tx, _) = tokio::sync::broadcast::channel::<Vec<u8>>(256);
-
-    let mut reader = pair
-        .master
-        .try_clone_reader()
-        .map_err(UnifiedExecError::create_session)?;
-    let output_tx_clone = output_tx.clone();
-    let reader_handle = tokio::task::spawn_blocking(move || {
-        let mut buf = [0u8; 8192];
-        loop {
-            match reader.read(&mut buf) {
-                Ok(0) => break,
-                Ok(n) => {
-                    let _ = output_tx_clone.send(buf[..n].to_vec());
-                }
-                Err(ref e) if e.kind() == ErrorKind::Interrupted => continue,
-                Err(ref e) if e.kind() == ErrorKind::WouldBlock => {
-                    std::thread::sleep(Duration::from_millis(5));
-                    continue;
-                }
-                Err(_) => break,
-            }
-        }
-    });
-
-    let writer = pair
-        .master
-        .take_writer()
-        .map_err(UnifiedExecError::create_session)?;
-    let writer = Arc::new(StdMutex::new(writer));
-    let writer_handle = tokio::spawn({
-        let writer = writer.clone();
-        async move {
-            while let Some(bytes) = writer_rx.recv().await {
-                let writer = writer.clone();
-                let _ = tokio::task::spawn_blocking(move || {
-                    if let Ok(mut guard) = writer.lock() {
-                        use std::io::Write;
-                        let _ = guard.write_all(&bytes);
-                        let _ = guard.flush();
-                    }
-                })
-                .await;
-            }
-        }
-    });
-
-    let exit_status = Arc::new(AtomicBool::new(false));
-    let wait_exit_status = Arc::clone(&exit_status);
-    let wait_handle = tokio::task::spawn_blocking(move || {
-        let _ = child.wait();
-        wait_exit_status.store(true, Ordering::SeqCst);
-    });
-
-    Ok(ExecCommandSession::new(
-        writer_tx,
-        output_tx,
-        killer,
-        reader_handle,
-        writer_handle,
-        wait_handle,
-        exit_status,
-    ))
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn push_chunk_trims_only_excess_bytes() {
-        let mut buffer = OutputBufferState::default();
-        buffer.push_chunk(vec![b'a'; UNIFIED_EXEC_OUTPUT_MAX_BYTES]);
-        buffer.push_chunk(vec![b'b']);
-        buffer.push_chunk(vec![b'c']);
-
-        assert_eq!(buffer.total_bytes, UNIFIED_EXEC_OUTPUT_MAX_BYTES);
-        assert_eq!(buffer.chunks.len(), 3);
-        assert_eq!(
-            buffer.chunks.front().unwrap().len(),
-            UNIFIED_EXEC_OUTPUT_MAX_BYTES - 2
-        );
-        assert_eq!(buffer.chunks.pop_back().unwrap(), vec![b'c']);
-        assert_eq!(buffer.chunks.pop_back().unwrap(), vec![b'b']);
-    }
-
-    #[cfg(unix)]
-    #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
-    async fn unified_exec_persists_across_requests_jif() -> Result<(), UnifiedExecError> {
-        let manager = UnifiedExecSessionManager::default();
-
-        let open_shell = manager
-            .handle_request(UnifiedExecRequest {
-                session_id: None,
-                input_chunks: &["bash".to_string(), "-i".to_string()],
-                timeout_ms: Some(1_500),
-            })
-            .await?;
-        let session_id = open_shell.session_id.expect("expected session_id");
-
-        manager
-            .handle_request(UnifiedExecRequest {
-                session_id: Some(session_id),
-                input_chunks: &[
-                    "export".to_string(),
-                    "CODEX_INTERACTIVE_SHELL_VAR=codex\n".to_string(),
-                ],
-                timeout_ms: Some(2_500),
-            })
-            .await?;
-
-        let out_2 = manager
-            .handle_request(UnifiedExecRequest {
-                session_id: Some(session_id),
-                input_chunks: &["echo $CODEX_INTERACTIVE_SHELL_VAR\n".to_string()],
-                timeout_ms: Some(1_500),
-            })
-            .await?;
-        assert!(out_2.output.contains("codex"));
-
-        Ok(())
-    }
-
-    #[cfg(unix)]
-    #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
-    async fn multi_unified_exec_sessions() -> Result<(), UnifiedExecError> {
-        let manager = UnifiedExecSessionManager::default();
-
-        let shell_a = manager
-            .handle_request(UnifiedExecRequest {
-                session_id: None,
-                input_chunks: &["/bin/bash".to_string(), "-i".to_string()],
-                timeout_ms: Some(1_500),
-            })
-            .await?;
-        let session_a = shell_a.session_id.expect("expected session id");
-
-        manager
-            .handle_request(UnifiedExecRequest {
-                session_id: Some(session_a),
-                input_chunks: &["export CODEX_INTERACTIVE_SHELL_VAR=codex\n".to_string()],
-                timeout_ms: Some(1_500),
-            })
-            .await?;
-
-        let out_2 = manager
-            .handle_request(UnifiedExecRequest {
-                session_id: None,
-                input_chunks: &[
-                    "echo".to_string(),
-                    "$CODEX_INTERACTIVE_SHELL_VAR\n".to_string(),
-                ],
-                timeout_ms: Some(1_500),
-            })
-            .await?;
-        assert!(!out_2.output.contains("codex"));
-
-        let out_3 = manager
-            .handle_request(UnifiedExecRequest {
-                session_id: Some(session_a),
-                input_chunks: &["echo $CODEX_INTERACTIVE_SHELL_VAR\n".to_string()],
-                timeout_ms: Some(1_500),
-            })
-            .await?;
-        assert!(out_3.output.contains("codex"));
-
-        Ok(())
-    }
-
-    #[cfg(unix)]
-    #[tokio::test]
-    async fn unified_exec_timeouts() -> Result<(), UnifiedExecError> {
-        let manager = UnifiedExecSessionManager::default();
-
-        let open_shell = manager
-            .handle_request(UnifiedExecRequest {
-                session_id: None,
-                input_chunks: &["bash".to_string(), "-i".to_string()],
-                timeout_ms: Some(1_500),
-            })
-            .await?;
-        let session_id = open_shell.session_id.expect("expected session id");
-
-        manager
-            .handle_request(UnifiedExecRequest {
-                session_id: Some(session_id),
-                input_chunks: &[
-                    "export".to_string(),
-                    "CODEX_INTERACTIVE_SHELL_VAR=codex\n".to_string(),
-                ],
-                timeout_ms: Some(1_500),
-            })
-            .await?;
-
-        let out_2 = manager
-            .handle_request(UnifiedExecRequest {
-                session_id: Some(session_id),
-                input_chunks: &["sleep 5 && echo $CODEX_INTERACTIVE_SHELL_VAR\n".to_string()],
-                timeout_ms: Some(10),
-            })
-            .await?;
-        assert!(!out_2.output.contains("codex"));
-
-        tokio::time::sleep(Duration::from_secs(7)).await;
-
-        let empty = Vec::new();
-        let out_3 = manager
-            .handle_request(UnifiedExecRequest {
-                session_id: Some(session_id),
-                input_chunks: &empty,
-                timeout_ms: Some(100),
-            })
-            .await?;
-
-        assert!(out_3.output.contains("codex"));
-
-        Ok(())
-    }
-
-    #[cfg(unix)]
-    #[tokio::test]
-    async fn requests_with_large_timeout_are_capped() -> Result<(), UnifiedExecError> {
-        let manager = UnifiedExecSessionManager::default();
-
-        let result = manager
-            .handle_request(UnifiedExecRequest {
-                session_id: None,
-                input_chunks: &["echo".to_string(), "codex".to_string()],
-                timeout_ms: Some(120_000),
-            })
-            .await?;
-
-        assert!(result.output.starts_with(
-            "Warning: requested timeout 120000ms exceeds maximum of 60000ms; clamping to 60000ms.\n"
-        ));
-        assert!(result.output.contains("codex"));
-
-        Ok(())
-    }
-
-    #[cfg(unix)]
-    #[tokio::test]
-    async fn completed_commands_do_not_persist_sessions() -> Result<(), UnifiedExecError> {
-        let manager = UnifiedExecSessionManager::default();
-        let result = manager
-            .handle_request(UnifiedExecRequest {
-                session_id: None,
-                input_chunks: &["/bin/echo".to_string(), "codex".to_string()],
-                timeout_ms: Some(1_500),
-            })
-            .await?;
-
-        assert!(result.session_id.is_none());
-        assert!(result.output.contains("codex"));
-
-        assert!(manager.sessions.lock().await.is_empty());
-
-        Ok(())
-    }
-
-    #[cfg(unix)]
-    #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
-    async fn reusing_completed_session_returns_unknown_session() -> Result<(), UnifiedExecError> {
-        let manager = UnifiedExecSessionManager::default();
-
-        let open_shell = manager
-            .handle_request(UnifiedExecRequest {
-                session_id: None,
-                input_chunks: &["/bin/bash".to_string(), "-i".to_string()],
-                timeout_ms: Some(1_500),
-            })
-            .await?;
-        let session_id = open_shell.session_id.expect("expected session id");
-
-        manager
-            .handle_request(UnifiedExecRequest {
-                session_id: Some(session_id),
-                input_chunks: &["exit\n".to_string()],
-                timeout_ms: Some(1_500),
-            })
-            .await?;
-
-        tokio::time::sleep(Duration::from_millis(200)).await;
-
-        let err = manager
-            .handle_request(UnifiedExecRequest {
-                session_id: Some(session_id),
-                input_chunks: &[],
-                timeout_ms: Some(100),
-            })
-            .await
-            .expect_err("expected unknown session error");
-
-        match err {
-            UnifiedExecError::UnknownSessionId { session_id: err_id } => {
-                assert_eq!(err_id, session_id);
-            }
-            other => panic!("expected UnknownSessionId, got {other:?}"),
-        }
-
-        assert!(!manager.sessions.lock().await.contains_key(&session_id));
-
-        Ok(())
-    }
-}

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

@@ -1,6 +1,4 @@
 use assert_cmd::Command as AssertCommand;
-use codex_core::RolloutRecorder;
-use codex_core::protocol::GitInfo;
 use codex_core::spawn::CODEX_SANDBOX_NETWORK_DISABLED_ENV_VAR;
 use std::time::Duration;
 use std::time::Instant;
@@ -79,22 +77,6 @@ async fn chat_mode_stream_cli() {
     assert_eq!(hi_lines, 1, "Expected exactly one line with 'hi'");
 
     server.verify().await;
-
-    // Verify a new session rollout was created and is discoverable via list_conversations
-    let page = RolloutRecorder::list_conversations(home.path(), 10, None)
-        .await
-        .expect("list conversations");
-    assert!(
-        !page.items.is_empty(),
-        "expected at least one session to be listed"
-    );
-    // First line of head must be the SessionMeta payload (id/timestamp)
-    let head0 = page.items[0].head.first().expect("missing head record");
-    assert!(head0.get("id").is_some(), "head[0] missing id");
-    assert!(
-        head0.get("timestamp").is_some(),
-        "head[0] missing timestamp"
-    );
 }
 
 /// Verify that passing `-c experimental_instructions_file=...` to the CLI
@@ -315,10 +297,8 @@ async fn integration_creates_and_checks_session_file() {
                     Ok(v) => v,
                     Err(_) => continue,
                 };
-                if item.get("type").and_then(|t| t.as_str()) == Some("response_item")
-                    && let Some(payload) = item.get("payload")
-                    && payload.get("type").and_then(|t| t.as_str()) == Some("message")
-                    && let Some(c) = payload.get("content")
+                if item.get("type").and_then(|t| t.as_str()) == Some("message")
+                    && let Some(c) = item.get("content")
                     && c.to_string().contains(&marker)
                 {
                     matching_path = Some(path.to_path_buf());
@@ -381,16 +361,9 @@ async fn integration_creates_and_checks_session_file() {
         .unwrap_or_else(|_| panic!("missing session meta line"));
     let meta: serde_json::Value = serde_json::from_str(meta_line)
         .unwrap_or_else(|_| panic!("Failed to parse session meta line as JSON"));
-    assert_eq!(
-        meta.get("type").and_then(|v| v.as_str()),
-        Some("session_meta")
-    );
-    let payload = meta
-        .get("payload")
-        .unwrap_or_else(|| panic!("Missing payload in meta line"));
-    assert!(payload.get("id").is_some(), "SessionMeta missing id");
+    assert!(meta.get("id").is_some(), "SessionMeta missing id");
     assert!(
-        payload.get("timestamp").is_some(),
+        meta.get("timestamp").is_some(),
         "SessionMeta missing timestamp"
     );
 
@@ -402,10 +375,8 @@ async fn integration_creates_and_checks_session_file() {
         let Ok(item) = serde_json::from_str::<serde_json::Value>(line) else {
             continue;
         };
-        if item.get("type").and_then(|t| t.as_str()) == Some("response_item")
-            && let Some(payload) = item.get("payload")
-            && payload.get("type").and_then(|t| t.as_str()) == Some("message")
-            && let Some(c) = payload.get("content")
+        if item.get("type").and_then(|t| t.as_str()) == Some("message")
+            && let Some(c) = item.get("content")
             && c.to_string().contains(&marker)
         {
             found_message = true;
@@ -618,7 +589,7 @@ async fn integration_git_info_unit_test() {
 
     // 5. Test serialization to ensure it works in SessionMeta
     let serialized = serde_json::to_string(&git_info).unwrap();
-    let deserialized: GitInfo = serde_json::from_str(&serialized).unwrap();
+    let deserialized: codex_core::git_info::GitInfo = serde_json::from_str(&serialized).unwrap();
 
     assert_eq!(git_info.commit_hash, deserialized.commit_hash);
     assert_eq!(git_info.branch, deserialized.branch);

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

@@ -4,10 +4,14 @@ use codex_core::ModelProviderInfo;
 use codex_core::NewConversation;
 use codex_core::WireApi;
 use codex_core::built_in_model_providers;
+use codex_core::protocol::AgentMessageEvent;
 use codex_core::protocol::EventMsg;
 use codex_core::protocol::InputItem;
+use codex_core::protocol::InputMessageKind;
 use codex_core::protocol::Op;
+use codex_core::protocol::UserMessageEvent;
 use codex_core::spawn::CODEX_SANDBOX_NETWORK_DISABLED_ENV_VAR;
+use codex_protocol::mcp_protocol::AuthMode;
 use core_test_support::load_default_config_for_test;
 use core_test_support::load_sse_fixture_with_id;
 use core_test_support::wait_for_event;
@@ -122,21 +126,16 @@ async fn resume_includes_initial_messages_and_sends_prior_items() {
     let tmpdir = TempDir::new().unwrap();
     let session_path = tmpdir.path().join("resume-session.jsonl");
     let mut f = std::fs::File::create(&session_path).unwrap();
-    let convo_id = Uuid::new_v4();
     writeln!(
         f,
         "{}",
         json!({
-            "timestamp": "2024-01-01T00:00:00.000Z",
-            "type": "session_meta",
-            "payload": {
-                "id": convo_id,
-                "timestamp": "2024-01-01T00:00:00Z",
-                "instructions": "be nice",
-                "cwd": ".",
-                "originator": "test_originator",
-                "cli_version": "test_version"
-            }
+            "record_type": "session_meta",
+            "id": Uuid::new_v4(),
+            "timestamp": "2024-01-01T00:00:00Z",
+            "cwd": tmpdir.path().to_string_lossy(),
+            "originator": "test",
+            "cli_version": "0.0.0-test"
         })
     )
     .unwrap();
@@ -149,17 +148,30 @@ async fn resume_includes_initial_messages_and_sends_prior_items() {
             text: "resumed user message".to_string(),
         }],
     };
-    let prior_user_json = serde_json::to_value(&prior_user).unwrap();
-    writeln!(
-        f,
-        "{}",
-        json!({
-            "timestamp": "2024-01-01T00:00:01.000Z",
-            "type": "response_item",
-            "payload": prior_user_json
-        })
-    )
-    .unwrap();
+    let mut prior_user_obj = serde_json::to_value(&prior_user)
+        .unwrap()
+        .as_object()
+        .unwrap()
+        .clone();
+    prior_user_obj.insert("record_type".to_string(), serde_json::json!("response"));
+    prior_user_obj.insert(
+        "timestamp".to_string(),
+        serde_json::json!("2025-01-01T00:00:00Z"),
+    );
+    writeln!(f, "{}", serde_json::Value::Object(prior_user_obj)).unwrap();
+
+    // Also include a matching user message event to preserve ordering at resume
+    let prior_user_event = EventMsg::UserMessage(UserMessageEvent {
+        message: "resumed user message".to_string(),
+        kind: Some(InputMessageKind::Plain),
+    });
+    let prior_user_event_line = serde_json::json!({
+        "timestamp": "2025-01-01T00:00:00Z",
+        "record_type": "event",
+        "id": "resume-0",
+        "msg": prior_user_event,
+    });
+    writeln!(f, "{prior_user_event_line}").unwrap();
 
     // Prior item: system message (excluded from API history)
     let prior_system = codex_protocol::models::ResponseItem::Message {
@@ -169,17 +181,17 @@ async fn resume_includes_initial_messages_and_sends_prior_items() {
             text: "resumed system instruction".to_string(),
         }],
     };
-    let prior_system_json = serde_json::to_value(&prior_system).unwrap();
-    writeln!(
-        f,
-        "{}",
-        json!({
-            "timestamp": "2024-01-01T00:00:02.000Z",
-            "type": "response_item",
-            "payload": prior_system_json
-        })
-    )
-    .unwrap();
+    let mut prior_system_obj = serde_json::to_value(&prior_system)
+        .unwrap()
+        .as_object()
+        .unwrap()
+        .clone();
+    prior_system_obj.insert("record_type".to_string(), serde_json::json!("response"));
+    prior_system_obj.insert(
+        "timestamp".to_string(),
+        serde_json::json!("2025-01-01T00:00:00Z"),
+    );
+    writeln!(f, "{}", serde_json::Value::Object(prior_system_obj)).unwrap();
 
     // Prior item: assistant message
     let prior_item = codex_protocol::models::ResponseItem::Message {
@@ -189,17 +201,27 @@ async fn resume_includes_initial_messages_and_sends_prior_items() {
             text: "resumed assistant message".to_string(),
         }],
     };
-    let prior_item_json = serde_json::to_value(&prior_item).unwrap();
-    writeln!(
-        f,
-        "{}",
-        json!({
-            "timestamp": "2024-01-01T00:00:03.000Z",
-            "type": "response_item",
-            "payload": prior_item_json
-        })
-    )
-    .unwrap();
+    let mut prior_item_obj = serde_json::to_value(&prior_item)
+        .unwrap()
+        .as_object()
+        .unwrap()
+        .clone();
+    prior_item_obj.insert("record_type".to_string(), serde_json::json!("response"));
+    prior_item_obj.insert(
+        "timestamp".to_string(),
+        serde_json::json!("2025-01-01T00:00:00Z"),
+    );
+    writeln!(f, "{}", serde_json::Value::Object(prior_item_obj)).unwrap();
+    let prior_item_event = EventMsg::AgentMessage(AgentMessageEvent {
+        message: "resumed assistant message".to_string(),
+    });
+    let prior_event_line = serde_json::json!({
+        "timestamp": "2025-01-01T00:00:00Z",
+        "record_type": "event",
+        "id": "resume-1",
+        "msg": prior_item_event,
+    });
+    writeln!(f, "{prior_event_line}").unwrap();
     drop(f);
 
     // Mock server that will receive the resumed request
@@ -237,13 +259,16 @@ async fn resume_includes_initial_messages_and_sends_prior_items() {
         .await
         .expect("create new conversation");
 
-    // 1) Assert initial_messages only includes existing EventMsg entries; response items are not converted
+    // 1) Assert initial_messages contains the prior user + assistant messages as EventMsg entries
     let initial_msgs = session_configured
         .initial_messages
         .clone()
-        .expect("expected initial messages option for resumed session");
+        .expect("expected initial messages for resumed session");
     let initial_json = serde_json::to_value(&initial_msgs).unwrap();
-    let expected_initial_json = json!([]);
+    let expected_initial_json = json!([
+        { "type": "user_message", "message": "resumed user message", "kind": "plain" },
+        { "type": "agent_message", "message": "resumed assistant message" }
+    ]);
     assert_eq!(initial_json, expected_initial_json);
 
     // 2) Submit new input; the request body must include the prior item followed by the new user input.
@@ -409,6 +434,56 @@ async fn includes_base_instructions_override_in_request() {
     );
 }
 
+#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
+async fn originator_config_override_is_used() {
+    // Mock server
+    let server = MockServer::start().await;
+
+    let first = ResponseTemplate::new(200)
+        .insert_header("content-type", "text/event-stream")
+        .set_body_raw(sse_completed("resp1"), "text/event-stream");
+
+    Mock::given(method("POST"))
+        .and(path("/v1/responses"))
+        .respond_with(first)
+        .expect(1)
+        .mount(&server)
+        .await;
+
+    let model_provider = ModelProviderInfo {
+        base_url: Some(format!("{}/v1", server.uri())),
+        ..built_in_model_providers()["openai"].clone()
+    };
+
+    let codex_home = TempDir::new().unwrap();
+    let mut config = load_default_config_for_test(&codex_home);
+    config.model_provider = model_provider;
+    config.responses_originator_header = "my_override".to_owned();
+
+    let conversation_manager =
+        ConversationManager::with_auth(CodexAuth::from_api_key("Test API Key"));
+    let codex = conversation_manager
+        .new_conversation(config)
+        .await
+        .expect("create new conversation")
+        .conversation;
+
+    codex
+        .submit(Op::UserInput {
+            items: vec![InputItem::Text {
+                text: "hello".into(),
+            }],
+        })
+        .await
+        .unwrap();
+
+    wait_for_event(&codex, |ev| matches!(ev, EventMsg::TaskComplete(_))).await;
+
+    let request = &server.received_requests().await.unwrap()[0];
+    let request_originator = request.headers.get("originator").unwrap();
+    assert_eq!(request_originator.to_str().unwrap(), "my_override");
+}
+
 #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
 async fn chatgpt_auth_sends_correct_request() {
     if std::env::var(CODEX_SANDBOX_NETWORK_DISABLED_ENV_VAR).is_ok() {
@@ -488,6 +563,82 @@ async fn chatgpt_auth_sends_correct_request() {
     );
 }
 
+#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
+async fn prefers_chatgpt_token_when_config_prefers_chatgpt() {
+    if std::env::var(CODEX_SANDBOX_NETWORK_DISABLED_ENV_VAR).is_ok() {
+        println!(
+            "Skipping test because it cannot execute when network is disabled in a Codex sandbox."
+        );
+        return;
+    }
+
+    // Mock server
+    let server = MockServer::start().await;
+
+    let first = ResponseTemplate::new(200)
+        .insert_header("content-type", "text/event-stream")
+        .set_body_raw(sse_completed("resp1"), "text/event-stream");
+
+    // Expect ChatGPT base path and correct headers
+    Mock::given(method("POST"))
+        .and(path("/v1/responses"))
+        .and(header_regex("Authorization", r"Bearer Access-123"))
+        .and(header_regex("chatgpt-account-id", r"acc-123"))
+        .respond_with(first)
+        .expect(1)
+        .mount(&server)
+        .await;
+
+    let model_provider = ModelProviderInfo {
+        base_url: Some(format!("{}/v1", server.uri())),
+        ..built_in_model_providers()["openai"].clone()
+    };
+
+    // Init session
+    let codex_home = TempDir::new().unwrap();
+    // Write auth.json that contains both API key and ChatGPT tokens for a plan that should prefer ChatGPT.
+    let _jwt = write_auth_json(
+        &codex_home,
+        Some("sk-test-key"),
+        "pro",
+        "Access-123",
+        Some("acc-123"),
+    );
+
+    let mut config = load_default_config_for_test(&codex_home);
+    config.model_provider = model_provider;
+    config.preferred_auth_method = AuthMode::ChatGPT;
+
+    let auth_manager = match CodexAuth::from_codex_home(
+        codex_home.path(),
+        config.preferred_auth_method,
+        &config.responses_originator_header,
+    ) {
+        Ok(Some(auth)) => codex_core::AuthManager::from_auth_for_testing(auth),
+        Ok(None) => panic!("No CodexAuth found in codex_home"),
+        Err(e) => panic!("Failed to load CodexAuth: {e}"),
+    };
+    let conversation_manager = ConversationManager::new(auth_manager);
+    let NewConversation {
+        conversation: codex,
+        ..
+    } = conversation_manager
+        .new_conversation(config)
+        .await
+        .expect("create new conversation");
+
+    codex
+        .submit(Op::UserInput {
+            items: vec![InputItem::Text {
+                text: "hello".into(),
+            }],
+        })
+        .await
+        .unwrap();
+
+    wait_for_event(&codex, |ev| matches!(ev, EventMsg::TaskComplete(_))).await;
+}
+
 #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
 async fn prefers_apikey_when_config_prefers_apikey_even_with_chatgpt_tokens() {
     if std::env::var(CODEX_SANDBOX_NETWORK_DISABLED_ENV_VAR).is_ok() {
@@ -532,8 +683,13 @@ async fn prefers_apikey_when_config_prefers_apikey_even_with_chatgpt_tokens() {
 
     let mut config = load_default_config_for_test(&codex_home);
     config.model_provider = model_provider;
+    config.preferred_auth_method = AuthMode::ApiKey;
 
-    let auth_manager = match CodexAuth::from_codex_home(codex_home.path()) {
+    let auth_manager = match CodexAuth::from_codex_home(
+        codex_home.path(),
+        config.preferred_auth_method,
+        &config.responses_originator_header,
+    ) {
         Ok(Some(auth)) => codex_core::AuthManager::from_auth_for_testing(auth),
         Ok(None) => panic!("No CodexAuth found in codex_home"),
         Err(e) => panic!("Failed to load CodexAuth: {e}"),

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

@@ -3,13 +3,10 @@
 use codex_core::CodexAuth;
 use codex_core::ConversationManager;
 use codex_core::ModelProviderInfo;
-use codex_core::NewConversation;
 use codex_core::built_in_model_providers;
 use codex_core::protocol::EventMsg;
 use codex_core::protocol::InputItem;
 use codex_core::protocol::Op;
-use codex_core::protocol::RolloutItem;
-use codex_core::protocol::RolloutLine;
 use codex_core::spawn::CODEX_SANDBOX_NETWORK_DISABLED_ENV_VAR;
 use core_test_support::load_default_config_for_test;
 use core_test_support::wait_for_event;
@@ -145,12 +142,11 @@ async fn summarize_context_three_requests_and_instructions() {
     let mut config = load_default_config_for_test(&home);
     config.model_provider = model_provider;
     let conversation_manager = ConversationManager::with_auth(CodexAuth::from_api_key("dummy"));
-    let NewConversation {
-        conversation: codex,
-        session_configured,
-        ..
-    } = conversation_manager.new_conversation(config).await.unwrap();
-    let rollout_path = session_configured.rollout_path;
+    let codex = conversation_manager
+        .new_conversation(config)
+        .await
+        .unwrap()
+        .conversation;
 
     // 1) Normal user input – should hit server once.
     codex
@@ -252,47 +248,4 @@ async fn summarize_context_three_requests_and_instructions() {
         !messages.iter().any(|(_, t)| t.contains(SUMMARIZE_TRIGGER)),
         "third request should not include the summarize trigger"
     );
-
-    // Shut down Codex to flush rollout entries before inspecting the file.
-    codex.submit(Op::Shutdown).await.unwrap();
-    wait_for_event(&codex, |ev| matches!(ev, EventMsg::ShutdownComplete)).await;
-
-    // Verify rollout contains APITurn entries for each API call and a Compacted entry.
-    let text = std::fs::read_to_string(&rollout_path).unwrap_or_else(|e| {
-        panic!(
-            "failed to read rollout file {}: {e}",
-            rollout_path.display()
-        )
-    });
-    let mut api_turn_count = 0usize;
-    let mut saw_compacted_summary = false;
-    for line in text.lines() {
-        let trimmed = line.trim();
-        if trimmed.is_empty() {
-            continue;
-        }
-        let Ok(entry): Result<RolloutLine, _> = serde_json::from_str(trimmed) else {
-            continue;
-        };
-        match entry.item {
-            RolloutItem::TurnContext(_) => {
-                api_turn_count += 1;
-            }
-            RolloutItem::Compacted(ci) => {
-                if ci.message == SUMMARY_TEXT {
-                    saw_compacted_summary = true;
-                }
-            }
-            _ => {}
-        }
-    }
-
-    assert!(
-        api_turn_count == 3,
-        "expected three APITurn entries in rollout"
-    );
-    assert!(
-        saw_compacted_summary,
-        "expected a Compacted entry containing the summarizer output"
-    );
 }

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

@@ -1,16 +1,13 @@
 use codex_core::CodexAuth;
-use codex_core::ContentItem;
 use codex_core::ConversationManager;
 use codex_core::ModelProviderInfo;
 use codex_core::NewConversation;
-use codex_core::ResponseItem;
 use codex_core::built_in_model_providers;
 use codex_core::protocol::ConversationPathResponseEvent;
 use codex_core::protocol::EventMsg;
 use codex_core::protocol::InputItem;
 use codex_core::protocol::Op;
-use codex_core::protocol::RolloutItem;
-use codex_core::protocol::RolloutLine;
+use codex_protocol::models::ResponseItem;
 use core_test_support::load_default_config_for_test;
 use core_test_support::wait_for_event;
 use tempfile::TempDir;
@@ -75,121 +72,105 @@ async fn fork_conversation_twice_drops_to_first_message() {
         let _ = wait_for_event(&codex, |ev| matches!(ev, EventMsg::TaskComplete(_))).await;
     }
 
-    // Request history from the base conversation to obtain rollout path.
-    codex.submit(Op::GetPath).await.unwrap();
+    // Request history from the base conversation.
+    codex.submit(Op::GetConversationPath).await.unwrap();
     let base_history =
-        wait_for_event(&codex, |ev| matches!(ev, EventMsg::ConversationPath(_))).await;
-    let base_path = match &base_history {
-        EventMsg::ConversationPath(ConversationPathResponseEvent { path, .. }) => path.clone(),
+        wait_for_event(&codex, |ev| matches!(ev, EventMsg::ConversationHistory(_))).await;
+
+    // Capture path/id from the base history and compute expected prefixes after each fork.
+    let (base_conv_id, base_path) = match &base_history {
+        EventMsg::ConversationHistory(ConversationPathResponseEvent {
+            conversation_id,
+            path,
+        }) => (*conversation_id, path.clone()),
         _ => panic!("expected ConversationHistory event"),
     };
 
-    // GetHistory flushes before returning the path; no wait needed.
-
-    // Helper: read rollout items (excluding SessionMeta) from a JSONL path.
-    let read_items = |p: &std::path::Path| -> Vec<RolloutItem> {
-        let text = std::fs::read_to_string(p).expect("read rollout file");
-        let mut items: Vec<RolloutItem> = Vec::new();
+    // Read entries from rollout file.
+    async fn read_response_entries(path: &std::path::Path) -> Vec<ResponseItem> {
+        let text = tokio::fs::read_to_string(path).await.unwrap_or_default();
+        let mut out = Vec::new();
         for line in text.lines() {
             if line.trim().is_empty() {
                 continue;
             }
-            let v: serde_json::Value = serde_json::from_str(line).expect("jsonl line");
-            let rl: RolloutLine = serde_json::from_value(v).expect("rollout line");
-            match rl.item {
-                RolloutItem::SessionMeta(_) => {}
-                other => items.push(other),
+            if let Ok(item) = serde_json::from_str::<ResponseItem>(line) {
+                out.push(item);
             }
         }
-        items
-    };
+        out
+    }
+    let entries_after_three: Vec<ResponseItem> = read_response_entries(&base_path).await;
+    // History layout for this test:
+    // [0] user instructions,
+    // [1] environment context,
+    // [2] "first" user message,
+    // [3] "second" user message,
+    // [4] "third" user message.
 
-    // Compute expected prefixes after each fork by truncating base rollout at nth-from-last user input.
-    let base_items = read_items(&base_path);
-    let find_user_input_positions = |items: &[RolloutItem]| -> Vec<usize> {
-        let mut pos = Vec::new();
-        for (i, it) in items.iter().enumerate() {
-            if let RolloutItem::ResponseItem(ResponseItem::Message { role, content, .. }) = it
-                && role == "user"
-            {
-                // Consider any user message as an input boundary; recorder stores both EventMsg and ResponseItem.
-                // We specifically look for input items, which are represented as ContentItem::InputText.
-                if content
-                    .iter()
-                    .any(|c| matches!(c, ContentItem::InputText { .. }))
-                {
-                    pos.push(i);
-                }
-            }
-        }
-        pos
-    };
-    let user_inputs = find_user_input_positions(&base_items);
+    // Fork 1: drops the last user message and everything after.
+    let expected_after_first = vec![
+        entries_after_three[0].clone(),
+        entries_after_three[1].clone(),
+        entries_after_three[2].clone(),
+        entries_after_three[3].clone(),
+    ];
 
-    // After dropping last user input (n=1), cut strictly before that input if present, else empty.
-    let cut1 = user_inputs
-        .get(user_inputs.len().saturating_sub(1))
-        .copied()
-        .unwrap_or(0);
-    let expected_after_first: Vec<RolloutItem> = base_items[..cut1].to_vec();
+    // Fork 2: drops the last user message and everything after.
+    // [0] user instructions,
+    // [1] environment context,
+    // [2] "first" user message,
+    let expected_after_second = vec![
+        entries_after_three[0].clone(),
+        entries_after_three[1].clone(),
+        entries_after_three[2].clone(),
+    ];
 
-    // After dropping again (n=1 on fork1), compute expected relative to fork1's rollout.
-
-    // Fork once with n=1 → drops the last user input and everything after.
+    // Fork once with n=1 → drops the last user message and everything after.
     let NewConversation {
         conversation: codex_fork1,
         ..
     } = conversation_manager
-        .fork_conversation(1, config_for_fork.clone(), base_path.clone())
+        .fork_conversation(base_path.clone(), base_conv_id, 1, config_for_fork.clone())
         .await
         .expect("fork 1");
 
-    codex_fork1.submit(Op::GetPath).await.unwrap();
+    codex_fork1.submit(Op::GetConversationPath).await.unwrap();
     let fork1_history = wait_for_event(&codex_fork1, |ev| {
-        matches!(ev, EventMsg::ConversationPath(_))
+        matches!(ev, EventMsg::ConversationHistory(_))
     })
     .await;
-    let fork1_path = match &fork1_history {
-        EventMsg::ConversationPath(ConversationPathResponseEvent { path, .. }) => path.clone(),
+    let (fork1_id, fork1_path) = match &fork1_history {
+        EventMsg::ConversationHistory(ConversationPathResponseEvent {
+            conversation_id,
+            path,
+        }) => (*conversation_id, path.clone()),
         _ => panic!("expected ConversationHistory event after first fork"),
     };
-
-    // GetHistory on fork1 flushed; the file is ready.
-    let fork1_items = read_items(&fork1_path);
-    pretty_assertions::assert_eq!(
-        serde_json::to_value(&fork1_items).unwrap(),
-        serde_json::to_value(&expected_after_first).unwrap()
-    );
+    let entries_after_first_fork: Vec<ResponseItem> = read_response_entries(&fork1_path).await;
+    assert_eq!(entries_after_first_fork, expected_after_first);
 
     // Fork again with n=1 → drops the (new) last user message, leaving only the first.
     let NewConversation {
         conversation: codex_fork2,
         ..
     } = conversation_manager
-        .fork_conversation(1, config_for_fork.clone(), fork1_path.clone())
+        .fork_conversation(fork1_path.clone(), fork1_id, 1, config_for_fork.clone())
         .await
         .expect("fork 2");
 
-    codex_fork2.submit(Op::GetPath).await.unwrap();
+    codex_fork2.submit(Op::GetConversationPath).await.unwrap();
     let fork2_history = wait_for_event(&codex_fork2, |ev| {
-        matches!(ev, EventMsg::ConversationPath(_))
+        matches!(ev, EventMsg::ConversationHistory(_))
     })
     .await;
-    let fork2_path = match &fork2_history {
-        EventMsg::ConversationPath(ConversationPathResponseEvent { path, .. }) => path.clone(),
+    let (_fork2_id, fork2_path) = match &fork2_history {
+        EventMsg::ConversationHistory(ConversationPathResponseEvent {
+            conversation_id,
+            path,
+        }) => (*conversation_id, path.clone()),
         _ => panic!("expected ConversationHistory event after second fork"),
     };
-    // GetHistory on fork2 flushed; the file is ready.
-    let fork1_items = read_items(&fork1_path);
-    let fork1_user_inputs = find_user_input_positions(&fork1_items);
-    let cut_last_on_fork1 = fork1_user_inputs
-        .get(fork1_user_inputs.len().saturating_sub(1))
-        .copied()
-        .unwrap_or(0);
-    let expected_after_second: Vec<RolloutItem> = fork1_items[..cut_last_on_fork1].to_vec();
-    let fork2_items = read_items(&fork2_path);
-    pretty_assertions::assert_eq!(
-        serde_json::to_value(&fork2_items).unwrap(),
-        serde_json::to_value(&expected_after_second).unwrap()
-    );
+    let entries_after_second_fork: Vec<ResponseItem> = read_response_entries(&fork2_path).await;
+    assert_eq!(entries_after_second_fork, expected_after_second);
 }

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

@@ -426,17 +426,11 @@ async fn overrides_turn_context_but_keeps_cached_prefix_and_key_constant() {
     // After overriding the turn context, the environment context should be emitted again
     // reflecting the new approval policy and sandbox settings. Omit cwd because it did
     // not change.
-    let expected_env_text_2 = format!(
-        r#"<environment_context>
+    let expected_env_text_2 = r#"<environment_context>
   <approval_policy>never</approval_policy>
   <sandbox_mode>workspace-write</sandbox_mode>
   <network_access>enabled</network_access>
-  <writable_roots>
-    <root>{}</root>
-  </writable_roots>
-</environment_context>"#,
-        writable.path().to_string_lossy()
-    );
+</environment_context>"#;
     let expected_env_msg_2 = serde_json::json!({
         "type": "message",
         "role": "user",

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

@@ -159,41 +159,6 @@ async fn read_only_forbids_all_writes() {
         .await;
 }
 
-/// Verify that user lookups via `pwd.getpwuid(os.getuid())` work under the
-/// seatbelt sandbox. Prior to allowing the necessary mach‑lookup for
-/// OpenDirectory libinfo, this would fail with `KeyError: getpwuid(): uid not found`.
-#[tokio::test]
-async fn python_getpwuid_works_under_seatbelt() {
-    if std::env::var(CODEX_SANDBOX_ENV_VAR) == Ok("seatbelt".to_string()) {
-        eprintln!("{CODEX_SANDBOX_ENV_VAR} is set to 'seatbelt', skipping test.");
-        return;
-    }
-
-    // ReadOnly is sufficient here since we are only exercising user lookup.
-    let policy = SandboxPolicy::ReadOnly;
-
-    let mut child = spawn_command_under_seatbelt(
-        vec![
-            "python3".to_string(),
-            "-c".to_string(),
-            // Print the passwd struct; success implies lookup worked.
-            "import pwd, os; print(pwd.getpwuid(os.getuid()))".to_string(),
-        ],
-        &policy,
-        std::env::current_dir().expect("should be able to get current dir"),
-        StdioPolicy::RedirectForShellTool,
-        HashMap::new(),
-    )
-    .await
-    .expect("should be able to spawn python under seatbelt");
-
-    let status = child
-        .wait()
-        .await
-        .expect("should be able to wait for child process");
-    assert!(status.success(), "python exited with {status:?}");
-}
-
 #[expect(clippy::expect_used)]
 fn create_test_scenario(tmp: &TempDir) -> TestScenario {
     let repo_parent = tmp.path().to_path_buf();

codex-rs/exec/Cargo.toml

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

codex-rs/exec/src/event_processor_with_human_output.rs

@@ -280,7 +280,7 @@ impl EventProcessor for EventProcessorWithHumanOutput {
                 parsed_cmd: _,
             }) => {
                 self.call_id_to_command.insert(
-                    call_id,
+                    call_id.clone(),
                     ExecCommandBegin {
                         command: command.clone(),
                     },
@@ -382,7 +382,7 @@ impl EventProcessor for EventProcessorWithHumanOutput {
                 // Store metadata so we can calculate duration later when we
                 // receive the corresponding PatchApplyEnd event.
                 self.call_id_to_patch.insert(
-                    call_id,
+                    call_id.clone(),
                     PatchApplyBegin {
                         start_time: Instant::now(),
                         auto_approved,
@@ -523,7 +523,6 @@ impl EventProcessor for EventProcessorWithHumanOutput {
                     history_log_id: _,
                     history_entry_count: _,
                     initial_messages: _,
-                    rollout_path: _,
                 } = session_configured_event;
 
                 ts_println!(
@@ -559,7 +558,7 @@ impl EventProcessor for EventProcessorWithHumanOutput {
                 }
             },
             EventMsg::ShutdownComplete => return CodexStatus::Shutdown,
-            EventMsg::ConversationPath(_) => {}
+            EventMsg::ConversationHistory(_) => {}
             EventMsg::UserMessage(_) => {}
         }
         CodexStatus::Running

codex-rs/exec/src/lib.rs

@@ -187,8 +187,11 @@ pub async fn run_main(cli: Cli, codex_linux_sandbox_exe: Option<PathBuf>) -> any
         std::process::exit(1);
     }
 
-    let conversation_manager =
-        ConversationManager::new(AuthManager::shared(config.codex_home.clone()));
+    let conversation_manager = ConversationManager::new(AuthManager::shared(
+        config.codex_home.clone(),
+        config.preferred_auth_method,
+        config.responses_originator_header.clone(),
+    ));
     let NewConversation {
         conversation_id: _,
         conversation,

codex-rs/exec/tests/suite/common.rs

@@ -61,7 +61,7 @@ pub(crate) async fn run_e2e_exec_test(cwd: &Path, response_streams: Vec<String>)
         .context("should find binary for codex-exec")
         .expect("should find binary for codex-exec")
         .current_dir(cwd.clone())
-        .env("CODEX_HOME", cwd)
+        .env("CODEX_HOME", cwd.clone())
         .env("OPENAI_API_KEY", "dummy")
         .env("OPENAI_BASE_URL", format!("{uri}/v1"))
         .arg("--skip-git-repo-check")

codex-rs/execpolicy/src/execv_checker.rs

@@ -88,7 +88,7 @@ impl ExecvChecker {
         let mut program = valid_exec.program.to_string();
         for system_path in valid_exec.system_path {
             if is_executable_file(&system_path) {
-                program = system_path;
+                program = system_path.to_string();
                 break;
             }
         }
@@ -196,7 +196,7 @@ system_path=[{fake_cp:?}]
         let checker = setup(&fake_cp);
         let exec_call = ExecCall {
             program: "cp".into(),
-            args: vec![source, dest.clone()],
+            args: vec![source.clone(), dest.clone()],
         };
         let valid_exec = match checker.r#match(&exec_call)? {
             MatchedExec::Match { exec } => exec,
@@ -207,7 +207,7 @@ system_path=[{fake_cp:?}]
         assert_eq!(
             checker.check(valid_exec.clone(), &cwd, &[], &[]),
             Err(ReadablePathNotInReadableFolders {
-                file: source_path,
+                file: source_path.clone(),
                 folders: vec![]
             }),
         );
@@ -229,7 +229,7 @@ system_path=[{fake_cp:?}]
         // Both readable and writeable folders specified.
         assert_eq!(
             checker.check(
-                valid_exec,
+                valid_exec.clone(),
                 &cwd,
                 std::slice::from_ref(&root_path),
                 std::slice::from_ref(&root_path)
@@ -241,7 +241,7 @@ system_path=[{fake_cp:?}]
         // folders.
         let exec_call_folders_as_args = ExecCall {
             program: "cp".into(),
-            args: vec![root.clone(), root],
+            args: vec![root.clone(), root.clone()],
         };
         let valid_exec_call_folders_as_args = match checker.r#match(&exec_call_folders_as_args)? {
             MatchedExec::Match { exec } => exec,
@@ -254,7 +254,7 @@ system_path=[{fake_cp:?}]
                 std::slice::from_ref(&root_path),
                 std::slice::from_ref(&root_path)
             ),
-            Ok(cp),
+            Ok(cp.clone()),
         );
 
         // Specify a parent of a readable folder as input.

codex-rs/execpolicy/src/policy_parser.rs

@@ -104,7 +104,7 @@ impl PolicyBuilder {
         info!("adding program spec: {program_spec:?}");
         let name = program_spec.program.clone();
         let mut programs = self.programs.borrow_mut();
-        programs.insert(name, program_spec);
+        programs.insert(name.clone(), program_spec);
     }
 
     fn add_forbidden_substrings(&self, substrings: &[String]) {

codex-rs/linux-sandbox/Cargo.toml

@@ -15,7 +15,9 @@ path = "src/lib.rs"
 workspace = true
 
 [target.'cfg(target_os = "linux")'.dependencies]
+anyhow = "1"
 clap = { version = "4", features = ["derive"] }
+codex-common = { path = "../common", features = ["cli"] }
 codex-core = { path = "../core" }
 landlock = "0.4.1"
 libc = "0.2.175"

codex-rs/login/Cargo.toml

@@ -17,6 +17,7 @@ serde = { version = "1", features = ["derive"] }
 serde_json = "1"
 sha2 = "0.10"
 tempfile = "3"
+thiserror = "2.0.16"
 tiny_http = "0.12"
 tokio = { version = "1", features = [
     "io-std",
@@ -30,4 +31,5 @@ urlencoding = "2.1"
 webbrowser = "1.0"
 
 [dev-dependencies]
+pretty_assertions = "1.4.1"
 tempfile = "3"

codex-rs/login/src/server.rs

@@ -16,7 +16,6 @@ use base64::Engine;
 use chrono::Utc;
 use codex_core::auth::AuthDotJson;
 use codex_core::auth::get_auth_file;
-use codex_core::default_client::ORIGINATOR;
 use codex_core::token_data::TokenData;
 use codex_core::token_data::parse_id_token;
 use rand::RngCore;
@@ -36,17 +35,19 @@ pub struct ServerOptions {
     pub port: u16,
     pub open_browser: bool,
     pub force_state: Option<String>,
+    pub originator: String,
 }
 
 impl ServerOptions {
-    pub fn new(codex_home: PathBuf, client_id: String) -> Self {
+    pub fn new(codex_home: PathBuf, client_id: String, originator: String) -> Self {
         Self {
             codex_home,
-            client_id,
+            client_id: client_id.to_string(),
             issuer: DEFAULT_ISSUER.to_string(),
             port: DEFAULT_PORT,
             open_browser: true,
             force_state: None,
+            originator,
         }
     }
 }
@@ -102,7 +103,14 @@ pub fn run_login_server(opts: ServerOptions) -> io::Result<LoginServer> {
     let server = Arc::new(server);
 
     let redirect_uri = format!("http://localhost:{actual_port}/auth/callback");
-    let auth_url = build_authorize_url(&opts.issuer, &opts.client_id, &redirect_uri, &pkce, &state);
+    let auth_url = build_authorize_url(
+        &opts.issuer,
+        &opts.client_id,
+        &redirect_uri,
+        &pkce,
+        &state,
+        &opts.originator,
+    );
 
     if opts.open_browser {
         let _ = webbrowser::open(&auth_url);
@@ -126,7 +134,7 @@ pub fn run_login_server(opts: ServerOptions) -> io::Result<LoginServer> {
     let shutdown_notify = Arc::new(tokio::sync::Notify::new());
     let server_handle = {
         let shutdown_notify = shutdown_notify.clone();
-        let server = server;
+        let server = server.clone();
         tokio::spawn(async move {
             let result = loop {
                 tokio::select! {
@@ -303,6 +311,7 @@ fn build_authorize_url(
     redirect_uri: &str,
     pkce: &PkceCodes,
     state: &str,
+    originator: &str,
 ) -> String {
     let query = vec![
         ("response_type", "code"),
@@ -314,7 +323,7 @@ fn build_authorize_url(
         ("id_token_add_organizations", "true"),
         ("codex_cli_simplified_flow", "true"),
         ("state", state),
-        ("originator", ORIGINATOR.value.as_str()),
+        ("originator", originator),
     ];
     let qs = query
         .into_iter()

codex-rs/login/tests/suite/login_server_e2e.rs

@@ -102,6 +102,7 @@ async fn end_to_end_login_flow_persists_auth_json() {
         port: 0,
         open_browser: false,
         force_state: Some(state),
+        originator: "test_originator".to_string(),
     };
     let server = run_login_server(opts).unwrap();
     let login_port = server.actual_port;
@@ -160,6 +161,7 @@ async fn creates_missing_codex_home_dir() {
         port: 0,
         open_browser: false,
         force_state: Some(state),
+        originator: "test_originator".to_string(),
     };
     let server = run_login_server(opts).unwrap();
     let login_port = server.actual_port;
@@ -200,6 +202,7 @@ async fn cancels_previous_login_server_when_port_is_in_use() {
         port: 0,
         open_browser: false,
         force_state: Some("cancel_state".to_string()),
+        originator: "test_originator".to_string(),
     };
 
     let first_server = run_login_server(first_opts).unwrap();
@@ -218,6 +221,7 @@ async fn cancels_previous_login_server_when_port_is_in_use() {
         port: login_port,
         open_browser: false,
         force_state: Some("cancel_state_2".to_string()),
+        originator: "test_originator".to_string(),
     };
 
     let second_server = run_login_server(second_opts).unwrap();

codex-rs/mcp-client/src/main.rs

@@ -64,9 +64,6 @@ async fn main() -> Result<()> {
             name: "codex-mcp-client".to_owned(),
             version: env!("CARGO_PKG_VERSION").to_owned(),
             title: Some("Codex".to_string()),
-            // This field is used by Codex when it is an MCP server: it should
-            // not be used when Codex is an MCP client.
-            user_agent: None,
         },
         protocol_version: MCP_SCHEMA_VERSION.to_owned(),
     };

codex-rs/mcp-server/Cargo.toml

@@ -26,6 +26,7 @@ schemars = "0.8.22"
 serde = { version = "1", features = ["derive"] }
 serde_json = "1"
 shlex = "1.3.0"
+strum_macros = "0.27.2"
 tokio = { version = "1", features = [
     "io-std",
     "macros",
@@ -40,9 +41,8 @@ uuid = { version = "1", features = ["serde", "v4"] }
 
 [dev-dependencies]
 assert_cmd = "2"
-base64 = "0.22"
 mcp_test_support = { path = "tests/common" }
-os_info = "3.12.0"
 pretty_assertions = "1.4.1"
 tempfile = "3"
+tokio-test = "0.4"
 wiremock = "0.6"

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

@@ -11,9 +11,6 @@ use codex_core::NewConversation;
 use codex_core::RolloutRecorder;
 use codex_core::SessionMeta;
 use codex_core::auth::CLIENT_ID;
-use codex_core::auth::get_auth_file;
-use codex_core::auth::login_with_api_key;
-use codex_core::auth::try_read_auth_json;
 use codex_core::config::Config;
 use codex_core::config::ConfigOverrides;
 use codex_core::config::ConfigToml;
@@ -38,8 +35,7 @@ use codex_protocol::mcp_protocol::AddConversationListenerParams;
 use codex_protocol::mcp_protocol::AddConversationSubscriptionResponse;
 use codex_protocol::mcp_protocol::ApplyPatchApprovalParams;
 use codex_protocol::mcp_protocol::ApplyPatchApprovalResponse;
-use codex_protocol::mcp_protocol::ArchiveConversationParams;
-use codex_protocol::mcp_protocol::ArchiveConversationResponse;
+use codex_protocol::mcp_protocol::AuthMode;
 use codex_protocol::mcp_protocol::AuthStatusChangeNotification;
 use codex_protocol::mcp_protocol::ClientRequest;
 use codex_protocol::mcp_protocol::ConversationId;
@@ -57,8 +53,6 @@ use codex_protocol::mcp_protocol::InterruptConversationParams;
 use codex_protocol::mcp_protocol::InterruptConversationResponse;
 use codex_protocol::mcp_protocol::ListConversationsParams;
 use codex_protocol::mcp_protocol::ListConversationsResponse;
-use codex_protocol::mcp_protocol::LoginApiKeyParams;
-use codex_protocol::mcp_protocol::LoginApiKeyResponse;
 use codex_protocol::mcp_protocol::LoginChatGptCompleteNotification;
 use codex_protocol::mcp_protocol::LoginChatGptResponse;
 use codex_protocol::mcp_protocol::NewConversationParams;
@@ -71,7 +65,6 @@ use codex_protocol::mcp_protocol::SendUserMessageResponse;
 use codex_protocol::mcp_protocol::SendUserTurnParams;
 use codex_protocol::mcp_protocol::SendUserTurnResponse;
 use codex_protocol::mcp_protocol::ServerNotification;
-use codex_protocol::mcp_protocol::UserInfoResponse;
 use codex_protocol::mcp_protocol::UserSavedConfig;
 use codex_protocol::models::ContentItem;
 use codex_protocol::models::ResponseItem;
@@ -80,16 +73,12 @@ use codex_protocol::protocol::USER_MESSAGE_BEGIN;
 use mcp_types::JSONRPCErrorError;
 use mcp_types::RequestId;
 use std::collections::HashMap;
-use std::ffi::OsStr;
 use std::path::PathBuf;
 use std::sync::Arc;
 use std::time::Duration;
-use tokio::select;
 use tokio::sync::Mutex;
 use tokio::sync::oneshot;
 use tracing::error;
-use tracing::info;
-use tracing::warn;
 use uuid::Uuid;
 
 // Duration before a ChatGPT login attempt is abandoned.
@@ -153,9 +142,6 @@ impl CodexMessageProcessor {
             ClientRequest::ResumeConversation { request_id, params } => {
                 self.handle_resume_conversation(request_id, params).await;
             }
-            ClientRequest::ArchiveConversation { request_id, params } => {
-                self.archive_conversation(request_id, params).await;
-            }
             ClientRequest::SendUserMessage { request_id, params } => {
                 self.send_user_message(request_id, params).await;
             }
@@ -174,9 +160,6 @@ impl CodexMessageProcessor {
             ClientRequest::GitDiffToRemote { request_id, params } => {
                 self.git_diff_to_origin(request_id, params.cwd).await;
             }
-            ClientRequest::LoginApiKey { request_id, params } => {
-                self.login_api_key(request_id, params).await;
-            }
             ClientRequest::LoginChatGpt { request_id } => {
                 self.login_chatgpt(request_id).await;
             }
@@ -195,54 +178,22 @@ impl CodexMessageProcessor {
             ClientRequest::GetUserAgent { request_id } => {
                 self.get_user_agent(request_id).await;
             }
-            ClientRequest::UserInfo { request_id } => {
-                self.get_user_info(request_id).await;
-            }
             ClientRequest::ExecOneOffCommand { request_id, params } => {
                 self.exec_one_off_command(request_id, params).await;
             }
         }
     }
 
-    async fn login_api_key(&mut self, request_id: RequestId, params: LoginApiKeyParams) {
-        {
-            let mut guard = self.active_login.lock().await;
-            if let Some(active) = guard.take() {
-                active.drop();
-            }
-        }
-
-        match login_with_api_key(&self.config.codex_home, &params.api_key) {
-            Ok(()) => {
-                self.auth_manager.reload();
-                self.outgoing
-                    .send_response(request_id, LoginApiKeyResponse {})
-                    .await;
-
-                let payload = AuthStatusChangeNotification {
-                    auth_method: self.auth_manager.auth().map(|auth| auth.mode),
-                };
-                self.outgoing
-                    .send_server_notification(ServerNotification::AuthStatusChange(payload))
-                    .await;
-            }
-            Err(err) => {
-                let error = JSONRPCErrorError {
-                    code: INTERNAL_ERROR_CODE,
-                    message: format!("failed to save api key: {err}"),
-                    data: None,
-                };
-                self.outgoing.send_error(request_id, error).await;
-            }
-        }
-    }
-
     async fn login_chatgpt(&mut self, request_id: RequestId) {
         let config = self.config.as_ref();
 
         let opts = LoginServerOptions {
             open_browser: false,
-            ..LoginServerOptions::new(config.codex_home.clone(), CLIENT_ID.to_string())
+            ..LoginServerOptions::new(
+                config.codex_home.clone(),
+                CLIENT_ID.to_string(),
+                config.responses_originator_header.clone(),
+            )
         };
 
         enum LoginChatGptReply {
@@ -390,7 +341,7 @@ impl CodexMessageProcessor {
             .await;
 
         // Send auth status change notification reflecting the current auth mode
-        // after logout.
+        // after logout (which may fall back to API key via env var).
         let current_auth_method = self.auth_manager.auth().map(|auth| auth.mode);
         let payload = AuthStatusChangeNotification {
             auth_method: current_auth_method,
@@ -405,6 +356,7 @@ impl CodexMessageProcessor {
         request_id: RequestId,
         params: codex_protocol::mcp_protocol::GetAuthStatusParams,
     ) {
+        let preferred_auth_method: AuthMode = self.auth_manager.preferred_auth_method();
         let include_token = params.include_token.unwrap_or(false);
         let do_refresh = params.refresh_token.unwrap_or(false);
 
@@ -412,11 +364,6 @@ impl CodexMessageProcessor {
             tracing::warn!("failed to refresh token while getting auth status: {err}");
         }
 
-        // Determine whether auth is required based on the active model provider.
-        // If a custom provider is configured with `requires_openai_auth == false`,
-        // then no auth step is required; otherwise, default to requiring auth.
-        let requires_openai_auth = Some(self.config.model_provider.requires_openai_auth);
-
         let response = match self.auth_manager.auth() {
             Some(auth) => {
                 let (reported_auth_method, token_opt) = match auth.get_token().await {
@@ -432,14 +379,14 @@ impl CodexMessageProcessor {
                 };
                 codex_protocol::mcp_protocol::GetAuthStatusResponse {
                     auth_method: reported_auth_method,
+                    preferred_auth_method,
                     auth_token: token_opt,
-                    requires_openai_auth,
                 }
             }
             None => codex_protocol::mcp_protocol::GetAuthStatusResponse {
                 auth_method: None,
+                preferred_auth_method,
                 auth_token: None,
-                requires_openai_auth,
             },
         };
 
@@ -447,7 +394,7 @@ impl CodexMessageProcessor {
     }
 
     async fn get_user_agent(&self, request_id: RequestId) {
-        let user_agent = get_codex_user_agent();
+        let user_agent = get_codex_user_agent(Some(&self.config.responses_originator_header));
         let response = GetUserAgentResponse { user_agent };
         self.outgoing.send_response(request_id, response).await;
     }
@@ -487,18 +434,6 @@ impl CodexMessageProcessor {
         self.outgoing.send_response(request_id, response).await;
     }
 
-    async fn get_user_info(&self, request_id: RequestId) {
-        // Read alleged user email from auth.json (best-effort; not verified).
-        let auth_path = get_auth_file(&self.config.codex_home);
-        let alleged_user_email = match try_read_auth_json(&auth_path) {
-            Ok(auth) => auth.tokens.and_then(|t| t.id_token.email),
-            Err(_) => None,
-        };
-
-        let response = UserInfoResponse { alleged_user_email };
-        self.outgoing.send_response(request_id, response).await;
-    }
-
     async fn exec_one_off_command(&self, request_id: RequestId, params: ExecOneOffCommandParams) {
         tracing::debug!("ExecOneOffCommand params: {params:?}");
 
@@ -593,7 +528,6 @@ impl CodexMessageProcessor {
                 let response = NewConversationResponse {
                     conversation_id,
                     model: session_configured.model,
-                    rollout_path: session_configured.rollout_path,
                 };
                 self.outgoing.send_response(request_id, response).await;
             }
@@ -735,141 +669,6 @@ impl CodexMessageProcessor {
         }
     }
 
-    async fn archive_conversation(&self, request_id: RequestId, params: ArchiveConversationParams) {
-        let ArchiveConversationParams {
-            conversation_id,
-            rollout_path,
-        } = params;
-
-        // Verify that the rollout path is in the sessions directory or else
-        // a malicious client could specify an arbitrary path.
-        let rollout_folder = self.config.codex_home.join(codex_core::SESSIONS_SUBDIR);
-        let canonical_rollout_path = tokio::fs::canonicalize(&rollout_path).await;
-        let canonical_rollout_path = if let Ok(path) = canonical_rollout_path
-            && path.starts_with(&rollout_folder)
-        {
-            path
-        } else {
-            let error = JSONRPCErrorError {
-                code: INVALID_REQUEST_ERROR_CODE,
-                message: format!(
-                    "rollout path `{}` must be in sessions directory",
-                    rollout_path.display()
-                ),
-                data: None,
-            };
-            self.outgoing.send_error(request_id, error).await;
-            return;
-        };
-
-        let required_suffix = format!("{}.jsonl", conversation_id.0);
-        let Some(file_name) = canonical_rollout_path.file_name().map(OsStr::to_owned) else {
-            let error = JSONRPCErrorError {
-                code: INVALID_REQUEST_ERROR_CODE,
-                message: format!(
-                    "rollout path `{}` missing file name",
-                    rollout_path.display()
-                ),
-                data: None,
-            };
-            self.outgoing.send_error(request_id, error).await;
-            return;
-        };
-
-        if !file_name
-            .to_string_lossy()
-            .ends_with(required_suffix.as_str())
-        {
-            let error = JSONRPCErrorError {
-                code: INVALID_REQUEST_ERROR_CODE,
-                message: format!(
-                    "rollout path `{}` does not match conversation id {conversation_id}",
-                    rollout_path.display()
-                ),
-                data: None,
-            };
-            self.outgoing.send_error(request_id, error).await;
-            return;
-        }
-
-        let removed_conversation = self
-            .conversation_manager
-            .remove_conversation(&conversation_id)
-            .await;
-        if let Some(conversation) = removed_conversation {
-            info!("conversation {conversation_id} was active; shutting down");
-            let conversation_clone = conversation.clone();
-            let notify = Arc::new(tokio::sync::Notify::new());
-            let notify_clone = notify.clone();
-
-            // Establish the listener for ShutdownComplete before submitting
-            // Shutdown so it is not missed.
-            let is_shutdown = tokio::spawn(async move {
-                loop {
-                    select! {
-                        _ = notify_clone.notified() => {
-                            break;
-                        }
-                        event = conversation_clone.next_event() => {
-                            if let Ok(event) = event && matches!(event.msg, EventMsg::ShutdownComplete) {
-                                break;
-                            }
-                        }
-                    }
-                }
-            });
-
-            // Request shutdown.
-            match conversation.submit(Op::Shutdown).await {
-                Ok(_) => {
-                    // Successfully submitted Shutdown; wait before proceeding.
-                    select! {
-                        _ = is_shutdown => {
-                            // Normal shutdown: proceed with archive.
-                        }
-                        _ = tokio::time::sleep(Duration::from_secs(10)) => {
-                            warn!("conversation {conversation_id} shutdown timed out; proceeding with archive");
-                            notify.notify_one();
-                        }
-                    }
-                }
-                Err(err) => {
-                    error!("failed to submit Shutdown to conversation {conversation_id}: {err}");
-                    notify.notify_one();
-                    // Perhaps we lost a shutdown race, so let's continue to
-                    // clean up the .jsonl file.
-                }
-            }
-        }
-
-        // Move the .jsonl file to the archived sessions subdir.
-        let result: std::io::Result<()> = async {
-            let archive_folder = self
-                .config
-                .codex_home
-                .join(codex_core::ARCHIVED_SESSIONS_SUBDIR);
-            tokio::fs::create_dir_all(&archive_folder).await?;
-            tokio::fs::rename(&canonical_rollout_path, &archive_folder.join(&file_name)).await?;
-            Ok(())
-        }
-        .await;
-
-        match result {
-            Ok(()) => {
-                let response = ArchiveConversationResponse {};
-                self.outgoing.send_response(request_id, response).await;
-            }
-            Err(err) => {
-                let error = JSONRPCErrorError {
-                    code: INTERNAL_ERROR_CODE,
-                    message: format!("failed to archive conversation: {err}"),
-                    data: None,
-                };
-                self.outgoing.send_error(request_id, error).await;
-            }
-        }
-    }
-
     async fn send_user_message(&self, request_id: RequestId, params: SendUserMessageParams) {
         let SendUserMessageParams {
             conversation_id,
@@ -1311,7 +1110,10 @@ fn extract_conversation_summary(
     head: &[serde_json::Value],
 ) -> Option<ConversationSummary> {
     let session_meta = match head.first() {
-        Some(first_line) => serde_json::from_value::<SessionMeta>(first_line.clone()).ok()?,
+        Some(first_line) => match serde_json::from_value::<SessionMeta>(first_line.clone()) {
+            Ok(session_meta) => session_meta,
+            Err(..) => return None,
+        },
         None => return None,
     };
 
@@ -1369,10 +1171,6 @@ mod tests {
             json!({
                 "id": conversation_id.0,
                 "timestamp": timestamp,
-                "cwd": "/",
-                "originator": "codex",
-                "cli_version": "0.0.0",
-                "instructions": null
             }),
             json!({
                 "type": "message",

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

@@ -222,7 +222,7 @@ async fn run_codex_tool_session_inner(
                     }
                     EventMsg::TaskComplete(TaskCompleteEvent { last_agent_message }) => {
                         let text = match last_agent_message {
-                            Some(msg) => msg,
+                            Some(msg) => msg.clone(),
                             None => "".to_string(),
                         };
                         let result = CallToolResult {
@@ -277,7 +277,7 @@ async fn run_codex_tool_session_inner(
                     | EventMsg::GetHistoryEntryResponse(_)
                     | EventMsg::PlanUpdate(_)
                     | EventMsg::TurnAborted(_)
-                    | EventMsg::ConversationPath(_)
+                    | EventMsg::ConversationHistory(_)
                     | EventMsg::UserMessage(_)
                     | EventMsg::ShutdownComplete => {
                         // For now, we do not do anything extra for these

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

@@ -14,8 +14,6 @@ use codex_protocol::mcp_protocol::ConversationId;
 use codex_core::AuthManager;
 use codex_core::ConversationManager;
 use codex_core::config::Config;
-use codex_core::default_client::USER_AGENT_SUFFIX;
-use codex_core::default_client::get_codex_user_agent;
 use codex_core::protocol::Submission;
 use mcp_types::CallToolRequestParams;
 use mcp_types::CallToolResult;
@@ -56,7 +54,11 @@ impl MessageProcessor {
         config: Arc<Config>,
     ) -> Self {
         let outgoing = Arc::new(outgoing);
-        let auth_manager = AuthManager::shared(config.codex_home.clone());
+        let auth_manager = AuthManager::shared(
+            config.codex_home.clone(),
+            config.preferred_auth_method,
+            config.responses_originator_header.clone(),
+        );
         let conversation_manager = Arc::new(ConversationManager::new(auth_manager.clone()));
         let codex_message_processor = CodexMessageProcessor::new(
             auth_manager,
@@ -209,14 +211,6 @@ impl MessageProcessor {
             return;
         }
 
-        let client_info = params.client_info;
-        let name = client_info.name;
-        let version = client_info.version;
-        let user_agent_suffix = format!("{name}; {version}");
-        if let Ok(mut suffix) = USER_AGENT_SUFFIX.lock() {
-            *suffix = Some(user_agent_suffix);
-        }
-
         self.initialized = true;
 
         // Build a minimal InitializeResult. Fill with placeholders.
@@ -237,7 +231,6 @@ impl MessageProcessor {
                 name: "codex-mcp-server".to_string(),
                 version: env!("CARGO_PKG_VERSION").to_string(),
                 title: Some("Codex".to_string()),
-                user_agent: Some(get_codex_user_agent()),
             },
         };
 
@@ -531,6 +524,7 @@ impl MessageProcessor {
 
         // Spawn the long-running reply handler.
         tokio::spawn({
+            let codex = codex.clone();
             let outgoing = outgoing.clone();
             let prompt = prompt.clone();
             let running_requests_id_to_codex_uuid = running_requests_id_to_codex_uuid.clone();

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

@@ -262,7 +262,6 @@ mod tests {
     use codex_protocol::mcp_protocol::LoginChatGptCompleteNotification;
     use pretty_assertions::assert_eq;
     use serde_json::json;
-    use tempfile::NamedTempFile;
     use uuid::Uuid;
 
     use super::*;
@@ -273,7 +272,6 @@ mod tests {
         let outgoing_message_sender = OutgoingMessageSender::new(outgoing_tx);
 
         let conversation_id = ConversationId::new();
-        let rollout_file = NamedTempFile::new().unwrap();
         let event = Event {
             id: "1".to_string(),
             msg: EventMsg::SessionConfigured(SessionConfiguredEvent {
@@ -282,7 +280,6 @@ mod tests {
                 history_log_id: 1,
                 history_entry_count: 1000,
                 initial_messages: None,
-                rollout_path: rollout_file.path().to_path_buf(),
             }),
         };
 
@@ -299,7 +296,7 @@ mod tests {
         let Ok(expected_params) = serde_json::to_value(&event) else {
             panic!("Event must serialize");
         };
-        assert_eq!(params, Some(expected_params));
+        assert_eq!(params, Some(expected_params.clone()));
     }
 
     #[tokio::test]
@@ -308,14 +305,12 @@ mod tests {
         let outgoing_message_sender = OutgoingMessageSender::new(outgoing_tx);
 
         let conversation_id = ConversationId::new();
-        let rollout_file = NamedTempFile::new().unwrap();
         let session_configured_event = SessionConfiguredEvent {
             session_id: conversation_id,
             model: "gpt-4o".to_string(),
             history_log_id: 1,
             history_entry_count: 1000,
             initial_messages: None,
-            rollout_path: rollout_file.path().to_path_buf(),
         };
         let event = Event {
             id: "1".to_string(),
@@ -345,7 +340,6 @@ mod tests {
                 "history_log_id": session_configured_event.history_log_id,
                 "history_entry_count": session_configured_event.history_entry_count,
                 "type": "session_configured",
-                "rollout_path": rollout_file.path().to_path_buf(),
             }
         });
         assert_eq!(params.unwrap(), expected_params);

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

@@ -13,14 +13,16 @@ codex-core = { path = "../../../core" }
 codex-mcp-server = { path = "../.." }
 codex-protocol = { path = "../../../protocol" }
 mcp-types = { path = "../../../mcp-types" }
-os_info = "3.12.0"
 pretty_assertions = "1.4.1"
 serde = { version = "1" }
 serde_json = "1"
+shlex = "1.3.0"
+tempfile = "3"
 tokio = { version = "1", features = [
     "io-std",
     "macros",
     "process",
     "rt-multi-thread",
 ] }
+uuid = { version = "1", features = ["serde", "v4"] }
 wiremock = "0.6"

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

@@ -13,12 +13,10 @@ use anyhow::Context;
 use assert_cmd::prelude::*;
 use codex_mcp_server::CodexToolCallParam;
 use codex_protocol::mcp_protocol::AddConversationListenerParams;
-use codex_protocol::mcp_protocol::ArchiveConversationParams;
 use codex_protocol::mcp_protocol::CancelLoginChatGptParams;
 use codex_protocol::mcp_protocol::GetAuthStatusParams;
 use codex_protocol::mcp_protocol::InterruptConversationParams;
 use codex_protocol::mcp_protocol::ListConversationsParams;
-use codex_protocol::mcp_protocol::LoginApiKeyParams;
 use codex_protocol::mcp_protocol::NewConversationParams;
 use codex_protocol::mcp_protocol::RemoveConversationListenerParams;
 use codex_protocol::mcp_protocol::ResumeConversationParams;
@@ -55,18 +53,6 @@ pub struct McpProcess {
 
 impl McpProcess {
     pub async fn new(codex_home: &Path) -> anyhow::Result<Self> {
-        Self::new_with_env(codex_home, &[]).await
-    }
-
-    /// Creates a new MCP process, allowing tests to override or remove
-    /// specific environment variables for the child process only.
-    ///
-    /// Pass a tuple of (key, Some(value)) to set/override, or (key, None) to
-    /// remove a variable from the child's environment.
-    pub async fn new_with_env(
-        codex_home: &Path,
-        env_overrides: &[(&str, Option<&str>)],
-    ) -> anyhow::Result<Self> {
         // Use assert_cmd to locate the binary path and then switch to tokio::process::Command
         let std_cmd = StdCommand::cargo_bin("codex-mcp-server")
             .context("should find binary for codex-mcp-server")?;
@@ -81,17 +67,6 @@ impl McpProcess {
         cmd.env("CODEX_HOME", codex_home);
         cmd.env("RUST_LOG", "debug");
 
-        for (k, v) in env_overrides {
-            match v {
-                Some(val) => {
-                    cmd.env(k, val);
-                }
-                None => {
-                    cmd.env_remove(k);
-                }
-            }
-        }
-
         let mut process = cmd
             .kill_on_drop(true)
             .spawn()
@@ -139,7 +114,6 @@ impl McpProcess {
                 name: "elicitation test".into(),
                 title: Some("Elicitation Test".into()),
                 version: "0.0.0".into(),
-                user_agent: None,
             },
             protocol_version: mcp_types::MCP_SCHEMA_VERSION.into(),
         };
@@ -154,14 +128,6 @@ impl McpProcess {
         .await?;
 
         let initialized = self.read_jsonrpc_message().await?;
-        let os_info = os_info::get();
-        let user_agent = format!(
-            "codex_cli_rs/0.0.0 ({} {}; {}) {} (elicitation test; 0.0.0)",
-            os_info.os_type(),
-            os_info.version(),
-            os_info.architecture().unwrap_or("unknown"),
-            codex_core::terminal::user_agent()
-        );
         assert_eq!(
             JSONRPCMessage::Response(JSONRPCResponse {
                 jsonrpc: JSONRPC_VERSION.into(),
@@ -175,8 +141,7 @@ impl McpProcess {
                     "serverInfo": {
                         "name": "codex-mcp-server",
                         "title": "Codex",
-                        "version": "0.0.0",
-                        "user_agent": user_agent
+                        "version": "0.0.0"
                     },
                     "protocolVersion": mcp_types::MCP_SCHEMA_VERSION
                 })
@@ -221,15 +186,6 @@ impl McpProcess {
         self.send_request("newConversation", params).await
     }
 
-    /// Send an `archiveConversation` JSON-RPC request.
-    pub async fn send_archive_conversation_request(
-        &mut self,
-        params: ArchiveConversationParams,
-    ) -> anyhow::Result<i64> {
-        let params = Some(serde_json::to_value(params)?);
-        self.send_request("archiveConversation", params).await
-    }
-
     /// Send an `addConversationListener` JSON-RPC request.
     pub async fn send_add_conversation_listener_request(
         &mut self,
@@ -296,11 +252,6 @@ impl McpProcess {
         self.send_request("getUserAgent", None).await
     }
 
-    /// Send a `userInfo` JSON-RPC request.
-    pub async fn send_user_info_request(&mut self) -> anyhow::Result<i64> {
-        self.send_request("userInfo", None).await
-    }
-
     /// Send a `listConversations` JSON-RPC request.
     pub async fn send_list_conversations_request(
         &mut self,
@@ -319,15 +270,6 @@ impl McpProcess {
         self.send_request("resumeConversation", params).await
     }
 
-    /// Send a `loginApiKey` JSON-RPC request.
-    pub async fn send_login_api_key_request(
-        &mut self,
-        params: LoginApiKeyParams,
-    ) -> anyhow::Result<i64> {
-        let params = Some(serde_json::to_value(params)?);
-        self.send_request("loginApiKey", params).await
-    }
-
     /// Send a `loginChatGpt` JSON-RPC request.
     pub async fn send_login_chat_gpt_request(&mut self) -> anyhow::Result<i64> {
         self.send_request("loginChatGpt", None).await

codex-rs/mcp-server/tests/suite/archive_conversation.rs

@@ -1,105 +0,0 @@
-use std::path::Path;
-
-use codex_core::ARCHIVED_SESSIONS_SUBDIR;
-use codex_protocol::mcp_protocol::ArchiveConversationParams;
-use codex_protocol::mcp_protocol::ArchiveConversationResponse;
-use codex_protocol::mcp_protocol::NewConversationParams;
-use codex_protocol::mcp_protocol::NewConversationResponse;
-use mcp_test_support::McpProcess;
-use mcp_test_support::to_response;
-use mcp_types::JSONRPCResponse;
-use mcp_types::RequestId;
-use tempfile::TempDir;
-use tokio::time::timeout;
-
-const DEFAULT_READ_TIMEOUT: std::time::Duration = std::time::Duration::from_secs(10);
-
-#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
-async fn archive_conversation_moves_rollout_into_archived_directory() {
-    let codex_home = TempDir::new().expect("create temp dir");
-    create_config_toml(codex_home.path()).expect("write config.toml");
-
-    let mut mcp = McpProcess::new(codex_home.path())
-        .await
-        .expect("spawn mcp process");
-    timeout(DEFAULT_READ_TIMEOUT, mcp.initialize())
-        .await
-        .expect("initialize timeout")
-        .expect("initialize request");
-
-    let new_request_id = mcp
-        .send_new_conversation_request(NewConversationParams {
-            model: Some("mock-model".to_string()),
-            ..Default::default()
-        })
-        .await
-        .expect("send newConversation");
-    let new_response: JSONRPCResponse = timeout(
-        DEFAULT_READ_TIMEOUT,
-        mcp.read_stream_until_response_message(RequestId::Integer(new_request_id)),
-    )
-    .await
-    .expect("newConversation timeout")
-    .expect("newConversation response");
-
-    let NewConversationResponse {
-        conversation_id,
-        rollout_path,
-        ..
-    } = to_response::<NewConversationResponse>(new_response)
-        .expect("deserialize newConversation response");
-
-    assert!(
-        rollout_path.exists(),
-        "expected rollout path {} to exist",
-        rollout_path.display()
-    );
-
-    let archive_request_id = mcp
-        .send_archive_conversation_request(ArchiveConversationParams {
-            conversation_id,
-            rollout_path: rollout_path.clone(),
-        })
-        .await
-        .expect("send archiveConversation");
-    let archive_response: JSONRPCResponse = timeout(
-        DEFAULT_READ_TIMEOUT,
-        mcp.read_stream_until_response_message(RequestId::Integer(archive_request_id)),
-    )
-    .await
-    .expect("archiveConversation timeout")
-    .expect("archiveConversation response");
-
-    let _: ArchiveConversationResponse =
-        to_response::<ArchiveConversationResponse>(archive_response)
-            .expect("deserialize archiveConversation response");
-
-    let archived_directory = codex_home.path().join(ARCHIVED_SESSIONS_SUBDIR);
-    let archived_rollout_path =
-        archived_directory.join(rollout_path.file_name().unwrap_or_else(|| {
-            panic!("rollout path {} missing file name", rollout_path.display())
-        }));
-
-    assert!(
-        !rollout_path.exists(),
-        "expected rollout path {} to be moved",
-        rollout_path.display()
-    );
-    assert!(
-        archived_rollout_path.exists(),
-        "expected archived rollout path {} to exist",
-        archived_rollout_path.display()
-    );
-}
-
-fn create_config_toml(codex_home: &Path) -> std::io::Result<()> {
-    let config_toml = codex_home.join("config.toml");
-    std::fs::write(config_toml, config_contents())
-}
-
-fn config_contents() -> &'static str {
-    r#"model = "mock-model"
-approval_policy = "never"
-sandbox_mode = "read-only"
-"#
-}

codex-rs/mcp-server/tests/suite/auth.rs

@@ -1,10 +1,9 @@
 use std::path::Path;
 
+use codex_core::auth::login_with_api_key;
 use codex_protocol::mcp_protocol::AuthMode;
 use codex_protocol::mcp_protocol::GetAuthStatusParams;
 use codex_protocol::mcp_protocol::GetAuthStatusResponse;
-use codex_protocol::mcp_protocol::LoginApiKeyParams;
-use codex_protocol::mcp_protocol::LoginApiKeyResponse;
 use mcp_test_support::McpProcess;
 use mcp_test_support::to_response;
 use mcp_types::JSONRPCResponse;
@@ -37,31 +36,12 @@ stream_max_retries = 0
     )
 }
 
-async fn login_with_api_key_via_request(mcp: &mut McpProcess, api_key: &str) {
-    let request_id = mcp
-        .send_login_api_key_request(LoginApiKeyParams {
-            api_key: api_key.to_string(),
-        })
-        .await
-        .unwrap_or_else(|e| panic!("send loginApiKey: {e}"));
-
-    let resp: JSONRPCResponse = timeout(
-        DEFAULT_READ_TIMEOUT,
-        mcp.read_stream_until_response_message(RequestId::Integer(request_id)),
-    )
-    .await
-    .unwrap_or_else(|e| panic!("loginApiKey timeout: {e}"))
-    .unwrap_or_else(|e| panic!("loginApiKey response: {e}"));
-    let _: LoginApiKeyResponse =
-        to_response(resp).unwrap_or_else(|e| panic!("deserialize login response: {e}"));
-}
-
 #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
 async fn get_auth_status_no_auth() {
     let codex_home = TempDir::new().unwrap_or_else(|e| panic!("create tempdir: {e}"));
-    create_config_toml(codex_home.path()).unwrap_or_else(|err| panic!("write config.toml: {err}"));
+    create_config_toml(codex_home.path()).expect("write config.toml");
 
-    let mut mcp = McpProcess::new_with_env(codex_home.path(), &[("OPENAI_API_KEY", None)])
+    let mut mcp = McpProcess::new(codex_home.path())
         .await
         .expect("spawn mcp process");
     timeout(DEFAULT_READ_TIMEOUT, mcp.initialize())
@@ -92,7 +72,8 @@ async fn get_auth_status_no_auth() {
 #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
 async fn get_auth_status_with_api_key() {
     let codex_home = TempDir::new().unwrap_or_else(|e| panic!("create tempdir: {e}"));
-    create_config_toml(codex_home.path()).unwrap_or_else(|err| panic!("write config.toml: {err}"));
+    create_config_toml(codex_home.path()).expect("write config.toml");
+    login_with_api_key(codex_home.path(), "sk-test-key").expect("seed api key");
 
     let mut mcp = McpProcess::new(codex_home.path())
         .await
@@ -102,8 +83,6 @@ async fn get_auth_status_with_api_key() {
         .expect("init timeout")
         .expect("init failed");
 
-    login_with_api_key_via_request(&mut mcp, "sk-test-key").await;
-
     let request_id = mcp
         .send_get_auth_status_request(GetAuthStatusParams {
             include_token: Some(true),
@@ -122,12 +101,14 @@ async fn get_auth_status_with_api_key() {
     let status: GetAuthStatusResponse = to_response(resp).expect("deserialize status");
     assert_eq!(status.auth_method, Some(AuthMode::ApiKey));
     assert_eq!(status.auth_token, Some("sk-test-key".to_string()));
+    assert_eq!(status.preferred_auth_method, AuthMode::ChatGPT);
 }
 
 #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
 async fn get_auth_status_with_api_key_no_include_token() {
     let codex_home = TempDir::new().unwrap_or_else(|e| panic!("create tempdir: {e}"));
-    create_config_toml(codex_home.path()).unwrap_or_else(|err| panic!("write config.toml: {err}"));
+    create_config_toml(codex_home.path()).expect("write config.toml");
+    login_with_api_key(codex_home.path(), "sk-test-key").expect("seed api key");
 
     let mut mcp = McpProcess::new(codex_home.path())
         .await
@@ -137,8 +118,6 @@ async fn get_auth_status_with_api_key_no_include_token() {
         .expect("init timeout")
         .expect("init failed");
 
-    login_with_api_key_via_request(&mut mcp, "sk-test-key").await;
-
     // Build params via struct so None field is omitted in wire JSON.
     let params = GetAuthStatusParams {
         include_token: None,
@@ -159,4 +138,5 @@ async fn get_auth_status_with_api_key_no_include_token() {
     let status: GetAuthStatusResponse = to_response(resp).expect("deserialize status");
     assert_eq!(status.auth_method, Some(AuthMode::ApiKey));
     assert!(status.auth_token.is_none(), "token must be omitted");
+    assert_eq!(status.preferred_auth_method, AuthMode::ChatGPT);
 }

codex-rs/mcp-server/tests/suite/codex_message_processor_flow.rs

@@ -90,7 +90,6 @@ async fn test_codex_jsonrpc_conversation_flow() {
     let NewConversationResponse {
         conversation_id,
         model,
-        rollout_path: _,
     } = new_conv_resp;
     assert_eq!(model, "mock-model");
 

codex-rs/mcp-server/tests/suite/create_conversation.rs

@@ -59,7 +59,6 @@ async fn test_conversation_create_and_send_message_ok() {
     let NewConversationResponse {
         conversation_id,
         model,
-        rollout_path: _,
     } = to_response::<NewConversationResponse>(new_conv_resp)
         .expect("deserialize newConversation response");
     assert_eq!(model, "o3");

codex-rs/mcp-server/tests/suite/list_resume.rs

@@ -156,45 +156,23 @@ fn create_fake_rollout(codex_home: &Path, filename_ts: &str, meta_rfc3339: &str,
 
     let file_path = dir.join(format!("rollout-{filename_ts}-{uuid}.jsonl"));
     let mut lines = Vec::new();
-    // Meta line with timestamp (flattened meta in payload for new schema)
     lines.push(
         json!({
+            "record_type": "session_meta",
+            "id": uuid,
             "timestamp": meta_rfc3339,
-            "type": "session_meta",
-            "payload": {
-                "id": uuid,
-                "timestamp": meta_rfc3339,
-                "cwd": "/",
-                "originator": "codex",
-                "cli_version": "0.0.0",
-                "instructions": null
-            }
+            "cwd": codex_home.to_string_lossy(),
+            "originator": "test",
+            "cli_version": "0.0.0-test"
         })
         .to_string(),
     );
-    // Minimal user message entry as a persisted response item (with envelope timestamp)
+    // Minimal user message entry as a persisted response item
     lines.push(
         json!({
-            "timestamp": meta_rfc3339,
-            "type":"response_item",
-            "payload": {
-                "type":"message",
-                "role":"user",
-                "content":[{"type":"input_text","text": preview}]
-            }
-        })
-        .to_string(),
-    );
-    // Add a matching user message event line to satisfy filters
-    lines.push(
-        json!({
-            "timestamp": meta_rfc3339,
-            "type":"event_msg",
-            "payload": {
-                "type":"user_message",
-                "message": preview,
-                "kind": "plain"
-            }
+            "type":"message",
+            "role":"user",
+            "content":[{"type":"input_text","text": preview}]
         })
         .to_string(),
     );

codex-rs/mcp-server/tests/suite/login.rs

@@ -1,7 +1,7 @@
 use std::path::Path;
 use std::time::Duration;
 
-use codex_login::login_with_api_key;
+use codex_core::auth::login_with_api_key;
 use codex_protocol::mcp_protocol::CancelLoginChatGptParams;
 use codex_protocol::mcp_protocol::CancelLoginChatGptResponse;
 use codex_protocol::mcp_protocol::GetAuthStatusParams;
@@ -46,7 +46,7 @@ async fn logout_chatgpt_removes_auth() {
     login_with_api_key(codex_home.path(), "sk-test-key").expect("seed api key");
     assert!(codex_home.path().join("auth.json").exists());
 
-    let mut mcp = McpProcess::new_with_env(codex_home.path(), &[("OPENAI_API_KEY", None)])
+    let mut mcp = McpProcess::new(codex_home.path())
         .await
         .expect("spawn mcp process");
     timeout(DEFAULT_READ_TIMEOUT, mcp.initialize())
@@ -95,7 +95,7 @@ async fn logout_chatgpt_removes_auth() {
 #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
 async fn login_and_cancel_chatgpt() {
     let codex_home = TempDir::new().unwrap_or_else(|e| panic!("create tempdir: {e}"));
-    create_config_toml(codex_home.path()).unwrap_or_else(|err| panic!("write config.toml: {err}"));
+    create_config_toml(codex_home.path()).expect("write config.toml");
 
     let mut mcp = McpProcess::new(codex_home.path())
         .await

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

@@ -1,5 +1,4 @@
 // Aggregates all former standalone integration tests as modules.
-mod archive_conversation;
 mod auth;
 mod codex_message_processor_flow;
 mod codex_tool;
@@ -10,4 +9,3 @@ mod list_resume;
 mod login;
 mod send_message;
 mod user_agent;
-mod user_info;

codex-rs/mcp-server/tests/suite/user_agent.rs

@@ -1,3 +1,5 @@
+use codex_core::default_client::DEFAULT_ORIGINATOR;
+use codex_core::default_client::get_codex_user_agent;
 use codex_protocol::mcp_protocol::GetUserAgentResponse;
 use mcp_test_support::McpProcess;
 use mcp_test_support::to_response;
@@ -33,18 +35,11 @@ async fn get_user_agent_returns_current_codex_user_agent() {
     .expect("getUserAgent timeout")
     .expect("getUserAgent response");
 
-    let os_info = os_info::get();
-    let user_agent = format!(
-        "codex_cli_rs/0.0.0 ({} {}; {}) {} (elicitation test; 0.0.0)",
-        os_info.os_type(),
-        os_info.version(),
-        os_info.architecture().unwrap_or("unknown"),
-        codex_core::terminal::user_agent()
-    );
-
     let received: GetUserAgentResponse =
         to_response(response).expect("deserialize getUserAgent response");
-    let expected = GetUserAgentResponse { user_agent };
+    let expected = GetUserAgentResponse {
+        user_agent: get_codex_user_agent(Some(DEFAULT_ORIGINATOR)),
+    };
 
     assert_eq!(received, expected);
 }

codex-rs/mcp-server/tests/suite/user_info.rs

@@ -1,78 +0,0 @@
-use std::time::Duration;
-
-use anyhow::Context;
-use base64::Engine;
-use base64::engine::general_purpose::URL_SAFE_NO_PAD;
-use codex_core::auth::AuthDotJson;
-use codex_core::auth::get_auth_file;
-use codex_core::auth::write_auth_json;
-use codex_core::token_data::IdTokenInfo;
-use codex_core::token_data::TokenData;
-use codex_protocol::mcp_protocol::UserInfoResponse;
-use mcp_test_support::McpProcess;
-use mcp_test_support::to_response;
-use mcp_types::JSONRPCResponse;
-use mcp_types::RequestId;
-use pretty_assertions::assert_eq;
-use serde_json::json;
-use tempfile::TempDir;
-use tokio::time::timeout;
-
-const DEFAULT_READ_TIMEOUT: Duration = Duration::from_secs(10);
-
-#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
-async fn user_info_returns_email_from_auth_json() {
-    let codex_home = TempDir::new().expect("create tempdir");
-
-    let auth_path = get_auth_file(codex_home.path());
-    let mut id_token = IdTokenInfo::default();
-    id_token.email = Some("user@example.com".to_string());
-    id_token.raw_jwt = encode_id_token_with_email("user@example.com").expect("encode id token");
-
-    let auth = AuthDotJson {
-        openai_api_key: None,
-        tokens: Some(TokenData {
-            id_token,
-            access_token: "access".to_string(),
-            refresh_token: "refresh".to_string(),
-            account_id: None,
-        }),
-        last_refresh: None,
-    };
-    write_auth_json(&auth_path, &auth).expect("write auth.json");
-
-    let mut mcp = McpProcess::new(codex_home.path())
-        .await
-        .expect("spawn mcp process");
-    timeout(DEFAULT_READ_TIMEOUT, mcp.initialize())
-        .await
-        .expect("initialize timeout")
-        .expect("initialize request");
-
-    let request_id = mcp.send_user_info_request().await.expect("send userInfo");
-    let response: JSONRPCResponse = timeout(
-        DEFAULT_READ_TIMEOUT,
-        mcp.read_stream_until_response_message(RequestId::Integer(request_id)),
-    )
-    .await
-    .expect("userInfo timeout")
-    .expect("userInfo response");
-
-    let received: UserInfoResponse = to_response(response).expect("deserialize userInfo response");
-    let expected = UserInfoResponse {
-        alleged_user_email: Some("user@example.com".to_string()),
-    };
-
-    assert_eq!(received, expected);
-}
-
-fn encode_id_token_with_email(email: &str) -> anyhow::Result<String> {
-    let header_b64 = URL_SAFE_NO_PAD.encode(
-        serde_json::to_vec(&json!({ "alg": "none", "typ": "JWT" }))
-            .context("serialize jwt header")?,
-    );
-    let payload =
-        serde_json::to_vec(&json!({ "email": email })).context("serialize jwt payload")?;
-    let payload_b64 = URL_SAFE_NO_PAD.encode(payload);
-    Ok(format!("{header_b64}.{payload_b64}.signature"))
-}

codex-rs/mcp-types/check_lib_rs.py

@@ -1,21 +0,0 @@
-#!/usr/bin/env python3
-
-import subprocess
-import sys
-from pathlib import Path
-
-
-def main() -> int:
-    crate_dir = Path(__file__).resolve().parent
-    generator = crate_dir / "generate_mcp_types.py"
-
-    result = subprocess.run(
-        [sys.executable, str(generator), "--check"],
-        cwd=crate_dir,
-        check=False,
-    )
-    return result.returncode
-
-
-if __name__ == "__main__":
-    raise SystemExit(main())

codex-rs/mcp-types/generate_mcp_types.py

@@ -5,19 +5,15 @@ import argparse
 import json
 import subprocess
 import sys
-import tempfile
 
 from dataclasses import (
     dataclass,
 )
-from difflib import unified_diff
 from pathlib import Path
-from shutil import copy2
 
 # Helper first so it is defined when other functions call it.
 from typing import Any, Literal
 
-
 SCHEMA_VERSION = "2025-06-18"
 JSONRPC_VERSION = "2.0"
 
@@ -47,31 +43,16 @@ def main() -> int:
     default_schema_file = (
         Path(__file__).resolve().parent / "schema" / SCHEMA_VERSION / "schema.json"
     )
-    default_lib_rs = Path(__file__).resolve().parent / "src/lib.rs"
     parser.add_argument(
         "schema_file",
         nargs="?",
         default=default_schema_file,
         help="schema.json file to process",
     )
-    parser.add_argument(
-        "--check",
-        action="store_true",
-        help="Regenerate lib.rs in a sandbox and ensure the checked-in file matches",
-    )
     args = parser.parse_args()
-    schema_file = Path(args.schema_file)
-    crate_dir = Path(__file__).resolve().parent
+    schema_file = args.schema_file
 
-    if args.check:
-        return run_check(schema_file, crate_dir, default_lib_rs)
-
-    generate_lib_rs(schema_file, default_lib_rs, fmt=True)
-    return 0
-
-
-def generate_lib_rs(schema_file: Path, lib_rs: Path, fmt: bool) -> None:
-    lib_rs.parent.mkdir(parents=True, exist_ok=True)
+    lib_rs = Path(__file__).resolve().parent / "src/lib.rs"
 
     global DEFINITIONS  # Allow helper functions to access the schema.
 
@@ -136,7 +117,9 @@ fn default_jsonrpc() -> String {{ JSONRPC_VERSION.to_owned() }}
 
     for req_name in CLIENT_REQUEST_TYPE_NAMES:
         defn = definitions[req_name]
-        method_const = defn.get("properties", {}).get("method", {}).get("const", req_name)
+        method_const = (
+            defn.get("properties", {}).get("method", {}).get("const", req_name)
+        )
         payload_type = f"<{req_name} as ModelContextProtocolRequest>::Params"
         try_from_impl_lines.append(f'            "{method_const}" => {{\n')
         try_from_impl_lines.append(
@@ -145,7 +128,9 @@ fn default_jsonrpc() -> String {{ JSONRPC_VERSION.to_owned() }}
         try_from_impl_lines.append(
             f"                let params: {payload_type} = serde_json::from_value(params_json)?;\n"
         )
-        try_from_impl_lines.append(f"                Ok(ClientRequest::{req_name}(params))\n")
+        try_from_impl_lines.append(
+            f"                Ok(ClientRequest::{req_name}(params))\n"
+        )
         try_from_impl_lines.append("            },\n")
 
     try_from_impl_lines.append(
@@ -159,7 +144,9 @@ fn default_jsonrpc() -> String {{ JSONRPC_VERSION.to_owned() }}
 
     # Generate TryFrom for ServerNotification
     notif_impl_lines: list[str] = []
-    notif_impl_lines.append("impl TryFrom<JSONRPCNotification> for ServerNotification {\n")
+    notif_impl_lines.append(
+        "impl TryFrom<JSONRPCNotification> for ServerNotification {\n"
+    )
     notif_impl_lines.append("    type Error = serde_json::Error;\n")
     notif_impl_lines.append(
         "    fn try_from(n: JSONRPCNotification) -> std::result::Result<Self, Self::Error> {\n"
@@ -168,7 +155,9 @@ fn default_jsonrpc() -> String {{ JSONRPC_VERSION.to_owned() }}
 
     for notif_name in SERVER_NOTIFICATION_TYPE_NAMES:
         n_def = definitions[notif_name]
-        method_const = n_def.get("properties", {}).get("method", {}).get("const", notif_name)
+        method_const = (
+            n_def.get("properties", {}).get("method", {}).get("const", notif_name)
+        )
         payload_type = f"<{notif_name} as ModelContextProtocolNotification>::Params"
         notif_impl_lines.append(f'            "{method_const}" => {{\n')
         # params may be optional
@@ -178,7 +167,9 @@ fn default_jsonrpc() -> String {{ JSONRPC_VERSION.to_owned() }}
         notif_impl_lines.append(
             f"                let params: {payload_type} = serde_json::from_value(params_json)?;\n"
         )
-        notif_impl_lines.append(f"                Ok(ServerNotification::{notif_name}(params))\n")
+        notif_impl_lines.append(
+            f"                Ok(ServerNotification::{notif_name}(params))\n"
+        )
         notif_impl_lines.append("            },\n")
 
     notif_impl_lines.append(
@@ -194,70 +185,13 @@ fn default_jsonrpc() -> String {{ JSONRPC_VERSION.to_owned() }}
         for chunk in out:
             f.write(chunk)
 
-    if fmt:
-        subprocess.check_call(
-            ["cargo", "fmt", "--", "--config", "imports_granularity=Item"],
-            cwd=lib_rs.parent.parent,
-            stderr=subprocess.DEVNULL,
-        )
+    subprocess.check_call(
+        ["cargo", "fmt", "--", "--config", "imports_granularity=Item"],
+        cwd=lib_rs.parent.parent,
+        stderr=subprocess.DEVNULL,
+    )
 
-
-def run_check(schema_file: Path, crate_dir: Path, checked_in_lib: Path) -> int:
-    config_path = crate_dir.parent / "rustfmt.toml"
-    eprint(f"Running --check with schema {schema_file}")
-
-    with tempfile.TemporaryDirectory() as tmp_dir:
-        tmp_path = Path(tmp_dir)
-        eprint(f"Created temporary workspace at {tmp_path}")
-        manifest_path = tmp_path / "Cargo.toml"
-        eprint(f"Copying Cargo.toml into {manifest_path}")
-        copy2(crate_dir / "Cargo.toml", manifest_path)
-        manifest_text = manifest_path.read_text(encoding="utf-8")
-        manifest_text = manifest_text.replace(
-            "version = { workspace = true }",
-            'version = "0.0.0"',
-        )
-        manifest_text = manifest_text.replace("\n[lints]\nworkspace = true\n", "\n")
-        manifest_path.write_text(manifest_text, encoding="utf-8")
-        src_dir = tmp_path / "src"
-        src_dir.mkdir(parents=True, exist_ok=True)
-        eprint(f"Generating lib.rs into {src_dir}")
-        generated_lib = src_dir / "lib.rs"
-
-        generate_lib_rs(schema_file, generated_lib, fmt=False)
-
-        eprint("Formatting generated lib.rs with rustfmt")
-        subprocess.check_call(
-            [
-                "rustfmt",
-                "--config-path",
-                str(config_path),
-                str(generated_lib),
-            ],
-            cwd=tmp_path,
-            stderr=subprocess.DEVNULL,
-        )
-
-        eprint("Comparing generated lib.rs with checked-in version")
-        checked_in_contents = checked_in_lib.read_text(encoding="utf-8")
-        generated_contents = generated_lib.read_text(encoding="utf-8")
-
-        if checked_in_contents == generated_contents:
-            eprint("lib.rs matches checked-in version")
-            return 0
-
-        diff = unified_diff(
-            checked_in_contents.splitlines(keepends=True),
-            generated_contents.splitlines(keepends=True),
-            fromfile=str(checked_in_lib),
-            tofile=str(generated_lib),
-        )
-        diff_text = "".join(diff)
-        eprint("Generated lib.rs does not match the checked-in version. Diff:")
-        if diff_text:
-            eprint(diff_text, end="")
-        eprint("Re-run generate_mcp_types.py without --check to update src/lib.rs.")
-        return 1
+    return 0
 
 
 def add_definition(name: str, definition: dict[str, Any], out: list[str]) -> None:
@@ -331,11 +265,8 @@ class StructField:
     name: str
     type_name: str
     serde: str | None = None
-    comment: str | None = None
 
     def append(self, out: list[str], supports_const: bool) -> None:
-        if self.comment:
-            out.append(f"    // {self.comment}\n")
         if self.serde:
             out.append(f"    {self.serde}\n")
         if self.viz == "const":
@@ -381,18 +312,6 @@ def define_struct(
         else:
             fields.append(StructField("pub", rs_prop.name, prop_type, rs_prop.serde))
 
-    # Special-case: add Codex-specific user_agent to Implementation
-    if name == "Implementation":
-        fields.append(
-            StructField(
-                "pub",
-                "user_agent",
-                "Option<String>",
-                '#[serde(default, skip_serializing_if = "Option::is_none")]',
-                "This is an extra field that the Codex MCP server sends as part of InitializeResult.",
-            )
-        )
-
     if implements_request_trait(name):
         add_trait_impl(name, "ModelContextProtocolRequest", fields, out)
     elif implements_notification_trait(name):
@@ -487,11 +406,15 @@ def define_untagged_enum(name: str, type_list: list[str], out: list[str]) -> Non
             case "integer":
                 out.append("    Integer(i64),\n")
             case _:
-                raise ValueError(f"Unknown type in untagged enum: {simple_type} in {name}")
+                raise ValueError(
+                    f"Unknown type in untagged enum: {simple_type} in {name}"
+                )
     out.append("}\n\n")
 
 
-def define_any_of(name: str, list_of_refs: list[Any], description: str | None = None) -> list[str]:
+def define_any_of(
+    name: str, list_of_refs: list[Any], description: str | None = None
+) -> list[str]:
     """Generate a Rust enum for a JSON-Schema `anyOf` union.
 
     For most types we simply map each `$ref` inside the `anyOf` list to a
@@ -556,7 +479,9 @@ def define_any_of(name: str, list_of_refs: list[Any], description: str | None =
             if name == "ClientRequest":
                 payload_type = f"<{ref_name} as ModelContextProtocolRequest>::Params"
             else:
-                payload_type = f"<{ref_name} as ModelContextProtocolNotification>::Params"
+                payload_type = (
+                    f"<{ref_name} as ModelContextProtocolNotification>::Params"
+                )
 
             # Determine the wire value for `method` so we can annotate the
             # variant appropriately. If for some reason the schema does not
@@ -564,7 +489,9 @@ def define_any_of(name: str, list_of_refs: list[Any], description: str | None =
             # least compile (although deserialization will likely fail).
             request_def = DEFINITIONS.get(ref_name, {})
             method_const = (
-                request_def.get("properties", {}).get("method", {}).get("const", ref_name)
+                request_def.get("properties", {})
+                .get("method", {})
+                .get("const", ref_name)
             )
 
             out.append(f'    #[serde(rename = "{method_const}")]\n')
@@ -614,7 +541,7 @@ def map_type(
     if type_prop == "string":
         if const_prop := typedef.get("const", None):
             assert isinstance(const_prop, str)
-            return f'&\'static str = "{const_prop}"'
+            return f'&\'static str = "{const_prop    }"'
         else:
             return "String"
     elif type_prop == "integer":
@@ -690,7 +617,7 @@ def rust_prop_name(name: str, is_optional: bool) -> RustProp:
         serde_annotations.append('skip_serializing_if = "Option::is_none"')
 
     if serde_annotations:
-        serde_str = f"#[serde({', '.join(serde_annotations)})]"
+        serde_str = f'#[serde({", ".join(serde_annotations)})]'
     else:
         serde_str = None
     return RustProp(prop_name, serde_str)
@@ -698,7 +625,9 @@ def rust_prop_name(name: str, is_optional: bool) -> RustProp:
 
 def to_snake_case(name: str) -> str:
     """Convert a camelCase or PascalCase name to snake_case."""
-    snake_case = name[0].lower() + "".join("_" + c.lower() if c.isupper() else c for c in name[1:])
+    snake_case = name[0].lower() + "".join(
+        "_" + c.lower() if c.isupper() else c for c in name[1:]
+    )
     if snake_case != name:
         return snake_case
     else:
@@ -734,9 +663,5 @@ def emit_doc_comment(text: str | None, out: list[str]) -> None:
         out.append(f"/// {line.rstrip()}\n")
 
 
-def eprint(*args: Any, **kwargs: Any) -> None:
-    print(*args, file=sys.stderr, **kwargs)
-
-
 if __name__ == "__main__":
     sys.exit(main())

codex-rs/mcp-types/src/lib.rs

@@ -487,9 +487,6 @@ pub struct Implementation {
     #[serde(default, skip_serializing_if = "Option::is_none")]
     pub title: Option<String>,
     pub version: String,
-    // This is an extra field that the Codex MCP server sends as part of InitializeResult.
-    #[serde(default, skip_serializing_if = "Option::is_none")]
-    pub user_agent: Option<String>,
 }
 
 #[derive(Debug, Clone, PartialEq, Deserialize, Serialize, TS)]

codex-rs/mcp-types/tests/suite/initialize.rs

@@ -62,7 +62,6 @@ fn deserialize_initialize_request() {
                 name: "acme-client".into(),
                 title: Some("Acme".to_string()),
                 version: "1.2.3".into(),
-                user_agent: None,
             },
             protocol_version: "2025-06-18".into(),
         }

codex-rs/ollama/Cargo.toml

@@ -24,7 +24,9 @@ tokio = { version = "1", features = [
     "rt-multi-thread",
     "signal",
 ] }
+toml = "0.9.5"
 tracing = { version = "0.1.41", features = ["log"] }
 wiremock = "0.6"
 
 [dev-dependencies]
+tempfile = "3"

codex-rs/protocol-ts/Cargo.toml

@@ -16,7 +16,6 @@ path = "src/main.rs"
 
 [dependencies]
 anyhow = "1"
-mcp-types = { path = "../mcp-types" }
 codex-protocol = { path = "../protocol" }
 ts-rs = "11"
 clap = { version = "4", features = ["derive"] }

codex-rs/protocol-ts/src/lib.rs

@@ -16,24 +16,19 @@ pub fn generate_ts(out_dir: &Path, prettier: Option<&Path>) -> Result<()> {
     ensure_dir(out_dir)?;
 
     // Generate TS bindings
-    mcp_types::InitializeResult::export_all_to(out_dir)?;
     codex_protocol::mcp_protocol::ConversationId::export_all_to(out_dir)?;
     codex_protocol::mcp_protocol::InputItem::export_all_to(out_dir)?;
     codex_protocol::mcp_protocol::ClientRequest::export_all_to(out_dir)?;
     codex_protocol::mcp_protocol::ServerRequest::export_all_to(out_dir)?;
     codex_protocol::mcp_protocol::NewConversationResponse::export_all_to(out_dir)?;
-    codex_protocol::mcp_protocol::ListConversationsResponse::export_all_to(out_dir)?;
-    codex_protocol::mcp_protocol::ResumeConversationResponse::export_all_to(out_dir)?;
-    codex_protocol::mcp_protocol::ArchiveConversationResponse::export_all_to(out_dir)?;
     codex_protocol::mcp_protocol::AddConversationSubscriptionResponse::export_all_to(out_dir)?;
     codex_protocol::mcp_protocol::RemoveConversationSubscriptionResponse::export_all_to(out_dir)?;
     codex_protocol::mcp_protocol::SendUserMessageResponse::export_all_to(out_dir)?;
     codex_protocol::mcp_protocol::SendUserTurnResponse::export_all_to(out_dir)?;
     codex_protocol::mcp_protocol::InterruptConversationResponse::export_all_to(out_dir)?;
     codex_protocol::mcp_protocol::GitDiffToRemoteResponse::export_all_to(out_dir)?;
-    codex_protocol::mcp_protocol::LoginApiKeyParams::export_all_to(out_dir)?;
-    codex_protocol::mcp_protocol::LoginApiKeyResponse::export_all_to(out_dir)?;
     codex_protocol::mcp_protocol::LoginChatGptResponse::export_all_to(out_dir)?;
+    codex_protocol::mcp_protocol::LoginChatGptCompleteNotification::export_all_to(out_dir)?;
     codex_protocol::mcp_protocol::CancelLoginChatGptResponse::export_all_to(out_dir)?;
     codex_protocol::mcp_protocol::LogoutChatGptResponse::export_all_to(out_dir)?;
     codex_protocol::mcp_protocol::GetAuthStatusResponse::export_all_to(out_dir)?;
@@ -41,11 +36,9 @@ pub fn generate_ts(out_dir: &Path, prettier: Option<&Path>) -> Result<()> {
     codex_protocol::mcp_protocol::ExecCommandApprovalResponse::export_all_to(out_dir)?;
     codex_protocol::mcp_protocol::GetUserSavedConfigResponse::export_all_to(out_dir)?;
     codex_protocol::mcp_protocol::GetUserAgentResponse::export_all_to(out_dir)?;
-    codex_protocol::mcp_protocol::UserInfoResponse::export_all_to(out_dir)?;
-
-    // All notification types reachable from this enum will be generated by
-    // induction, so they do not need to be listed individually.
     codex_protocol::mcp_protocol::ServerNotification::export_all_to(out_dir)?;
+    codex_protocol::mcp_protocol::ListConversationsResponse::export_all_to(out_dir)?;
+    codex_protocol::mcp_protocol::ResumeConversationResponse::export_all_to(out_dir)?;
 
     generate_index_ts(out_dir)?;
 

codex-rs/protocol/Cargo.toml

@@ -17,6 +17,7 @@ icu_locale_core = "2.0.0"
 mcp-types = { path = "../mcp-types" }
 mime_guess = "2.0.5"
 serde = { version = "1", features = ["derive"] }
+serde_bytes = "0.11"
 serde_json = "1"
 serde_with = { version = "3.14.0", features = ["macros", "base64"] }
 strum = "0.27.2"
@@ -28,8 +29,3 @@ uuid = { version = "1", features = ["serde", "v4"] }
 
 [dev-dependencies]
 pretty_assertions = "1.4.1"
-tempfile = "3"
-
-[package.metadata.cargo-shear]
-# Required because the not imported as strum_macros in non-nightly builds.
-ignored = ["strum"]

codex-rs/protocol/src/mcp_protocol.rs

@@ -91,11 +91,6 @@ pub enum ClientRequest {
         request_id: RequestId,
         params: ResumeConversationParams,
     },
-    ArchiveConversation {
-        #[serde(rename = "id")]
-        request_id: RequestId,
-        params: ArchiveConversationParams,
-    },
     SendUserMessage {
         #[serde(rename = "id")]
         request_id: RequestId,
@@ -126,11 +121,6 @@ pub enum ClientRequest {
         request_id: RequestId,
         params: GitDiffToRemoteParams,
     },
-    LoginApiKey {
-        #[serde(rename = "id")]
-        request_id: RequestId,
-        params: LoginApiKeyParams,
-    },
     LoginChatGpt {
         #[serde(rename = "id")]
         request_id: RequestId,
@@ -157,10 +147,6 @@ pub enum ClientRequest {
         #[serde(rename = "id")]
         request_id: RequestId,
     },
-    UserInfo {
-        #[serde(rename = "id")]
-        request_id: RequestId,
-    },
     /// Execute a command (argv vector) under the server's sandbox.
     ExecOneOffCommand {
         #[serde(rename = "id")]
@@ -217,7 +203,6 @@ pub struct NewConversationParams {
 pub struct NewConversationResponse {
     pub conversation_id: ConversationId,
     pub model: String,
-    pub rollout_path: PathBuf,
 }
 
 #[derive(Serialize, Deserialize, Debug, Clone, TS)]
@@ -277,32 +262,10 @@ pub struct AddConversationSubscriptionResponse {
     pub subscription_id: Uuid,
 }
 
-/// The [`ConversationId`] must match the `rollout_path`.
-#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, TS)]
-#[serde(rename_all = "camelCase")]
-pub struct ArchiveConversationParams {
-    pub conversation_id: ConversationId,
-    pub rollout_path: PathBuf,
-}
-
-#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, TS)]
-#[serde(rename_all = "camelCase")]
-pub struct ArchiveConversationResponse {}
-
 #[derive(Serialize, Deserialize, Debug, Clone, PartialEq, TS)]
 #[serde(rename_all = "camelCase")]
 pub struct RemoveConversationSubscriptionResponse {}
 
-#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, TS)]
-#[serde(rename_all = "camelCase")]
-pub struct LoginApiKeyParams {
-    pub api_key: String,
-}
-
-#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, TS)]
-#[serde(rename_all = "camelCase")]
-pub struct LoginApiKeyResponse {}
-
 #[derive(Serialize, Deserialize, Debug, Clone, PartialEq, TS)]
 #[serde(rename_all = "camelCase")]
 pub struct LoginChatGptResponse {
@@ -382,14 +345,9 @@ pub struct ExecArbitraryCommandResponse {
 pub struct GetAuthStatusResponse {
     #[serde(skip_serializing_if = "Option::is_none")]
     pub auth_method: Option<AuthMode>,
+    pub preferred_auth_method: AuthMode,
     #[serde(skip_serializing_if = "Option::is_none")]
     pub auth_token: Option<String>,
-
-    // Indicates that auth method must be valid to use the server.
-    // This can be false if using a custom provider that is configured
-    // with requires_openai_auth == false.
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub requires_openai_auth: Option<bool>,
 }
 
 #[derive(Serialize, Deserialize, Debug, Clone, PartialEq, TS)]
@@ -398,16 +356,6 @@ pub struct GetUserAgentResponse {
     pub user_agent: String,
 }
 
-#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, TS)]
-#[serde(rename_all = "camelCase")]
-pub struct UserInfoResponse {
-    /// Note: `alleged_user_email` is not currently verified. We read it from
-    /// the local auth.json, which the user could theoretically modify. In the
-    /// future, we may add logic to verify the email against the server before
-    /// returning it.
-    pub alleged_user_email: Option<String>,
-}
-
 #[derive(Serialize, Deserialize, Debug, Clone, PartialEq, TS)]
 #[serde(rename_all = "camelCase")]
 pub struct GetUserSavedConfigResponse {

codex-rs/protocol/src/models.rs

@@ -49,7 +49,7 @@ pub enum ResponseItem {
         content: Vec<ContentItem>,
     },
     Reasoning {
-        #[serde(default, skip_serializing)]
+        #[serde(default)]
         id: String,
         summary: Vec<ReasoningItemReasoningSummary>,
         #[serde(default, skip_serializing_if = "should_serialize_reasoning_content")]
@@ -115,6 +115,7 @@ pub enum ResponseItem {
         status: Option<String>,
         action: WebSearchAction,
     },
+
     #[serde(other)]
     Other,
 }
@@ -219,7 +220,7 @@ impl From<Vec<InputItem>> for ResponseInputItem {
                             let mime = mime_guess::from_path(&path)
                                 .first()
                                 .map(|m| m.essence_str().to_owned())
-                                .unwrap_or_else(|| "image".to_string());
+                                .unwrap_or_else(|| "application/octet-stream".to_string());
                             let encoded = base64::engine::general_purpose::STANDARD.encode(bytes);
                             Some(ContentItem::InputImage {
                                 image_url: format!("data:{mime};base64,{encoded}"),

codex-rs/protocol/src/protocol.rs

@@ -15,7 +15,6 @@ use crate::config_types::ReasoningSummary as ReasoningSummaryConfig;
 use crate::custom_prompts::CustomPrompt;
 use crate::mcp_protocol::ConversationId;
 use crate::message_history::HistoryEntry;
-use crate::models::ResponseItem;
 use crate::num_format::format_with_separators;
 use crate::parse_command::ParsedCommand;
 use crate::plan_tool::UpdatePlanArgs;
@@ -149,7 +148,7 @@ pub enum Op {
 
     /// Request the full in-memory conversation transcript for the current session.
     /// Reply is delivered via `EventMsg::ConversationHistory`.
-    GetPath,
+    GetConversationPath,
 
     /// Request the list of MCP tools available across all configured servers.
     /// Reply is delivered via `EventMsg::McpListToolsResponse`.
@@ -425,7 +424,7 @@ pub enum EventMsg {
     /// Agent text output message
     AgentMessage(AgentMessageEvent),
 
-    /// User/system input message (what was sent to the model)
+    /// User/system input message (what was sent to the model).
     UserMessage(UserMessageEvent),
 
     /// Agent text output delta message
@@ -499,7 +498,7 @@ pub enum EventMsg {
     /// Notification that the agent is shutting down.
     ShutdownComplete,
 
-    ConversationPath(ConversationPathResponseEvent),
+    ConversationHistory(ConversationPathResponseEvent),
 }
 
 // Individual event payload types matching each `EventMsg` variant.
@@ -695,8 +694,6 @@ pub struct UserMessageEvent {
     pub message: String,
     #[serde(skip_serializing_if = "Option::is_none")]
     pub kind: Option<InputMessageKind>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub images: Option<Vec<String>>,
 }
 
 impl<T, U> From<(T, U)> for InputMessageKind
@@ -806,137 +803,6 @@ pub struct ConversationPathResponseEvent {
     pub path: PathBuf,
 }
 
-#[derive(Debug, Clone, Deserialize, Serialize, TS)]
-pub struct ResumedHistory {
-    pub conversation_id: ConversationId,
-    pub history: Vec<RolloutItem>,
-    pub rollout_path: PathBuf,
-}
-
-#[derive(Debug, Clone, Deserialize, Serialize, TS)]
-pub enum InitialHistory {
-    New,
-    Resumed(ResumedHistory),
-    Forked(Vec<RolloutItem>),
-}
-
-impl InitialHistory {
-    pub fn get_rollout_items(&self) -> Vec<RolloutItem> {
-        match self {
-            InitialHistory::New => Vec::new(),
-            InitialHistory::Resumed(resumed) => resumed.history.clone(),
-            InitialHistory::Forked(items) => items.clone(),
-        }
-    }
-    pub fn get_response_items(&self) -> Vec<ResponseItem> {
-        match self {
-            InitialHistory::New => Vec::new(),
-            InitialHistory::Resumed(resumed) => resumed
-                .history
-                .iter()
-                .filter_map(|ri| match ri {
-                    RolloutItem::ResponseItem(item) => Some(item.clone()),
-                    _ => None,
-                })
-                .collect(),
-            InitialHistory::Forked(items) => items
-                .iter()
-                .filter_map(|ri| match ri {
-                    RolloutItem::ResponseItem(item) => Some(item.clone()),
-                    _ => None,
-                })
-                .collect(),
-        }
-    }
-    pub fn get_event_msgs(&self) -> Option<Vec<EventMsg>> {
-        match self {
-            InitialHistory::New => None,
-            InitialHistory::Resumed(resumed) => Some(
-                resumed
-                    .history
-                    .iter()
-                    .filter_map(|ri| match ri {
-                        RolloutItem::EventMsg(ev) => Some(ev.clone()),
-                        _ => None,
-                    })
-                    .collect(),
-            ),
-            InitialHistory::Forked(items) => Some(
-                items
-                    .iter()
-                    .filter_map(|ri| match ri {
-                        RolloutItem::EventMsg(ev) => Some(ev.clone()),
-                        _ => None,
-                    })
-                    .collect(),
-            ),
-        }
-    }
-}
-
-#[derive(Serialize, Deserialize, Clone, Default, Debug, TS)]
-pub struct SessionMeta {
-    pub id: ConversationId,
-    pub timestamp: String,
-    pub cwd: PathBuf,
-    pub originator: String,
-    pub cli_version: String,
-    pub instructions: Option<String>,
-}
-
-#[derive(Serialize, Deserialize, Debug, Clone, TS)]
-pub struct SessionMetaLine {
-    #[serde(flatten)]
-    pub meta: SessionMeta,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub git: Option<GitInfo>,
-}
-
-#[derive(Serialize, Deserialize, Debug, Clone, TS)]
-#[serde(tag = "type", content = "payload", rename_all = "snake_case")]
-pub enum RolloutItem {
-    SessionMeta(SessionMetaLine),
-    ResponseItem(ResponseItem),
-    Compacted(CompactedItem),
-    TurnContext(TurnContextItem),
-    EventMsg(EventMsg),
-}
-
-#[derive(Serialize, Deserialize, Clone, Debug, TS)]
-pub struct CompactedItem {
-    pub message: String,
-}
-
-#[derive(Serialize, Deserialize, Clone, Debug, TS)]
-pub struct TurnContextItem {
-    pub cwd: PathBuf,
-    pub approval_policy: AskForApproval,
-    pub sandbox_policy: SandboxPolicy,
-    pub model: String,
-    pub effort: ReasoningEffortConfig,
-    pub summary: ReasoningSummaryConfig,
-}
-
-#[derive(Serialize, Deserialize, Clone)]
-pub struct RolloutLine {
-    pub timestamp: String,
-    #[serde(flatten)]
-    pub item: RolloutItem,
-}
-
-#[derive(Serialize, Deserialize, Clone, Debug, TS)]
-pub struct GitInfo {
-    /// Current commit hash (SHA)
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub commit_hash: Option<String>,
-    /// Current branch name
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub branch: Option<String>,
-    /// Repository URL (if available from remote)
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub repository_url: Option<String>,
-}
-
 #[derive(Debug, Clone, Deserialize, Serialize, TS)]
 pub struct ExecCommandBeginEvent {
     /// Identifier so this can be paired with the ExecCommandEnd event.
@@ -1091,8 +957,6 @@ pub struct SessionConfiguredEvent {
     /// When present, UIs can use these to seed the history.
     #[serde(skip_serializing_if = "Option::is_none")]
     pub initial_messages: Option<Vec<EventMsg>>,
-
-    pub rollout_path: PathBuf,
 }
 
 /// User's decision in response to an ExecApprovalRequest.
@@ -1155,15 +1019,12 @@ pub enum TurnAbortReason {
 #[cfg(test)]
 mod tests {
     use super::*;
-    use serde_json::json;
-    use tempfile::NamedTempFile;
 
     /// Serialize Event to verify that its JSON representation has the expected
     /// amount of nesting.
     #[test]
     fn serialize_event() {
         let conversation_id = ConversationId(uuid::uuid!("67e55044-10b1-426f-9247-bb680e5fe0c8"));
-        let rollout_file = NamedTempFile::new().unwrap();
         let event = Event {
             id: "1234".to_string(),
             msg: EventMsg::SessionConfigured(SessionConfiguredEvent {
@@ -1172,22 +1033,13 @@ mod tests {
                 history_log_id: 0,
                 history_entry_count: 0,
                 initial_messages: None,
-                rollout_path: rollout_file.path().to_path_buf(),
             }),
         };
-
-        let expected = json!({
-            "id": "1234",
-            "msg": {
-                "type": "session_configured",
-                "session_id": "67e55044-10b1-426f-9247-bb680e5fe0c8",
-                "model": "codex-mini-latest",
-                "history_log_id": 0,
-                "history_entry_count": 0,
-                "rollout_path": format!("{}", rollout_file.path().display()),
-            }
-        });
-        assert_eq!(expected, serde_json::to_value(&event).unwrap());
+        let serialized = serde_json::to_string(&event).unwrap();
+        assert_eq!(
+            serialized,
+            r#"{"id":"1234","msg":{"type":"session_configured","session_id":"67e55044-10b1-426f-9247-bb680e5fe0c8","model":"codex-mini-latest","history_log_id":0,"history_entry_count":0}}"#
+        );
     }
 
     #[test]

codex-rs/tui/Cargo.toml

@@ -59,7 +59,9 @@ ratatui = { version = "0.29.0", features = [
     "unstable-rendered-line-info",
     "unstable-widget-ref",
 ] }
+ratatui-image = "8.0.0"
 regex-lite = "0.1"
+reqwest = { version = "0.12", features = ["json"] }
 serde = { version = "1", features = ["derive"] }
 serde_json = { version = "1", features = ["preserve_order"] }
 shlex = "1.3.0"
@@ -79,10 +81,12 @@ tokio-stream = "0.1.17"
 tracing = { version = "0.1.41", features = ["log"] }
 tracing-appender = "0.2.3"
 tracing-subscriber = { version = "0.3.19", features = ["env-filter"] }
-pulldown-cmark = "0.10"
+tui-input = "0.14.0"
+tui-markdown = "0.3.3"
 unicode-segmentation = "1.12.0"
 unicode-width = "0.1"
 url = "2"
+uuid = "1"
 pathdiff = "0.2"
 
 [target.'cfg(unix)'.dependencies]

codex-rs/tui/src/app.rs

@@ -11,8 +11,6 @@ use codex_ansi_escape::ansi_escape_line;
 use codex_core::AuthManager;
 use codex_core::ConversationManager;
 use codex_core::config::Config;
-use codex_core::config::persist_model_selection;
-use codex_core::model_family::find_family_for_model;
 use codex_core::protocol::TokenUsage;
 use color_eyre::eyre::Result;
 use color_eyre::eyre::WrapErr;
@@ -39,9 +37,6 @@ pub(crate) struct App {
 
     /// Config is stored here so we can recreate ChatWidgets as needed.
     pub(crate) config: Config,
-    pub(crate) active_profile: Option<String>,
-    model_saved_to_profile: bool,
-    model_saved_to_global: bool,
 
     pub(crate) file_search: FileSearchManager,
 
@@ -66,7 +61,6 @@ impl App {
         tui: &mut tui::Tui,
         auth_manager: Arc<AuthManager>,
         config: Config,
-        active_profile: Option<String>,
         initial_prompt: Option<String>,
         initial_images: Vec<PathBuf>,
         resume_selection: ResumeSelection,
@@ -125,9 +119,6 @@ impl App {
             app_event_tx,
             chat_widget,
             config,
-            active_profile,
-            model_saved_to_profile: false,
-            model_saved_to_global: false,
             file_search,
             enhanced_keys_supported,
             transcript_lines: Vec::new(),
@@ -300,14 +291,7 @@ impl App {
                 self.chat_widget.set_reasoning_effort(effort);
             }
             AppEvent::UpdateModel(model) => {
-                self.chat_widget.set_model(model.clone());
-                self.config.model = model.clone();
-                if let Some(family) = find_family_for_model(&model) {
-                    self.config.model_family = family;
-                }
-                self.model_saved_to_profile = false;
-                self.model_saved_to_global = false;
-                self.show_model_save_hint();
+                self.chat_widget.set_model(model);
             }
             AppEvent::UpdateAskForApprovalPolicy(policy) => {
                 self.chat_widget.set_approval_policy(policy);
@@ -320,93 +304,7 @@ impl App {
     }
 
     pub(crate) fn token_usage(&self) -> codex_core::protocol::TokenUsage {
-        self.chat_widget.token_usage()
-    }
-
-    fn show_model_save_hint(&mut self) {
-        let model = self.config.model.clone();
-        if self.active_profile.is_some() {
-            self.chat_widget.add_info_message(format!(
-                "Model switched to {model}. Press Ctrl+S to save it for this profile, then press Ctrl+S again to set it as your global default."
-            ));
-        } else {
-            self.chat_widget.add_info_message(format!(
-                "Model switched to {model}. Press Ctrl+S to save it as your global default."
-            ));
-        }
-    }
-
-    async fn persist_model_shortcut(&mut self) {
-        enum SaveScope<'a> {
-            Profile(&'a str),
-            Global,
-            AlreadySaved,
-        }
-
-        let scope = if let Some(profile) = self
-            .active_profile
-            .as_deref()
-            .filter(|_| !self.model_saved_to_profile)
-        {
-            SaveScope::Profile(profile)
-        } else if !self.model_saved_to_global {
-            SaveScope::Global
-        } else {
-            SaveScope::AlreadySaved
-        };
-
-        let model = self.config.model.clone();
-        let effort = self.config.model_reasoning_effort;
-        let codex_home = self.config.codex_home.clone();
-
-        match scope {
-            SaveScope::Profile(profile) => {
-                match persist_model_selection(&codex_home, Some(profile), &model, Some(effort))
-                    .await
-                {
-                    Ok(()) => {
-                        self.model_saved_to_profile = true;
-                        self.chat_widget.add_info_message(format!(
-                            "Saved model {model} ({effort}) for profile `{profile}`. Press Ctrl+S again to make this your global default."
-                        ));
-                    }
-                    Err(err) => {
-                        tracing::error!(
-                            error = %err,
-                            "failed to persist model selection via shortcut"
-                        );
-                        self.chat_widget.add_error_message(format!(
-                            "Failed to save model preference for profile `{profile}`: {err}"
-                        ));
-                    }
-                }
-            }
-            SaveScope::Global => {
-                match persist_model_selection(&codex_home, None, &model, Some(effort)).await {
-                    Ok(()) => {
-                        self.model_saved_to_global = true;
-                        self.chat_widget.add_info_message(format!(
-                            "Saved model {model} ({effort}) as your global default."
-                        ));
-                    }
-                    Err(err) => {
-                        tracing::error!(
-                            error = %err,
-                            "failed to persist global model selection via shortcut"
-                        );
-                        self.chat_widget.add_error_message(format!(
-                            "Failed to save global model preference: {err}"
-                        ));
-                    }
-                }
-            }
-            SaveScope::AlreadySaved => {
-                self.chat_widget.add_info_message(
-                    "Model preference already saved globally; no further action needed."
-                        .to_string(),
-                );
-            }
-        }
+        self.chat_widget.token_usage().clone()
     }
 
     async fn handle_key_event(&mut self, tui: &mut tui::Tui, key_event: KeyEvent) {
@@ -422,14 +320,6 @@ impl App {
                 self.overlay = Some(Overlay::new_transcript(self.transcript_lines.clone()));
                 tui.frame_requester().schedule_frame();
             }
-            KeyEvent {
-                code: KeyCode::Char('s'),
-                modifiers: crossterm::event::KeyModifiers::CONTROL,
-                kind: KeyEventKind::Press,
-                ..
-            } => {
-                self.persist_model_shortcut().await;
-            }
             // Esc primes/advances backtracking only in normal (not working) mode
             // with an empty composer. In any other state, forward Esc so the
             // active UI (e.g. status indicator, modals, popups) handles it.