feat: improve macOS tab title

.github/workflows/ci.yml

@@ -27,26 +27,12 @@ jobs:
       - name: Install dependencies
         run: pnpm install --frozen-lockfile
 
-      # build_npm_package.py requires DotSlash when staging releases.
-      - uses: facebook/install-dotslash@v2
+      # Run all tasks using workspace filters
 
-      - name: Stage npm package
+      - name: Ensure staging a release works.
         env:
           GH_TOKEN: ${{ github.token }}
-        run: |
-          set -euo pipefail
-          CODEX_VERSION=0.40.0
-          PACK_OUTPUT="${RUNNER_TEMP}/codex-npm.tgz"
-          python3 ./codex-cli/scripts/build_npm_package.py \
-            --release-version "$CODEX_VERSION" \
-            --pack-output "$PACK_OUTPUT"
-          echo "PACK_OUTPUT=$PACK_OUTPUT" >> "$GITHUB_ENV"
-
-      - name: Upload staged npm package artifact
-        uses: actions/upload-artifact@v4
-        with:
-          name: codex-npm-staging
-          path: ${{ env.PACK_OUTPUT }}
+        run: ./codex-cli/scripts/stage_release.sh
 
       - name: Ensure root README.md contains only ASCII and certain Unicode code points
         run: ./scripts/asciicheck.py README.md

.github/workflows/rust-release.yml

@@ -173,8 +173,6 @@ jobs:
     outputs:
       version: ${{ steps.release_name.outputs.name }}
       tag: ${{ github.ref_name }}
-      should_publish_npm: ${{ steps.npm_publish_settings.outputs.should_publish }}
-      npm_tag: ${{ steps.npm_publish_settings.outputs.npm_tag }}
 
     steps:
       - name: Checkout repository
@@ -195,37 +193,21 @@ jobs:
           version="${GITHUB_REF_NAME#rust-v}"
           echo "name=${version}" >> $GITHUB_OUTPUT
 
-      - name: Determine npm publish settings
-        id: npm_publish_settings
-        env:
-          VERSION: ${{ steps.release_name.outputs.name }}
-        run: |
-          set -euo pipefail
-          version="${VERSION}"
-
-          if [[ "${version}" =~ ^[0-9]+\.[0-9]+\.[0-9]+$ ]]; then
-            echo "should_publish=true" >> "$GITHUB_OUTPUT"
-            echo "npm_tag=" >> "$GITHUB_OUTPUT"
-          elif [[ "${version}" =~ ^[0-9]+\.[0-9]+\.[0-9]+-alpha\.[0-9]+$ ]]; then
-            echo "should_publish=true" >> "$GITHUB_OUTPUT"
-            echo "npm_tag=alpha" >> "$GITHUB_OUTPUT"
-          else
-            echo "should_publish=false" >> "$GITHUB_OUTPUT"
-            echo "npm_tag=" >> "$GITHUB_OUTPUT"
-          fi
-
-      # build_npm_package.py requires DotSlash when staging releases.
-      - uses: facebook/install-dotslash@v2
       - name: Stage npm package
         env:
           GH_TOKEN: ${{ github.token }}
         run: |
           set -euo pipefail
           TMP_DIR="${RUNNER_TEMP}/npm-stage"
-          ./codex-cli/scripts/build_npm_package.py \
+          python3 codex-cli/scripts/stage_rust_release.py \
             --release-version "${{ steps.release_name.outputs.name }}" \
-            --staging-dir "${TMP_DIR}" \
-            --pack-output "${GITHUB_WORKSPACE}/dist/npm/codex-npm-${{ steps.release_name.outputs.name }}.tgz"
+            --tmp "${TMP_DIR}"
+          mkdir -p dist/npm
+          # Produce an npm-ready tarball using `npm pack` and store it in dist/npm.
+          # We then rename it to a stable name used by our publishing script.
+          (cd "$TMP_DIR" && npm pack --pack-destination "${GITHUB_WORKSPACE}/dist/npm")
+          mv "${GITHUB_WORKSPACE}"/dist/npm/*.tgz \
+             "${GITHUB_WORKSPACE}/dist/npm/codex-npm-${{ steps.release_name.outputs.name }}.tgz"
 
       - name: Create GitHub Release
         uses: softprops/action-gh-release@v2
@@ -248,8 +230,8 @@ jobs:
   # July 31, 2025: https://github.blog/changelog/2025-07-31-npm-trusted-publishing-with-oidc-is-generally-available/
   # npm docs: https://docs.npmjs.com/trusted-publishers
   publish-npm:
-    # Publish to npm for stable releases and alpha pre-releases with numeric suffixes.
-    if: ${{ needs.release.outputs.should_publish_npm == 'true' }}
+    # Skip this step for pre-releases (alpha/beta).
+    if: ${{ !contains(needs.release.outputs.version, '-') }}
     name: publish-npm
     needs: release
     runs-on: ubuntu-latest
@@ -284,17 +266,7 @@ jobs:
 
       # No NODE_AUTH_TOKEN needed because we use OIDC.
       - name: Publish to npm
-        env:
-          VERSION: ${{ needs.release.outputs.version }}
-          NPM_TAG: ${{ needs.release.outputs.npm_tag }}
-        run: |
-          set -euo pipefail
-          tag_args=()
-          if [[ -n "${NPM_TAG}" ]]; then
-            tag_args+=(--tag "${NPM_TAG}")
-          fi
-
-          npm publish "${GITHUB_WORKSPACE}/dist/npm/codex-npm-${VERSION}.tgz" "${tag_args[@]}"
+        run: npm publish "${GITHUB_WORKSPACE}/dist/npm/codex-npm-${{ needs.release.outputs.version }}.tgz"
 
   update-branch:
     name: Update latest-alpha-cli branch

codex-cli/.gitignore

@@ -1 +1,7 @@
-/vendor/
+# Added by ./scripts/install_native_deps.sh
+/bin/codex-aarch64-apple-darwin
+/bin/codex-aarch64-unknown-linux-musl
+/bin/codex-linux-sandbox-arm64
+/bin/codex-linux-sandbox-x64
+/bin/codex-x86_64-apple-darwin
+/bin/codex-x86_64-unknown-linux-musl

codex-cli/bin/codex.js

@@ -1,7 +1,6 @@
 #!/usr/bin/env node
 // Unified entry point for the Codex CLI.
 
-import { existsSync } from "fs";
 import path from "path";
 import { fileURLToPath } from "url";
 
@@ -41,10 +40,10 @@ switch (platform) {
   case "win32":
     switch (arch) {
       case "x64":
-        targetTriple = "x86_64-pc-windows-msvc";
+        targetTriple = "x86_64-pc-windows-msvc.exe";
         break;
       case "arm64":
-        targetTriple = "aarch64-pc-windows-msvc";
+        targetTriple = "aarch64-pc-windows-msvc.exe";
         break;
       default:
         break;
@@ -58,10 +57,7 @@ if (!targetTriple) {
   throw new Error(`Unsupported platform: ${platform} (${arch})`);
 }
 
-const vendorRoot = path.join(__dirname, "..", "vendor");
-const archRoot = path.join(vendorRoot, targetTriple);
-const codexBinaryName = process.platform === "win32" ? "codex.exe" : "codex";
-const binaryPath = path.join(archRoot, "codex", codexBinaryName);
+const binaryPath = path.join(__dirname, "..", "bin", `codex-${targetTriple}`);
 
 // Use an asynchronous spawn instead of spawnSync so that Node is able to
 // respond to signals (e.g. Ctrl-C / SIGINT) while the native binary is
@@ -70,6 +66,23 @@ const binaryPath = path.join(archRoot, "codex", codexBinaryName);
 // receives a fatal signal, both processes exit in a predictable manner.
 const { spawn } = await import("child_process");
 
+async function tryImport(moduleName) {
+  try {
+    // eslint-disable-next-line node/no-unsupported-features/es-syntax
+    return await import(moduleName);
+  } catch (err) {
+    return null;
+  }
+}
+
+async function resolveRgDir() {
+  const ripgrep = await tryImport("@vscode/ripgrep");
+  if (!ripgrep?.rgPath) {
+    return null;
+  }
+  return path.dirname(ripgrep.rgPath);
+}
+
 function getUpdatedPath(newDirs) {
   const pathSep = process.platform === "win32" ? ";" : ":";
   const existingPath = process.env.PATH || "";
@@ -80,13 +93,63 @@ function getUpdatedPath(newDirs) {
   return updatedPath;
 }
 
+function sanitizeTitleSegment(segment) {
+  return segment
+    .replace(/[\u0000-\u001f\u007f]/g, " ")
+    .replace(/\s+/g, " ")
+    .trim();
+}
+
+function truncateWithEllipsis(text, maxLength) {
+  if (text.length <= maxLength) {
+    return text;
+  }
+  if (maxLength <= 1) {
+    return text.slice(0, maxLength);
+  }
+  return `${text.slice(0, maxLength - 1)}…`;
+}
+
+function buildMacOSTabTitle(argv) {
+  const argsString = sanitizeTitleSegment(argv.join(" "));
+  const truncatedArgs = argsString
+    ? truncateWithEllipsis(argsString, 60)
+    : null;
+  const cwdLabel = sanitizeTitleSegment(path.basename(process.cwd()));
+  const parts = ["codex"];
+  if (truncatedArgs) {
+    parts.push(truncatedArgs);
+  }
+  let title = parts.join(" ");
+  if (cwdLabel) {
+    title = `${title} — ${cwdLabel}`;
+  }
+  return title;
+}
+
+function updateMacOSTabTitle(argv) {
+  if (platform !== "darwin") {
+    return;
+  }
+  if (!process.stdout?.isTTY) {
+    return;
+  }
+  const title = buildMacOSTabTitle(argv);
+  if (!title) {
+    return;
+  }
+  process.stdout.write(`\u001B]0;${title}\u0007`);
+}
+
 const additionalDirs = [];
-const pathDir = path.join(archRoot, "path");
-if (existsSync(pathDir)) {
-  additionalDirs.push(pathDir);
+const rgDir = await resolveRgDir();
+if (rgDir) {
+  additionalDirs.push(rgDir);
 }
 const updatedPath = getUpdatedPath(additionalDirs);
 
+updateMacOSTabTitle(process.argv.slice(2));
+
 const child = spawn(binaryPath, process.argv.slice(2), {
   stdio: "inherit",
   env: { ...process.env, PATH: updatedPath, CODEX_MANAGED_BY_NPM: "1" },

codex-cli/bin/rg

@@ -1,79 +0,0 @@
-#!/usr/bin/env dotslash
-
-{
-  "name": "rg",
-  "platforms": {
-    "macos-aarch64": {
-      "size": 1787248,
-      "hash": "blake3",
-      "digest": "8d9942032585ea8ee805937634238d9aee7b210069f4703c88fbe568e26fb78a",
-      "format": "tar.gz",
-      "path": "ripgrep-14.1.1-aarch64-apple-darwin/rg",
-      "providers": [
-        {
-          "url": "https://github.com/BurntSushi/ripgrep/releases/download/14.1.1/ripgrep-14.1.1-aarch64-apple-darwin.tar.gz"
-        }
-      ]
-    },
-    "linux-aarch64": {
-      "size": 2047405,
-      "hash": "blake3",
-      "digest": "0b670b8fa0a3df2762af2fc82cc4932f684ca4c02dbd1260d4f3133fd4b2a515",
-      "format": "tar.gz",
-      "path": "ripgrep-14.1.1-aarch64-unknown-linux-gnu/rg",
-      "providers": [
-        {
-          "url": "https://github.com/BurntSushi/ripgrep/releases/download/14.1.1/ripgrep-14.1.1-aarch64-unknown-linux-gnu.tar.gz"
-        }
-      ]
-    },
-    "macos-x86_64": {
-      "size": 2082672,
-      "hash": "blake3",
-      "digest": "e9b862fc8da3127f92791f0ff6a799504154ca9d36c98bf3e60a81c6b1f7289e",
-      "format": "tar.gz",
-      "path": "ripgrep-14.1.1-x86_64-apple-darwin/rg",
-      "providers": [
-        {
-          "url": "https://github.com/BurntSushi/ripgrep/releases/download/14.1.1/ripgrep-14.1.1-x86_64-apple-darwin.tar.gz"
-        }
-      ]
-    },
-    "linux-x86_64": {
-      "size": 2566310,
-      "hash": "blake3",
-      "digest": "f73cca4e54d78c31f832c7f6e2c0b4db8b04fa3eaa747915727d570893dbee76",
-      "format": "tar.gz",
-      "path": "ripgrep-14.1.1-x86_64-unknown-linux-musl/rg",
-      "providers": [
-        {
-          "url": "https://github.com/BurntSushi/ripgrep/releases/download/14.1.1/ripgrep-14.1.1-x86_64-unknown-linux-musl.tar.gz"
-        }
-      ]
-    },
-    "windows-x86_64": {
-      "size": 2058893,
-      "hash": "blake3",
-      "digest": "a8ce1a6fed4f8093ee997e57f33254e94b2cd18e26358b09db599c89882eadbd",
-      "format": "zip",
-      "path": "ripgrep-14.1.1-x86_64-pc-windows-msvc/rg.exe",
-      "providers": [
-        {
-          "url": "https://github.com/BurntSushi/ripgrep/releases/download/14.1.1/ripgrep-14.1.1-x86_64-pc-windows-msvc.zip"
-        }
-      ]
-    },
-    "windows-aarch64": {
-      "size": 1667740,
-      "hash": "blake3",
-      "digest": "47b971a8c4fca1d23a4e7c19bd4d88465ebc395598458133139406d3bf85f3fa",
-      "format": "zip",
-      "path": "rg.exe",
-      "providers": [
-        {
-          "url": "https://github.com/microsoft/ripgrep-prebuilt/releases/download/v13.0.0-13/ripgrep-v13.0.0-13-aarch64-pc-windows-msvc.zip"
-        }
-      ]
-    }
-  }
-}

codex-cli/package-lock.json

@@ -2,17 +2,118 @@
   "name": "@openai/codex",
   "version": "0.0.0-dev",
   "lockfileVersion": 3,
+  "requires": true,
   "packages": {
     "": {
       "name": "@openai/codex",
       "version": "0.0.0-dev",
       "license": "Apache-2.0",
+      "dependencies": {
+        "@vscode/ripgrep": "^1.15.14"
+      },
       "bin": {
         "codex": "bin/codex.js"
       },
       "engines": {
         "node": ">=20"
       }
+    },
+    "node_modules/@vscode/ripgrep": {
+      "version": "1.15.14",
+      "resolved": "https://registry.npmjs.org/@vscode/ripgrep/-/ripgrep-1.15.14.tgz",
+      "integrity": "sha512-/G1UJPYlm+trBWQ6cMO3sv6b8D1+G16WaJH1/DSqw32JOVlzgZbLkDxRyzIpTpv30AcYGMkCf5tUqGlW6HbDWw==",
+      "hasInstallScript": true,
+      "license": "MIT",
+      "dependencies": {
+        "https-proxy-agent": "^7.0.2",
+        "proxy-from-env": "^1.1.0",
+        "yauzl": "^2.9.2"
+      }
+    },
+    "node_modules/agent-base": {
+      "version": "7.1.4",
+      "resolved": "https://registry.npmjs.org/agent-base/-/agent-base-7.1.4.tgz",
+      "integrity": "sha512-MnA+YT8fwfJPgBx3m60MNqakm30XOkyIoH1y6huTQvC0PwZG7ki8NacLBcrPbNoo8vEZy7Jpuk7+jMO+CUovTQ==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 14"
+      }
+    },
+    "node_modules/buffer-crc32": {
+      "version": "0.2.13",
+      "resolved": "https://registry.npmjs.org/buffer-crc32/-/buffer-crc32-0.2.13.tgz",
+      "integrity": "sha512-VO9Ht/+p3SN7SKWqcrgEzjGbRSJYTx+Q1pTQC0wrWqHx0vpJraQ6GtHx8tvcg1rlK1byhU5gccxgOgj7B0TDkQ==",
+      "license": "MIT",
+      "engines": {
+        "node": "*"
+      }
+    },
+    "node_modules/debug": {
+      "version": "4.4.1",
+      "resolved": "https://registry.npmjs.org/debug/-/debug-4.4.1.tgz",
+      "integrity": "sha512-KcKCqiftBJcZr++7ykoDIEwSa3XWowTfNPo92BYxjXiyYEVrUQh2aLyhxBCwww+heortUFxEJYcRzosstTEBYQ==",
+      "license": "MIT",
+      "dependencies": {
+        "ms": "^2.1.3"
+      },
+      "engines": {
+        "node": ">=6.0"
+      },
+      "peerDependenciesMeta": {
+        "supports-color": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/fd-slicer": {
+      "version": "1.1.0",
+      "resolved": "https://registry.npmjs.org/fd-slicer/-/fd-slicer-1.1.0.tgz",
+      "integrity": "sha512-cE1qsB/VwyQozZ+q1dGxR8LBYNZeofhEdUNGSMbQD3Gw2lAzX9Zb3uIU6Ebc/Fmyjo9AWWfnn0AUCHqtevs/8g==",
+      "license": "MIT",
+      "dependencies": {
+        "pend": "~1.2.0"
+      }
+    },
+    "node_modules/https-proxy-agent": {
+      "version": "7.0.6",
+      "resolved": "https://registry.npmjs.org/https-proxy-agent/-/https-proxy-agent-7.0.6.tgz",
+      "integrity": "sha512-vK9P5/iUfdl95AI+JVyUuIcVtd4ofvtrOr3HNtM2yxC9bnMbEdp3x01OhQNnjb8IJYi38VlTE3mBXwcfvywuSw==",
+      "license": "MIT",
+      "dependencies": {
+        "agent-base": "^7.1.2",
+        "debug": "4"
+      },
+      "engines": {
+        "node": ">= 14"
+      }
+    },
+    "node_modules/ms": {
+      "version": "2.1.3",
+      "resolved": "https://registry.npmjs.org/ms/-/ms-2.1.3.tgz",
+      "integrity": "sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA==",
+      "license": "MIT"
+    },
+    "node_modules/pend": {
+      "version": "1.2.0",
+      "resolved": "https://registry.npmjs.org/pend/-/pend-1.2.0.tgz",
+      "integrity": "sha512-F3asv42UuXchdzt+xXqfW1OGlVBe+mxa2mqI0pg5yAHZPvFmY3Y6drSf/GQ1A86WgWEN9Kzh/WrgKa6iGcHXLg==",
+      "license": "MIT"
+    },
+    "node_modules/proxy-from-env": {
+      "version": "1.1.0",
+      "resolved": "https://registry.npmjs.org/proxy-from-env/-/proxy-from-env-1.1.0.tgz",
+      "integrity": "sha512-D+zkORCbA9f1tdWRK0RaCR3GPv50cMxcrz4X8k5LTSUD1Dkw47mKJEZQNunItRTkWwgtaUSo1RVFRIG9ZXiFYg==",
+      "license": "MIT"
+    },
+    "node_modules/yauzl": {
+      "version": "2.10.0",
+      "resolved": "https://registry.npmjs.org/yauzl/-/yauzl-2.10.0.tgz",
+      "integrity": "sha512-p4a9I6X6nu6IhoGmBqAcbJy1mlC4j27vEPZX9F4L4/vZT3Lyq1VkFHw/V/PUcB9Buo+DG3iHkT0x3Qya58zc3g==",
+      "license": "MIT",
+      "dependencies": {
+        "buffer-crc32": "~0.2.3",
+        "fd-slicer": "~1.1.0"
+      }
     }
   }
 }

codex-cli/package.json

@@ -11,11 +11,17 @@
   },
   "files": [
     "bin",
-    "vendor"
+    "dist"
   ],
   "repository": {
     "type": "git",
     "url": "git+https://github.com/openai/codex.git",
     "directory": "codex-cli"
+  },
+  "dependencies": {
+    "@vscode/ripgrep": "^1.15.14"
+  },
+  "devDependencies": {
+    "prettier": "^3.3.3"
   }
 }

codex-cli/scripts/README.md

@@ -5,7 +5,5 @@ Run the following:
 To build the 0.2.x or later version of the npm module, which runs the Rust version of the CLI, build it as follows:
 
 ```bash
-./codex-cli/scripts/build_npm_package.py --release-version 0.6.0
+./codex-cli/scripts/stage_rust_release.py --release-version 0.6.0
 ```
-
-Note this will create `./codex-cli/vendor/` as a side-effect.

codex-cli/scripts/build_npm_package.py

@@ -1,294 +0,0 @@
-#!/usr/bin/env python3
-"""Stage and optionally package the @openai/codex npm module."""
-
-import argparse
-import json
-import re
-import shutil
-import subprocess
-import sys
-import tempfile
-from pathlib import Path
-
-SCRIPT_DIR = Path(__file__).resolve().parent
-CODEX_CLI_ROOT = SCRIPT_DIR.parent
-REPO_ROOT = CODEX_CLI_ROOT.parent
-GITHUB_REPO = "openai/codex"
-
-
-def parse_args() -> argparse.Namespace:
-    parser = argparse.ArgumentParser(description="Build or stage the Codex CLI npm package.")
-    parser.add_argument(
-        "--version",
-        help="Version number to write to package.json inside the staged package.",
-    )
-    parser.add_argument(
-        "--release-version",
-        help=(
-            "Version to stage for npm release. When provided, the script also resolves the "
-            "matching rust-release workflow unless --workflow-url is supplied."
-        ),
-    )
-    parser.add_argument(
-        "--workflow-url",
-        help="Optional GitHub Actions workflow run URL used to download native binaries.",
-    )
-    parser.add_argument(
-        "--staging-dir",
-        type=Path,
-        help=(
-            "Directory to stage the package contents. Defaults to a new temporary directory "
-            "if omitted. The directory must be empty when provided."
-        ),
-    )
-    parser.add_argument(
-        "--tmp",
-        dest="staging_dir",
-        type=Path,
-        help=argparse.SUPPRESS,
-    )
-    parser.add_argument(
-        "--pack-output",
-        type=Path,
-        help="Path where the generated npm tarball should be written.",
-    )
-    return parser.parse_args()
-
-
-def main() -> int:
-    args = parse_args()
-
-    version = args.version
-    release_version = args.release_version
-    if release_version:
-        if version and version != release_version:
-            raise RuntimeError("--version and --release-version must match when both are provided.")
-        version = release_version
-
-    if not version:
-        raise RuntimeError("Must specify --version or --release-version.")
-
-    staging_dir, created_temp = prepare_staging_dir(args.staging_dir)
-
-    try:
-        stage_sources(staging_dir, version)
-
-        workflow_url = args.workflow_url
-        resolved_head_sha: str | None = None
-        if not workflow_url:
-            if release_version:
-                workflow = resolve_release_workflow(version)
-                workflow_url = workflow["url"]
-                resolved_head_sha = workflow.get("headSha")
-            else:
-                workflow_url = resolve_latest_alpha_workflow_url()
-        elif release_version:
-            try:
-                workflow = resolve_release_workflow(version)
-                resolved_head_sha = workflow.get("headSha")
-            except Exception:
-                resolved_head_sha = None
-
-        if release_version and resolved_head_sha:
-            print(f"should `git checkout {resolved_head_sha}`")
-
-        if not workflow_url:
-            raise RuntimeError("Unable to determine workflow URL for native binaries.")
-
-        install_native_binaries(staging_dir, workflow_url)
-
-        if release_version:
-            staging_dir_str = str(staging_dir)
-            print(
-                f"Staged version {version} for release in {staging_dir_str}\n\n"
-                "Verify the CLI:\n"
-                f"    node {staging_dir_str}/bin/codex.js --version\n"
-                f"    node {staging_dir_str}/bin/codex.js --help\n\n"
-            )
-        else:
-            print(f"Staged package in {staging_dir}")
-
-        if args.pack_output is not None:
-            output_path = run_npm_pack(staging_dir, args.pack_output)
-            print(f"npm pack output written to {output_path}")
-    finally:
-        if created_temp:
-            # Preserve the staging directory for further inspection.
-            pass
-
-    return 0
-
-
-def prepare_staging_dir(staging_dir: Path | None) -> tuple[Path, bool]:
-    if staging_dir is not None:
-        staging_dir = staging_dir.resolve()
-        staging_dir.mkdir(parents=True, exist_ok=True)
-        if any(staging_dir.iterdir()):
-            raise RuntimeError(f"Staging directory {staging_dir} is not empty.")
-        return staging_dir, False
-
-    temp_dir = Path(tempfile.mkdtemp(prefix="codex-npm-stage-"))
-    return temp_dir, True
-
-
-def stage_sources(staging_dir: Path, version: str) -> None:
-    bin_dir = staging_dir / "bin"
-    bin_dir.mkdir(parents=True, exist_ok=True)
-
-    shutil.copy2(CODEX_CLI_ROOT / "bin" / "codex.js", bin_dir / "codex.js")
-    rg_manifest = CODEX_CLI_ROOT / "bin" / "rg"
-    if rg_manifest.exists():
-        shutil.copy2(rg_manifest, bin_dir / "rg")
-
-    readme_src = REPO_ROOT / "README.md"
-    if readme_src.exists():
-        shutil.copy2(readme_src, staging_dir / "README.md")
-
-    with open(CODEX_CLI_ROOT / "package.json", "r", encoding="utf-8") as fh:
-        package_json = json.load(fh)
-    package_json["version"] = version
-
-    with open(staging_dir / "package.json", "w", encoding="utf-8") as out:
-        json.dump(package_json, out, indent=2)
-        out.write("\n")
-
-
-def install_native_binaries(staging_dir: Path, workflow_url: str | None) -> None:
-    cmd = ["./scripts/install_native_deps.py"]
-    if workflow_url:
-        cmd.extend(["--workflow-url", workflow_url])
-    cmd.append(str(staging_dir))
-    subprocess.check_call(cmd, cwd=CODEX_CLI_ROOT)
-
-
-def resolve_latest_alpha_workflow_url() -> str:
-    version = determine_latest_alpha_version()
-    workflow_url = fetch_workflow_url_for_version(version)
-    if not workflow_url:
-        raise RuntimeError(f"Unable to locate workflow for version {version}.")
-    return workflow_url
-
-
-def determine_latest_alpha_version() -> str:
-    releases = list_releases()
-    best_key: tuple[int, int, int, int] | None = None
-    best_version: str | None = None
-    pattern = re.compile(r"^rust-v(\d+)\.(\d+)\.(\d+)-alpha\.(\d+)$")
-    for release in releases:
-        tag = release.get("tag_name", "")
-        match = pattern.match(tag)
-        if not match:
-            continue
-        key = tuple(int(match.group(i)) for i in range(1, 5))
-        if best_key is None or key > best_key:
-            best_key = key
-            best_version = (
-                f"{match.group(1)}.{match.group(2)}.{match.group(3)}-alpha.{match.group(4)}"
-            )
-
-    if best_version is None:
-        raise RuntimeError("No alpha releases found when resolving workflow URL.")
-    return best_version
-
-
-def list_releases() -> list[dict]:
-    stdout = subprocess.check_output(
-        ["gh", "api", f"/repos/{GITHUB_REPO}/releases?per_page=100"],
-        text=True,
-    )
-    try:
-        releases = json.loads(stdout or "[]")
-    except json.JSONDecodeError as exc:
-        raise RuntimeError("Unable to parse releases JSON.") from exc
-    if not isinstance(releases, list):
-        raise RuntimeError("Unexpected response when listing releases.")
-    return releases
-
-
-def fetch_workflow_url_for_version(version: str) -> str | None:
-    ref = f"rust-v{version}"
-    stdout = subprocess.check_output(
-        [
-            "gh",
-            "run",
-            "list",
-            "--branch",
-            ref,
-            "--limit",
-            "20",
-            "--json",
-            "workflowName,url",
-        ],
-        text=True,
-    )
-
-    try:
-        runs = json.loads(stdout or "[]")
-    except json.JSONDecodeError as exc:
-        raise RuntimeError("Unable to parse workflow run listing.") from exc
-
-    for run in runs:
-        if run.get("workflowName") == "rust-release":
-            url = run.get("url")
-            if url:
-                return url
-    return None
-
-
-def resolve_release_workflow(version: str) -> dict:
-    stdout = subprocess.check_output(
-        [
-            "gh",
-            "run",
-            "list",
-            "--branch",
-            f"rust-v{version}",
-            "--json",
-            "workflowName,url,headSha",
-            "--jq",
-            'first(.[] | select(.workflowName == "rust-release"))',
-        ],
-        text=True,
-    )
-    workflow = json.loads(stdout)
-    if not workflow:
-        raise RuntimeError(f"Unable to find rust-release workflow for version {version}.")
-    return workflow
-
-
-def run_npm_pack(staging_dir: Path, output_path: Path) -> Path:
-    output_path = output_path.resolve()
-    output_path.parent.mkdir(parents=True, exist_ok=True)
-
-    with tempfile.TemporaryDirectory(prefix="codex-npm-pack-") as pack_dir_str:
-        pack_dir = Path(pack_dir_str)
-        stdout = subprocess.check_output(
-            ["npm", "pack", "--json", "--pack-destination", str(pack_dir)],
-            cwd=staging_dir,
-            text=True,
-        )
-        try:
-            pack_output = json.loads(stdout)
-        except json.JSONDecodeError as exc:
-            raise RuntimeError("Failed to parse npm pack output.") from exc
-
-        if not pack_output:
-            raise RuntimeError("npm pack did not produce an output tarball.")
-
-        tarball_name = pack_output[0].get("filename") or pack_output[0].get("name")
-        if not tarball_name:
-            raise RuntimeError("Unable to determine npm pack output filename.")
-
-        tarball_path = pack_dir / tarball_name
-        if not tarball_path.exists():
-            raise RuntimeError(f"Expected npm pack output not found: {tarball_path}")
-
-        shutil.move(str(tarball_path), output_path)
-
-    return output_path
-
-
-if __name__ == "__main__":
-    import sys
-
-    sys.exit(main())

codex-cli/scripts/install_native_deps.py

@@ -1,318 +0,0 @@
-#!/usr/bin/env python3
-"""Install Codex native binaries (Rust CLI plus ripgrep helpers)."""
-
-import argparse
-import json
-import os
-import shutil
-import subprocess
-import tarfile
-import tempfile
-import zipfile
-from concurrent.futures import ThreadPoolExecutor, as_completed
-from pathlib import Path
-from typing import Iterable, Sequence
-from urllib.parse import urlparse
-from urllib.request import urlopen
-
-SCRIPT_DIR = Path(__file__).resolve().parent
-CODEX_CLI_ROOT = SCRIPT_DIR.parent
-DEFAULT_WORKFLOW_URL = "https://github.com/openai/codex/actions/runs/17952349351"  # rust-v0.40.0
-VENDOR_DIR_NAME = "vendor"
-RG_MANIFEST = CODEX_CLI_ROOT / "bin" / "rg"
-CODEX_TARGETS = (
-    "x86_64-unknown-linux-musl",
-    "aarch64-unknown-linux-musl",
-    "x86_64-apple-darwin",
-    "aarch64-apple-darwin",
-    "x86_64-pc-windows-msvc",
-    "aarch64-pc-windows-msvc",
-)
-
-RG_TARGET_PLATFORM_PAIRS: list[tuple[str, str]] = [
-    ("x86_64-unknown-linux-musl", "linux-x86_64"),
-    ("aarch64-unknown-linux-musl", "linux-aarch64"),
-    ("x86_64-apple-darwin", "macos-x86_64"),
-    ("aarch64-apple-darwin", "macos-aarch64"),
-    ("x86_64-pc-windows-msvc", "windows-x86_64"),
-    ("aarch64-pc-windows-msvc", "windows-aarch64"),
-]
-RG_TARGET_TO_PLATFORM = {target: platform for target, platform in RG_TARGET_PLATFORM_PAIRS}
-DEFAULT_RG_TARGETS = [target for target, _ in RG_TARGET_PLATFORM_PAIRS]
-
-
-def parse_args() -> argparse.Namespace:
-    parser = argparse.ArgumentParser(description="Install native Codex binaries.")
-    parser.add_argument(
-        "--workflow-url",
-        help=(
-            "GitHub Actions workflow URL that produced the artifacts. Defaults to a "
-            "known good run when omitted."
-        ),
-    )
-    parser.add_argument(
-        "root",
-        nargs="?",
-        type=Path,
-        help=(
-            "Directory containing package.json for the staged package. If omitted, the "
-            "repository checkout is used."
-        ),
-    )
-    return parser.parse_args()
-
-
-def main() -> int:
-    args = parse_args()
-
-    codex_cli_root = (args.root or CODEX_CLI_ROOT).resolve()
-    vendor_dir = codex_cli_root / VENDOR_DIR_NAME
-    vendor_dir.mkdir(parents=True, exist_ok=True)
-
-    workflow_url = (args.workflow_url or DEFAULT_WORKFLOW_URL).strip()
-    if not workflow_url:
-        workflow_url = DEFAULT_WORKFLOW_URL
-
-    workflow_id = workflow_url.rstrip("/").split("/")[-1]
-
-    with tempfile.TemporaryDirectory(prefix="codex-native-artifacts-") as artifacts_dir_str:
-        artifacts_dir = Path(artifacts_dir_str)
-        _download_artifacts(workflow_id, artifacts_dir)
-        install_codex_binaries(artifacts_dir, vendor_dir, CODEX_TARGETS)
-
-    fetch_rg(vendor_dir, DEFAULT_RG_TARGETS, manifest_path=RG_MANIFEST)
-
-    print(f"Installed native dependencies into {vendor_dir}")
-    return 0
-
-
-def fetch_rg(
-    vendor_dir: Path,
-    targets: Sequence[str] | None = None,
-    *,
-    manifest_path: Path,
-) -> list[Path]:
-    """Download ripgrep binaries described by the DotSlash manifest."""
-
-    if targets is None:
-        targets = DEFAULT_RG_TARGETS
-
-    if not manifest_path.exists():
-        raise FileNotFoundError(f"DotSlash manifest not found: {manifest_path}")
-
-    manifest = _load_manifest(manifest_path)
-    platforms = manifest.get("platforms", {})
-
-    vendor_dir.mkdir(parents=True, exist_ok=True)
-
-    targets = list(targets)
-    if not targets:
-        return []
-
-    task_configs: list[tuple[str, str, dict]] = []
-    for target in targets:
-        platform_key = RG_TARGET_TO_PLATFORM.get(target)
-        if platform_key is None:
-            raise ValueError(f"Unsupported ripgrep target '{target}'.")
-
-        platform_info = platforms.get(platform_key)
-        if platform_info is None:
-            raise RuntimeError(f"Platform '{platform_key}' not found in manifest {manifest_path}.")
-
-        task_configs.append((target, platform_key, platform_info))
-
-    results: dict[str, Path] = {}
-    max_workers = min(len(task_configs), max(1, (os.cpu_count() or 1)))
-
-    with ThreadPoolExecutor(max_workers=max_workers) as executor:
-        future_map = {
-            executor.submit(
-                _fetch_single_rg,
-                vendor_dir,
-                target,
-                platform_key,
-                platform_info,
-                manifest_path,
-            ): target
-            for target, platform_key, platform_info in task_configs
-        }
-
-        for future in as_completed(future_map):
-            target = future_map[future]
-            results[target] = future.result()
-
-    return [results[target] for target in targets]
-
-
-def _download_artifacts(workflow_id: str, dest_dir: Path) -> None:
-    cmd = [
-        "gh",
-        "run",
-        "download",
-        "--dir",
-        str(dest_dir),
-        "--repo",
-        "openai/codex",
-        workflow_id,
-    ]
-    subprocess.check_call(cmd)
-
-
-def install_codex_binaries(
-    artifacts_dir: Path, vendor_dir: Path, targets: Iterable[str]
-) -> list[Path]:
-    targets = list(targets)
-    if not targets:
-        return []
-
-    results: dict[str, Path] = {}
-    max_workers = min(len(targets), max(1, (os.cpu_count() or 1)))
-
-    with ThreadPoolExecutor(max_workers=max_workers) as executor:
-        future_map = {
-            executor.submit(_install_single_codex_binary, artifacts_dir, vendor_dir, target): target
-            for target in targets
-        }
-
-        for future in as_completed(future_map):
-            target = future_map[future]
-            results[target] = future.result()
-
-    return [results[target] for target in targets]
-
-
-def _install_single_codex_binary(artifacts_dir: Path, vendor_dir: Path, target: str) -> Path:
-    artifact_subdir = artifacts_dir / target
-    archive_name = _archive_name_for_target(target)
-    archive_path = artifact_subdir / archive_name
-    if not archive_path.exists():
-        raise FileNotFoundError(f"Expected artifact not found: {archive_path}")
-
-    dest_dir = vendor_dir / target / "codex"
-    dest_dir.mkdir(parents=True, exist_ok=True)
-
-    binary_name = "codex.exe" if "windows" in target else "codex"
-    dest = dest_dir / binary_name
-    dest.unlink(missing_ok=True)
-    extract_archive(archive_path, "zst", None, dest)
-    if "windows" not in target:
-        dest.chmod(0o755)
-    return dest
-
-
-def _archive_name_for_target(target: str) -> str:
-    if "windows" in target:
-        return f"codex-{target}.exe.zst"
-    return f"codex-{target}.zst"
-
-
-def _fetch_single_rg(
-    vendor_dir: Path,
-    target: str,
-    platform_key: str,
-    platform_info: dict,
-    manifest_path: Path,
-) -> Path:
-    providers = platform_info.get("providers", [])
-    if not providers:
-        raise RuntimeError(f"No providers listed for platform '{platform_key}' in {manifest_path}.")
-
-    url = providers[0]["url"]
-    archive_format = platform_info.get("format", "zst")
-    archive_member = platform_info.get("path")
-
-    dest_dir = vendor_dir / target / "path"
-    dest_dir.mkdir(parents=True, exist_ok=True)
-
-    is_windows = platform_key.startswith("win")
-    binary_name = "rg.exe" if is_windows else "rg"
-    dest = dest_dir / binary_name
-
-    with tempfile.TemporaryDirectory() as tmp_dir_str:
-        tmp_dir = Path(tmp_dir_str)
-        archive_filename = os.path.basename(urlparse(url).path)
-        download_path = tmp_dir / archive_filename
-        _download_file(url, download_path)
-
-        dest.unlink(missing_ok=True)
-        extract_archive(download_path, archive_format, archive_member, dest)
-
-    if not is_windows:
-        dest.chmod(0o755)
-
-    return dest
-
-
-def _download_file(url: str, dest: Path) -> None:
-    dest.parent.mkdir(parents=True, exist_ok=True)
-    with urlopen(url) as response, open(dest, "wb") as out:
-        shutil.copyfileobj(response, out)
-
-
-def extract_archive(
-    archive_path: Path,
-    archive_format: str,
-    archive_member: str | None,
-    dest: Path,
-) -> None:
-    dest.parent.mkdir(parents=True, exist_ok=True)
-
-    if archive_format == "zst":
-        output_path = archive_path.parent / dest.name
-        subprocess.check_call(
-            ["zstd", "-f", "-d", str(archive_path), "-o", str(output_path)]
-        )
-        shutil.move(str(output_path), dest)
-        return
-
-    if archive_format == "tar.gz":
-        if not archive_member:
-            raise RuntimeError("Missing 'path' for tar.gz archive in DotSlash manifest.")
-        with tarfile.open(archive_path, "r:gz") as tar:
-            try:
-                member = tar.getmember(archive_member)
-            except KeyError as exc:
-                raise RuntimeError(
-                    f"Entry '{archive_member}' not found in archive {archive_path}."
-                ) from exc
-            tar.extract(member, path=archive_path.parent, filter="data")
-        extracted = archive_path.parent / archive_member
-        shutil.move(str(extracted), dest)
-        return
-
-    if archive_format == "zip":
-        if not archive_member:
-            raise RuntimeError("Missing 'path' for zip archive in DotSlash manifest.")
-        with zipfile.ZipFile(archive_path) as archive:
-            try:
-                with archive.open(archive_member) as src, open(dest, "wb") as out:
-                    shutil.copyfileobj(src, out)
-            except KeyError as exc:
-                raise RuntimeError(
-                    f"Entry '{archive_member}' not found in archive {archive_path}."
-                ) from exc
-        return
-
-    raise RuntimeError(f"Unsupported archive format '{archive_format}'.")
-
-
-def _load_manifest(manifest_path: Path) -> dict:
-    cmd = ["dotslash", "--", "parse", str(manifest_path)]
-    stdout = subprocess.check_output(cmd, text=True)
-    try:
-        manifest = json.loads(stdout)
-    except json.JSONDecodeError as exc:
-        raise RuntimeError(f"Invalid DotSlash manifest output from {manifest_path}.") from exc
-
-    if not isinstance(manifest, dict):
-        raise RuntimeError(
-            f"Unexpected DotSlash manifest structure for {manifest_path}: {type(manifest)!r}"
-        )
-
-    return manifest
-
-
-if __name__ == "__main__":
-    import sys
-
-    sys.exit(main())

codex-cli/scripts/install_native_deps.sh

@@ -0,0 +1,94 @@
+#!/usr/bin/env bash
+
+# Install native runtime dependencies for codex-cli.
+#
+# Usage
+#   install_native_deps.sh [--workflow-url URL] [CODEX_CLI_ROOT]
+#
+# The optional RELEASE_ROOT is the path that contains package.json.  Omitting
+# it installs the binaries into the repository's own bin/ folder to support
+# local development.
+
+set -euo pipefail
+
+# ------------------
+# Parse arguments
+# ------------------
+
+CODEX_CLI_ROOT=""
+
+# Until we start publishing stable GitHub releases, we have to grab the binaries
+# from the GitHub Action that created them. Update the URL below to point to the
+# appropriate workflow run:
+WORKFLOW_URL="https://github.com/openai/codex/actions/runs/17417194663" # rust-v0.28.0
+
+while [[ $# -gt 0 ]]; do
+  case "$1" in
+    --workflow-url)
+      shift || { echo "--workflow-url requires an argument"; exit 1; }
+      if [ -n "$1" ]; then
+        WORKFLOW_URL="$1"
+      fi
+      ;;
+    *)
+      if [[ -z "$CODEX_CLI_ROOT" ]]; then
+        CODEX_CLI_ROOT="$1"
+      else
+        echo "Unexpected argument: $1" >&2
+        exit 1
+      fi
+      ;;
+  esac
+  shift
+done
+
+# ----------------------------------------------------------------------------
+# Determine where the binaries should be installed.
+# ----------------------------------------------------------------------------
+
+if [ -n "$CODEX_CLI_ROOT" ]; then
+  # The caller supplied a release root directory.
+  BIN_DIR="$CODEX_CLI_ROOT/bin"
+else
+  # No argument; fall back to the repo’s own bin directory.
+  # Resolve the path of this script, then walk up to the repo root.
+  SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+  CODEX_CLI_ROOT="$(cd "$SCRIPT_DIR/.." && pwd)"
+  BIN_DIR="$CODEX_CLI_ROOT/bin"
+fi
+
+# Make sure the destination directory exists.
+mkdir -p "$BIN_DIR"
+
+# ----------------------------------------------------------------------------
+# Download and decompress the artifacts from the GitHub Actions workflow.
+# ----------------------------------------------------------------------------
+
+WORKFLOW_ID="${WORKFLOW_URL##*/}"
+
+ARTIFACTS_DIR="$(mktemp -d)"
+trap 'rm -rf "$ARTIFACTS_DIR"' EXIT
+
+# NB: The GitHub CLI `gh` must be installed and authenticated.
+gh run download --dir "$ARTIFACTS_DIR" --repo openai/codex "$WORKFLOW_ID"
+
+# x64 Linux
+zstd -d "$ARTIFACTS_DIR/x86_64-unknown-linux-musl/codex-x86_64-unknown-linux-musl.zst" \
+    -o "$BIN_DIR/codex-x86_64-unknown-linux-musl"
+# ARM64 Linux
+zstd -d "$ARTIFACTS_DIR/aarch64-unknown-linux-musl/codex-aarch64-unknown-linux-musl.zst" \
+    -o "$BIN_DIR/codex-aarch64-unknown-linux-musl"
+# x64 macOS
+zstd -d "$ARTIFACTS_DIR/x86_64-apple-darwin/codex-x86_64-apple-darwin.zst" \
+    -o "$BIN_DIR/codex-x86_64-apple-darwin"
+# ARM64 macOS
+zstd -d "$ARTIFACTS_DIR/aarch64-apple-darwin/codex-aarch64-apple-darwin.zst" \
+    -o "$BIN_DIR/codex-aarch64-apple-darwin"
+# x64 Windows
+zstd -d "$ARTIFACTS_DIR/x86_64-pc-windows-msvc/codex-x86_64-pc-windows-msvc.exe.zst" \
+    -o "$BIN_DIR/codex-x86_64-pc-windows-msvc.exe"
+# ARM64 Windows
+zstd -d "$ARTIFACTS_DIR/aarch64-pc-windows-msvc/codex-aarch64-pc-windows-msvc.exe.zst" \
+    -o "$BIN_DIR/codex-aarch64-pc-windows-msvc.exe"
+
+echo "Installed native dependencies into $BIN_DIR"

codex-cli/scripts/stage_release.sh

@@ -0,0 +1,120 @@
+#!/usr/bin/env bash
+# -----------------------------------------------------------------------------
+# stage_release.sh
+# -----------------------------------------------------------------------------
+# Stages an npm release for @openai/codex.
+#
+# Usage:
+#
+#   --tmp <dir>  : Use <dir> instead of a freshly created temp directory.
+#   -h|--help    : Print usage.
+#
+# -----------------------------------------------------------------------------
+
+set -euo pipefail
+
+# Helper - usage / flag parsing
+
+usage() {
+  cat <<EOF
+Usage: $(basename "$0") [--tmp DIR] [--version VERSION]
+
+Options
+  --tmp DIR   Use DIR to stage the release (defaults to a fresh mktemp dir)
+  --version   Specify the version to release (defaults to a timestamp-based version)
+  -h, --help  Show this help
+
+Legacy positional argument: the first non-flag argument is still interpreted
+as the temporary directory (for backwards compatibility) but is deprecated.
+EOF
+  exit "${1:-0}"
+}
+
+TMPDIR=""
+# Default to a timestamp-based version (keep same scheme as before)
+VERSION="$(printf '0.1.%d' "$(date +%y%m%d%H%M)")"
+WORKFLOW_URL=""
+
+# Manual flag parser - Bash getopts does not handle GNU long options well.
+while [[ $# -gt 0 ]]; do
+  case "$1" in
+    --tmp)
+      shift || { echo "--tmp requires an argument"; usage 1; }
+      TMPDIR="$1"
+      ;;
+    --tmp=*)
+      TMPDIR="${1#*=}"
+      ;;
+    --version)
+      shift || { echo "--version requires an argument"; usage 1; }
+      VERSION="$1"
+      ;;
+    --workflow-url)
+      shift || { echo "--workflow-url requires an argument"; exit 1; }
+      WORKFLOW_URL="$1"
+      ;;
+    -h|--help)
+      usage 0
+      ;;
+    --*)
+      echo "Unknown option: $1" >&2
+      usage 1
+      ;;
+    *)
+      echo "Unexpected extra argument: $1" >&2
+      usage 1
+      ;;
+  esac
+  shift
+done
+
+# Fallback when the caller did not specify a directory.
+# If no directory was specified create a fresh temporary one.
+if [[ -z "$TMPDIR" ]]; then
+  TMPDIR="$(mktemp -d)"
+fi
+
+# Ensure the directory exists, then resolve to an absolute path.
+mkdir -p "$TMPDIR"
+TMPDIR="$(cd "$TMPDIR" && pwd)"
+
+# Main build logic
+
+echo "Staging release in $TMPDIR"
+
+# The script lives in codex-cli/scripts/ - change into codex-cli root so that
+# relative paths keep working.
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+CODEX_CLI_ROOT="$(cd "$SCRIPT_DIR/.." && pwd)"
+
+pushd "$CODEX_CLI_ROOT" >/dev/null
+
+# 1. Build the JS artifacts ---------------------------------------------------
+
+# Paths inside the staged package
+mkdir -p "$TMPDIR/bin"
+
+cp -r bin/codex.js "$TMPDIR/bin/codex.js"
+cp ../README.md "$TMPDIR" || true # README is one level up - ignore if missing
+
+# Modify package.json - bump version and optionally add the native directory to
+# the files array so that the binaries are published to npm.
+
+jq --arg version "$VERSION" \
+    '.version = $version' \
+    package.json > "$TMPDIR/package.json"
+
+# 2. Native runtime deps (sandbox plus optional Rust binaries)
+
+./scripts/install_native_deps.sh --workflow-url "$WORKFLOW_URL" "$TMPDIR"
+
+popd >/dev/null
+
+echo "Staged version $VERSION for release in $TMPDIR"
+
+echo "Verify the CLI:"
+echo "    node ${TMPDIR}/bin/codex.js --version"
+echo "    node ${TMPDIR}/bin/codex.js --help"
+
+# Print final hint for convenience
+echo "Next:  cd \"$TMPDIR\" && npm publish"

codex-cli/scripts/stage_rust_release.py

@@ -0,0 +1,70 @@
+#!/usr/bin/env python3
+
+import json
+import subprocess
+import sys
+import argparse
+from pathlib import Path
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser(
+        description="""Stage a release for the npm module.
+
+Run this after the GitHub Release has been created and use
+`--release-version` to specify the version to release.
+
+Optionally pass `--tmp` to control the temporary staging directory that will be
+forwarded to stage_release.sh.
+"""
+    )
+    parser.add_argument(
+        "--release-version", required=True, help="Version to release, e.g., 0.3.0"
+    )
+    parser.add_argument(
+        "--tmp",
+        help="Optional path to stage the npm package; forwarded to stage_release.sh",
+    )
+    args = parser.parse_args()
+    version = args.release_version
+
+    gh_run = subprocess.run(
+        [
+            "gh",
+            "run",
+            "list",
+            "--branch",
+            f"rust-v{version}",
+            "--json",
+            "workflowName,url,headSha",
+            "--jq",
+            'first(.[] | select(.workflowName == "rust-release"))',
+        ],
+        stdout=subprocess.PIPE,
+        check=True,
+    )
+    gh_run.check_returncode()
+    workflow = json.loads(gh_run.stdout)
+    sha = workflow["headSha"]
+
+    print(f"should `git checkout {sha}`")
+
+    current_dir = Path(__file__).parent.resolve()
+    cmd = [
+        str(current_dir / "stage_release.sh"),
+        "--version",
+        version,
+        "--workflow-url",
+        workflow["url"],
+    ]
+    if args.tmp:
+        cmd.extend(["--tmp", args.tmp])
+
+    stage_release = subprocess.run(cmd)
+    stage_release.check_returncode()
+
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

codex-rs/Cargo.lock

@@ -316,17 +316,6 @@ dependencies = [
  "syn 2.0.104",
 ]
 
-[[package]]
-name = "async-trait"
-version = "0.1.89"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9035ad2d096bed7955a320ee7e2230574d28fd3c3a0f186cbea1ff3c7eed5dbb"
-dependencies = [
- "proc-macro2",
- "quote",
- "syn 2.0.104",
-]
-
 [[package]]
 name = "atomic-waker"
 version = "1.1.2"
@@ -649,11 +638,9 @@ dependencies = [
  "codex-protocol",
  "codex-protocol-ts",
  "codex-tui",
- "owo-colors",
  "predicates",
  "pretty_assertions",
  "serde_json",
- "supports-color",
  "tempfile",
  "tokio",
  "tracing",
@@ -700,7 +687,7 @@ dependencies = [
  "portable-pty",
  "predicates",
  "pretty_assertions",
- "rand",
+ "rand 0.9.2",
  "regex-lite",
  "reqwest",
  "seccompiler",
@@ -789,16 +776,6 @@ dependencies = [
  "tokio",
 ]
 
-[[package]]
-name = "codex-git-tooling"
-version = "0.0.0"
-dependencies = [
- "pretty_assertions",
- "tempfile",
- "thiserror 2.0.16",
- "walkdir",
-]
-
 [[package]]
 name = "codex-linux-sandbox"
 version = "0.0.0"
@@ -816,13 +793,11 @@ dependencies = [
 name = "codex-login"
 version = "0.0.0"
 dependencies = [
- "anyhow",
  "base64",
  "chrono",
  "codex-core",
  "codex-protocol",
- "core_test_support",
- "rand",
+ "rand 0.8.5",
  "reqwest",
  "serde",
  "serde_json",
@@ -860,7 +835,6 @@ dependencies = [
  "codex-core",
  "codex-login",
  "codex-protocol",
- "core_test_support",
  "mcp-types",
  "mcp_test_support",
  "os_info",
@@ -897,7 +871,6 @@ dependencies = [
 name = "codex-protocol"
 version = "0.0.0"
 dependencies = [
- "anyhow",
  "base64",
  "icu_decimal",
  "icu_locale_core",
@@ -942,7 +915,6 @@ dependencies = [
  "codex-common",
  "codex-core",
  "codex-file-search",
- "codex-git-tooling",
  "codex-login",
  "codex-ollama",
  "codex-protocol",
@@ -957,11 +929,12 @@ dependencies = [
  "libc",
  "mcp-types",
  "once_cell",
+ "owo-colors",
  "path-clean",
  "pathdiff",
  "pretty_assertions",
  "pulldown-cmark",
- "rand",
+ "rand 0.9.2",
  "ratatui",
  "regex-lite",
  "serde",
@@ -983,16 +956,6 @@ dependencies = [
  "vt100",
 ]
 
-[[package]]
-name = "codex-utils-readiness"
-version = "0.0.0"
-dependencies = [
- "async-trait",
- "thiserror 2.0.16",
- "time",
- "tokio",
-]
-
 [[package]]
 name = "color-eyre"
 version = "0.6.5"
@@ -1110,7 +1073,6 @@ checksum = "773648b94d0e5d620f64f280777445740e61fe701025087ec8b57f45c791888b"
 name = "core_test_support"
 version = "0.0.0"
 dependencies = [
- "anyhow",
  "codex-core",
  "serde_json",
  "tempfile",
@@ -1288,12 +1250,12 @@ dependencies = [
 
 [[package]]
 name = "deranged"
-version = "0.5.4"
+version = "0.4.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a41953f86f8a05768a6cda24def994fd2f424b04ec5c719cf89989779f199071"
+checksum = "9c9e6a11ca8224451684bc0d7d5a7adbf8f2fd6887261a1cfc3c0432f9d4068e"
 dependencies = [
  "powerfmt",
- "serde_core",
+ "serde",
 ]
 
 [[package]]
@@ -2693,9 +2655,9 @@ dependencies = [
 
 [[package]]
 name = "log"
-version = "0.4.28"
+version = "0.4.27"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "34080505efa8e45a4b816c349525ebe327ceaa8559756f0356cba97ef3bf7432"
+checksum = "13dc2df351e3202783a1fe0d44375f7295ffb4049267b0f3018346dc122a1d94"
 
 [[package]]
 name = "logos"
@@ -3490,14 +3452,35 @@ dependencies = [
  "nibble_vec",
 ]
 
+[[package]]
+name = "rand"
+version = "0.8.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "34af8d1a0e25924bc5b7c43c079c942339d8f0a8b57c39049bef581b46327404"
+dependencies = [
+ "libc",
+ "rand_chacha 0.3.1",
+ "rand_core 0.6.4",
+]
+
 [[package]]
 name = "rand"
 version = "0.9.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "6db2770f06117d490610c7488547d543617b21bfa07796d7a12f6f1bd53850d1"
 dependencies = [
- "rand_chacha",
- "rand_core",
+ "rand_chacha 0.9.0",
+ "rand_core 0.9.3",
+]
+
+[[package]]
+name = "rand_chacha"
+version = "0.3.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e6c10a63a0fa32252be49d21e7709d4d4baf8d231c2dbce1eaa8141b9b127d88"
+dependencies = [
+ "ppv-lite86",
+ "rand_core 0.6.4",
 ]
 
 [[package]]
@@ -3507,7 +3490,16 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "d3022b5f1df60f26e1ffddd6c66e8aa15de382ae63b3a0c1bfc0e4d3e3f325cb"
 dependencies = [
  "ppv-lite86",
- "rand_core",
+ "rand_core 0.9.3",
+]
+
+[[package]]
+name = "rand_core"
+version = "0.6.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ec0be4795e2f6a28069bec0b5ff3e2ac9bafc99e6a9a7dc3547996c5c816922c"
+dependencies = [
+ "getrandom 0.2.16",
 ]
 
 [[package]]
@@ -3936,9 +3928,9 @@ dependencies = [
 
 [[package]]
 name = "serde"
-version = "1.0.226"
+version = "1.0.224"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0dca6411025b24b60bfa7ec1fe1f8e710ac09782dca409ee8237ba74b51295fd"
+checksum = "6aaeb1e94f53b16384af593c71e20b095e958dab1d26939c1b70645c5cfbcc0b"
 dependencies = [
  "serde_core",
  "serde_derive",
@@ -3946,18 +3938,18 @@ dependencies = [
 
 [[package]]
 name = "serde_core"
-version = "1.0.226"
+version = "1.0.224"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ba2ba63999edb9dac981fb34b3e5c0d111a69b0924e253ed29d83f7c99e966a4"
+checksum = "32f39390fa6346e24defbcdd3d9544ba8a19985d0af74df8501fbfe9a64341ab"
 dependencies = [
  "serde_derive",
 ]
 
 [[package]]
 name = "serde_derive"
-version = "1.0.226"
+version = "1.0.224"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8db53ae22f34573731bafa1db20f04027b2d25e02d8205921b569171699cdb33"
+checksum = "87ff78ab5e8561c9a675bfc1785cb07ae721f0ee53329a595cefd8c04c2ac4e0"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -4460,15 +4452,15 @@ dependencies = [
 
 [[package]]
 name = "tempfile"
-version = "3.23.0"
+version = "3.20.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2d31c77bdf42a745371d260a26ca7163f1e0924b64afa0b688e61b5a9fa02f16"
+checksum = "e8a64e3985349f2441a1a9ef0b853f869006c3855f2cda6862a94d26ebb9d6a1"
 dependencies = [
  "fastrand",
  "getrandom 0.3.3",
  "once_cell",
  "rustix 1.0.8",
- "windows-sys 0.60.2",
+ "windows-sys 0.59.0",
 ]
 
 [[package]]
@@ -4592,9 +4584,9 @@ dependencies = [
 
 [[package]]
 name = "time"
-version = "0.3.44"
+version = "0.3.41"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "91e7d9e3bb61134e77bde20dd4825b97c010155709965fedf0f49bb138e52a9d"
+checksum = "8a7619e19bc266e0f9c5e6686659d394bc57973859340060a69221e57dbc0c40"
 dependencies = [
  "deranged",
  "itoa",
@@ -4609,15 +4601,15 @@ dependencies = [
 
 [[package]]
 name = "time-core"
-version = "0.1.6"
+version = "0.1.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "40868e7c1d2f0b8d73e4a8c7f0ff63af4f6d19be117e90bd73eb1d62cf831c6b"
+checksum = "c9e9a38711f559d9e3ce1cdb06dd7c5b8ea546bc90052da6d06bb76da74bb07c"
 
 [[package]]
 name = "time-macros"
-version = "0.2.24"
+version = "0.2.22"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "30cfb0125f12d9c277f35663a0a33f8c30190f4e4574868a330595412d34ebf3"
+checksum = "3526739392ec93fd8b359c8e98514cb3e8e021beb4e5f597b00a0221f8ed8a49"
 dependencies = [
  "num-conv",
  "time-core",

codex-rs/Cargo.toml

@@ -9,7 +9,6 @@ members = [
     "exec",
     "execpolicy",
     "file-search",
-    "git-tooling",
     "linux-sandbox",
     "login",
     "mcp-client",
@@ -19,7 +18,6 @@ members = [
     "protocol",
     "protocol-ts",
     "tui",
-    "utils/readiness",
 ]
 resolver = "2"
 
@@ -31,170 +29,15 @@ version = "0.0.0"
 # edition.
 edition = "2024"
 
-[workspace.dependencies]
-# Internal
-codex-ansi-escape = { path = "ansi-escape" }
-codex-apply-patch = { path = "apply-patch" }
-codex-arg0 = { path = "arg0" }
-codex-chatgpt = { path = "chatgpt" }
-codex-common = { path = "common" }
-codex-core = { path = "core" }
-codex-exec = { path = "exec" }
-codex-file-search = { path = "file-search" }
-codex-git-tooling = { path = "git-tooling" }
-codex-linux-sandbox = { path = "linux-sandbox" }
-codex-login = { path = "login" }
-codex-mcp-client = { path = "mcp-client" }
-codex-mcp-server = { path = "mcp-server" }
-codex-ollama = { path = "ollama" }
-codex-protocol = { path = "protocol" }
-codex-protocol-ts = { path = "protocol-ts" }
-codex-tui = { path = "tui" }
-codex-utils-readiness = { path = "utils/readiness" }
-core_test_support = { path = "core/tests/common" }
-mcp-types = { path = "mcp-types" }
-mcp_test_support = { path = "mcp-server/tests/common" }
-
-# External
-allocative = "0.3.3"
-ansi-to-tui = "7.0.0"
-anyhow = "1"
-arboard = "3"
-askama = "0.12"
-assert_cmd = "2"
-async-channel = "2.3.1"
-async-stream = "0.3.6"
-async-trait = "0.1.89"
-base64 = "0.22.1"
-bytes = "1.10.1"
-chrono = "0.4.40"
-clap = "4"
-clap_complete = "4"
-color-eyre = "0.6.3"
-crossterm = "0.28.1"
-derive_more = "2"
-diffy = "0.4.2"
-dirs = "6"
-dotenvy = "0.15.7"
-env-flags = "0.1.1"
-env_logger = "0.11.5"
-eventsource-stream = "0.2.3"
-futures = "0.3"
-icu_decimal = "2.0.0"
-icu_locale_core = "2.0.0"
-ignore = "0.4.23"
-image = { version = "^0.25.8", default-features = false }
-insta = "1.43.2"
-itertools = "0.14.0"
-landlock = "0.4.1"
-lazy_static = "1"
-libc = "0.2.175"
-log = "0.4"
-maplit = "1.0.2"
-mime_guess = "2.0.5"
-multimap = "0.10.0"
-nucleo-matcher = "0.3.1"
-once_cell = "1"
-openssl-sys = "*"
-os_info = "3.12.0"
-owo-colors = "4.2.0"
-path-absolutize = "3.1.1"
-path-clean = "1.0.1"
-pathdiff = "0.2"
-portable-pty = "0.9.0"
-predicates = "3"
-pretty_assertions = "1.4.1"
-pulldown-cmark = "0.10"
-rand = "0.9"
-ratatui = "0.29.0"
-regex-lite = "0.1.7"
-reqwest = "0.12"
-schemars = "0.8.22"
-seccompiler = "0.5.0"
-serde = "1"
-serde_json = "1"
-serde_with = "3.14"
-sha1 = "0.10.6"
-sha2 = "0.10"
-shlex = "1.3.0"
-similar = "2.7.0"
-starlark = "0.13.0"
-strum = "0.27.2"
-strum_macros = "0.27.2"
-supports-color = "3.0.2"
-sys-locale = "0.3.2"
-tempfile = "3.23.0"
-textwrap = "0.16.2"
-thiserror = "2.0.16"
-time = "0.3"
-tiny_http = "0.12"
-tokio = "1"
-tokio-stream = "0.1.17"
-tokio-test = "0.4"
-tokio-util = "0.7.16"
-toml = "0.9.5"
-toml_edit = "0.23.4"
-tracing = "0.1.41"
-tracing-appender = "0.2.3"
-tracing-subscriber = "0.3.20"
-tree-sitter = "0.25.9"
-tree-sitter-bash = "0.25.0"
-ts-rs = "11"
-unicode-segmentation = "1.12.0"
-unicode-width = "0.1"
-url = "2"
-urlencoding = "2.1"
-uuid = "1"
-vt100 = "0.16.2"
-walkdir = "2.5.0"
-webbrowser = "1.0"
-which = "6"
-wildmatch = "2.5.0"
-wiremock = "0.6"
-
 [workspace.lints]
 rust = {}
 
 [workspace.lints.clippy]
 expect_used = "deny"
-identity_op = "deny"
-manual_clamp = "deny"
-manual_filter = "deny"
-manual_find = "deny"
-manual_flatten = "deny"
-manual_map = "deny"
-manual_memcpy = "deny"
-manual_non_exhaustive = "deny"
-manual_ok_or = "deny"
-manual_range_contains = "deny"
-manual_retain = "deny"
-manual_strip = "deny"
-manual_try_fold = "deny"
-manual_unwrap_or = "deny"
-needless_borrow = "deny"
-needless_borrowed_reference = "deny"
-needless_collect = "deny"
-needless_late_init = "deny"
-needless_option_as_deref = "deny"
-needless_question_mark = "deny"
-needless_update = "deny"
 redundant_clone = "deny"
-redundant_closure = "deny"
-redundant_closure_for_method_calls = "deny"
-redundant_static_lifetimes = "deny"
-trivially_copy_pass_by_ref = "deny"
 uninlined_format_args = "deny"
-unnecessary_filter_map = "deny"
-unnecessary_lazy_evaluations = "deny"
-unnecessary_sort_by = "deny"
-unnecessary_to_owned = "deny"
 unwrap_used = "deny"
 
-# cargo-shear cannot see the platform-specific openssl-sys usage, so we
-# silence the false positive here instead of deleting a real dependency.
-[workspace.metadata.cargo-shear]
-ignored = ["openssl-sys", "codex-utils-readiness"]
-
 [profile.release]
 lto = "fat"
 # Because we bundle some of these executables with the TypeScript CLI, we

codex-rs/ansi-escape/Cargo.toml

@@ -8,9 +8,9 @@ name = "codex_ansi_escape"
 path = "src/lib.rs"
 
 [dependencies]
-ansi-to-tui = { workspace = true }
-ratatui = { workspace = true, features = [
+ansi-to-tui = "7.0.0"
+ratatui = { version = "0.29.0", features = [
     "unstable-rendered-line-info",
     "unstable-widget-ref",
 ] }
-tracing = { workspace = true, features = ["log"] }
+tracing = { version = "0.1.41", features = ["log"] }

codex-rs/apply-patch/Cargo.toml

@@ -15,14 +15,14 @@ path = "src/main.rs"
 workspace = true
 
 [dependencies]
-anyhow = { workspace = true }
-similar = { workspace = true }
-thiserror = { workspace = true }
-tree-sitter = { workspace = true }
-tree-sitter-bash = { workspace = true }
-once_cell = { workspace = true }
+anyhow = "1"
+similar = "2.7.0"
+thiserror = "2.0.16"
+tree-sitter = "0.25.9"
+tree-sitter-bash = "0.25.0"
+once_cell = "1"
 
 [dev-dependencies]
-assert_cmd = { workspace = true }
-pretty_assertions = { workspace = true }
-tempfile = { workspace = true }
+assert_cmd = "2"
+pretty_assertions = "1.4.1"
+tempfile = "3.13.0"

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

@@ -648,18 +648,21 @@ fn derive_new_contents_from_chunks(
         }
     };
 
-    let mut original_lines: Vec<String> = original_contents.split('\n').map(String::from).collect();
+    let mut original_lines: Vec<String> = original_contents
+        .split('\n')
+        .map(|s| s.to_string())
+        .collect();
 
     // Drop the trailing empty element that results from the final newline so
     // that line counts match the behaviour of standard `diff`.
-    if original_lines.last().is_some_and(String::is_empty) {
+    if original_lines.last().is_some_and(|s| s.is_empty()) {
         original_lines.pop();
     }
 
     let replacements = compute_replacements(&original_lines, path, chunks)?;
     let new_lines = apply_replacements(original_lines, &replacements);
     let mut new_lines = new_lines;
-    if !new_lines.last().is_some_and(String::is_empty) {
+    if !new_lines.last().is_some_and(|s| s.is_empty()) {
         new_lines.push(String::new());
     }
     let new_contents = new_lines.join("\n");
@@ -703,7 +706,7 @@ fn compute_replacements(
         if chunk.old_lines.is_empty() {
             // Pure addition (no old lines). We'll add them at the end or just
             // before the final empty line if one exists.
-            let insertion_idx = if original_lines.last().is_some_and(String::is_empty) {
+            let insertion_idx = if original_lines.last().is_some_and(|s| s.is_empty()) {
                 original_lines.len() - 1
             } else {
                 original_lines.len()
@@ -729,11 +732,11 @@ fn compute_replacements(
 
         let mut new_slice: &[String] = &chunk.new_lines;
 
-        if found.is_none() && pattern.last().is_some_and(String::is_empty) {
+        if found.is_none() && pattern.last().is_some_and(|s| s.is_empty()) {
             // Retry without the trailing empty line which represents the final
             // newline in the file.
             pattern = &pattern[..pattern.len() - 1];
-            if new_slice.last().is_some_and(String::is_empty) {
+            if new_slice.last().is_some_and(|s| s.is_empty()) {
                 new_slice = &new_slice[..new_slice.len() - 1];
             }
 
@@ -845,7 +848,6 @@ mod tests {
     use super::*;
     use pretty_assertions::assert_eq;
     use std::fs;
-    use std::string::ToString;
     use tempfile::tempdir;
 
     /// Helper to construct a patch with the given body.
@@ -854,7 +856,7 @@ mod tests {
     }
 
     fn strs_to_strings(strs: &[&str]) -> Vec<String> {
-        strs.iter().map(ToString::to_string).collect()
+        strs.iter().map(|s| s.to_string()).collect()
     }
 
     // Test helpers to reduce repetition when building bash -lc heredoc scripts

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

@@ -112,10 +112,9 @@ pub(crate) fn seek_sequence(
 #[cfg(test)]
 mod tests {
     use super::seek_sequence;
-    use std::string::ToString;
 
     fn to_vec(strings: &[&str]) -> Vec<String> {
-        strings.iter().map(ToString::to_string).collect()
+        strings.iter().map(|s| s.to_string()).collect()
     }
 
     #[test]

codex-rs/arg0/Cargo.toml

@@ -11,10 +11,10 @@ path = "src/lib.rs"
 workspace = true
 
 [dependencies]
-anyhow = { workspace = true }
-codex-apply-patch = { workspace = true }
-codex-core = { workspace = true }
-codex-linux-sandbox = { workspace = true }
-dotenvy = { workspace = true }
-tempfile = { workspace = true }
-tokio = { workspace = true, features = ["rt-multi-thread"] }
+anyhow = "1"
+codex-apply-patch = { path = "../apply-patch" }
+codex-core = { path = "../core" }
+codex-linux-sandbox = { path = "../linux-sandbox" }
+dotenvy = "0.15.7"
+tempfile = "3"
+tokio = { version = "1", features = ["rt-multi-thread"] }

codex-rs/arg0/src/lib.rs

@@ -54,7 +54,7 @@ where
 
     let argv1 = args.next().unwrap_or_default();
     if argv1 == CODEX_APPLY_PATCH_ARG1 {
-        let patch_arg = args.next().and_then(|s| s.to_str().map(str::to_owned));
+        let patch_arg = args.next().and_then(|s| s.to_str().map(|s| s.to_owned()));
         let exit_code = match patch_arg {
             Some(patch_arg) => {
                 let mut stdout = std::io::stdout();

codex-rs/chatgpt/Cargo.toml

@@ -7,13 +7,13 @@ version = { workspace = true }
 workspace = true
 
 [dependencies]
-anyhow = { workspace = true }
-clap = { workspace = true, features = ["derive"] }
-codex-common = { workspace = true, features = ["cli"] }
-codex-core = { workspace = true }
-serde = { workspace = true, features = ["derive"] }
-serde_json = { workspace = true }
-tokio = { workspace = true, features = ["full"] }
+anyhow = "1"
+clap = { version = "4", features = ["derive"] }
+codex-common = { path = "../common", features = ["cli"] }
+codex-core = { path = "../core" }
+serde = { version = "1", features = ["derive"] }
+serde_json = "1"
+tokio = { version = "1", features = ["full"] }
 
 [dev-dependencies]
-tempfile = { workspace = true }
+tempfile = "3"

codex-rs/cli/Cargo.toml

@@ -15,34 +15,32 @@ path = "src/lib.rs"
 workspace = true
 
 [dependencies]
-anyhow = { workspace = true }
-clap = { workspace = true, features = ["derive"] }
-clap_complete = { workspace = true }
-codex-arg0 = { workspace = true }
-codex-chatgpt = { workspace = true }
-codex-common = { workspace = true, features = ["cli"] }
-codex-core = { workspace = true }
-codex-exec = { workspace = true }
-codex-login = { workspace = true }
-codex-mcp-server = { workspace = true }
-codex-protocol = { workspace = true }
-codex-protocol-ts = { workspace = true }
-codex-tui = { workspace = true }
-owo-colors = { workspace = true }
-serde_json = { workspace = true }
-supports-color = { workspace = true }
-tokio = { workspace = true, features = [
+anyhow = "1"
+clap = { version = "4", features = ["derive"] }
+clap_complete = "4"
+codex-arg0 = { path = "../arg0" }
+codex-chatgpt = { path = "../chatgpt" }
+codex-common = { path = "../common", features = ["cli"] }
+codex-core = { path = "../core" }
+codex-exec = { path = "../exec" }
+codex-login = { path = "../login" }
+codex-mcp-server = { path = "../mcp-server" }
+codex-protocol = { path = "../protocol" }
+codex-tui = { path = "../tui" }
+serde_json = "1"
+tokio = { version = "1", features = [
     "io-std",
     "macros",
     "process",
     "rt-multi-thread",
     "signal",
 ] }
-tracing = { workspace = true }
-tracing-subscriber = { workspace = true }
+tracing = "0.1.41"
+tracing-subscriber = "0.3.20"
+codex-protocol-ts = { path = "../protocol-ts" }
 
 [dev-dependencies]
-assert_cmd = { workspace = true }
-predicates = { workspace = true }
-pretty_assertions = { workspace = true }
-tempfile = { workspace = true }
+assert_cmd = "2"
+predicates = "3"
+pretty_assertions = "1"
+tempfile = "3"

codex-rs/cli/src/main.rs

@@ -14,11 +14,8 @@ use codex_cli::login::run_logout;
 use codex_cli::proto;
 use codex_common::CliConfigOverrides;
 use codex_exec::Cli as ExecCli;
-use codex_tui::AppExitInfo;
 use codex_tui::Cli as TuiCli;
-use owo_colors::OwoColorize;
 use std::path::PathBuf;
-use supports_color::Stream;
 
 mod mcp_cmd;
 
@@ -159,41 +156,6 @@ struct GenerateTsCommand {
     prettier: Option<PathBuf>,
 }
 
-fn format_exit_messages(exit_info: AppExitInfo, color_enabled: bool) -> Vec<String> {
-    let AppExitInfo {
-        token_usage,
-        conversation_id,
-    } = exit_info;
-
-    if token_usage.is_zero() {
-        return Vec::new();
-    }
-
-    let mut lines = vec![format!(
-        "{}",
-        codex_core::protocol::FinalOutput::from(token_usage)
-    )];
-
-    if let Some(session_id) = conversation_id {
-        let resume_cmd = format!("codex resume {session_id}");
-        let command = if color_enabled {
-            resume_cmd.cyan().to_string()
-        } else {
-            resume_cmd
-        };
-        lines.push(format!("To continue this session, run {command}."));
-    }
-
-    lines
-}
-
-fn print_exit_messages(exit_info: AppExitInfo) {
-    let color_enabled = supports_color::on(Stream::Stdout).is_some();
-    for line in format_exit_messages(exit_info, color_enabled) {
-        println!("{line}");
-    }
-}
-
 fn main() -> anyhow::Result<()> {
     arg0_dispatch_or_else(|codex_linux_sandbox_exe| async move {
         cli_main(codex_linux_sandbox_exe).await?;
@@ -214,8 +176,13 @@ async fn cli_main(codex_linux_sandbox_exe: Option<PathBuf>) -> anyhow::Result<()
                 &mut interactive.config_overrides,
                 root_config_overrides.clone(),
             );
-            let exit_info = codex_tui::run_main(interactive, codex_linux_sandbox_exe).await?;
-            print_exit_messages(exit_info);
+            let usage = codex_tui::run_main(interactive, codex_linux_sandbox_exe).await?;
+            if !usage.token_usage.is_zero() {
+                println!(
+                    "{}",
+                    codex_core::protocol::FinalOutput::from(usage.token_usage)
+                );
+            }
         }
         Some(Subcommand::Exec(mut exec_cli)) => {
             prepend_config_flags(
@@ -405,8 +372,6 @@ fn print_completion(cmd: CompletionCommand) {
 #[cfg(test)]
 mod tests {
     use super::*;
-    use codex_core::protocol::TokenUsage;
-    use codex_protocol::mcp_protocol::ConversationId;
 
     fn finalize_from_args(args: &[&str]) -> TuiCli {
         let cli = MultitoolCli::try_parse_from(args).expect("parse");
@@ -428,52 +393,6 @@ mod tests {
         finalize_resume_interactive(interactive, root_overrides, session_id, last, resume_cli)
     }
 
-    fn sample_exit_info(conversation: Option<&str>) -> AppExitInfo {
-        let token_usage = TokenUsage {
-            output_tokens: 2,
-            total_tokens: 2,
-            ..Default::default()
-        };
-        AppExitInfo {
-            token_usage,
-            conversation_id: conversation
-                .map(ConversationId::from_string)
-                .map(Result::unwrap),
-        }
-    }
-
-    #[test]
-    fn format_exit_messages_skips_zero_usage() {
-        let exit_info = AppExitInfo {
-            token_usage: TokenUsage::default(),
-            conversation_id: None,
-        };
-        let lines = format_exit_messages(exit_info, false);
-        assert!(lines.is_empty());
-    }
-
-    #[test]
-    fn format_exit_messages_includes_resume_hint_without_color() {
-        let exit_info = sample_exit_info(Some("123e4567-e89b-12d3-a456-426614174000"));
-        let lines = format_exit_messages(exit_info, false);
-        assert_eq!(
-            lines,
-            vec![
-                "Token usage: total=2 input=0 output=2".to_string(),
-                "To continue this session, run codex resume 123e4567-e89b-12d3-a456-426614174000."
-                    .to_string(),
-            ]
-        );
-    }
-
-    #[test]
-    fn format_exit_messages_applies_color_when_enabled() {
-        let exit_info = sample_exit_info(Some("123e4567-e89b-12d3-a456-426614174000"));
-        let lines = format_exit_messages(exit_info, true);
-        assert_eq!(lines.len(), 2);
-        assert!(lines[1].contains("\u{1b}[36m"));
-    }
-
     #[test]
     fn resume_model_flag_applies_when_no_root_flags() {
         let interactive = finalize_from_args(["codex", "resume", "-m", "gpt-5-test"].as_ref());

codex-rs/cli/src/mcp_cmd.rs

@@ -148,8 +148,7 @@ fn run_add(config_overrides: &CliConfigOverrides, add_args: AddArgs) -> Result<(
         command: command_bin,
         args: command_args,
         env: env_map,
-        startup_timeout_sec: None,
-        tool_timeout_sec: None,
+        startup_timeout_ms: None,
     };
 
     servers.insert(name.clone(), new_entry);
@@ -211,12 +210,7 @@ fn run_list(config_overrides: &CliConfigOverrides, list_args: ListArgs) -> Resul
                     "command": cfg.command,
                     "args": cfg.args,
                     "env": env,
-                    "startup_timeout_sec": cfg
-                        .startup_timeout_sec
-                        .map(|timeout| timeout.as_secs_f64()),
-                    "tool_timeout_sec": cfg
-                        .tool_timeout_sec
-                        .map(|timeout| timeout.as_secs_f64()),
+                    "startup_timeout_ms": cfg.startup_timeout_ms,
                 })
             })
             .collect();
@@ -311,12 +305,7 @@ fn run_get(config_overrides: &CliConfigOverrides, get_args: GetArgs) -> Result<(
             "command": server.command,
             "args": server.args,
             "env": env,
-            "startup_timeout_sec": server
-                .startup_timeout_sec
-                .map(|timeout| timeout.as_secs_f64()),
-            "tool_timeout_sec": server
-                .tool_timeout_sec
-                .map(|timeout| timeout.as_secs_f64()),
+            "startup_timeout_ms": server.startup_timeout_ms,
         }))?;
         println!("{output}");
         return Ok(());
@@ -344,11 +333,8 @@ fn run_get(config_overrides: &CliConfigOverrides, get_args: GetArgs) -> Result<(
         }
     };
     println!("  env: {env_display}");
-    if let Some(timeout) = server.startup_timeout_sec {
-        println!("  startup_timeout_sec: {}", timeout.as_secs_f64());
-    }
-    if let Some(timeout) = server.tool_timeout_sec {
-        println!("  tool_timeout_sec: {}", timeout.as_secs_f64());
+    if let Some(timeout) = server.startup_timeout_ms {
+        println!("  startup_timeout_ms: {timeout}");
     }
     println!("  remove: codex mcp remove {}", get_args.name);
 

codex-rs/common/Cargo.toml

@@ -7,11 +7,11 @@ version = { workspace = true }
 workspace = true
 
 [dependencies]
-clap = { workspace = true, features = ["derive", "wrap_help"], optional = true }
-codex-core = { workspace = true }
-codex-protocol = { workspace = true }
-serde = { workspace = true, optional = true }
-toml = { workspace = true, optional = true }
+clap = { version = "4", features = ["derive", "wrap_help"], optional = true }
+codex-core = { path = "../core" }
+codex-protocol = { path = "../protocol" }
+serde = { version = "1", optional = true }
+toml = { version = "0.9", optional = true }
 
 [features]
 # Separate feature so that `clap` is not a mandatory dependency.

codex-rs/common/src/model_presets.rs

@@ -1,3 +1,4 @@
+use codex_core::config::GPT_5_CODEX_MEDIUM_MODEL;
 use codex_core::protocol_config_types::ReasoningEffort;
 use codex_protocol::mcp_protocol::AuthMode;
 
@@ -68,6 +69,13 @@ const PRESETS: &[ModelPreset] = &[
     },
 ];
 
-pub fn builtin_model_presets(_auth_mode: Option<AuthMode>) -> Vec<ModelPreset> {
-    PRESETS.to_vec()
+pub fn builtin_model_presets(auth_mode: Option<AuthMode>) -> Vec<ModelPreset> {
+    match auth_mode {
+        Some(AuthMode::ApiKey) => PRESETS
+            .iter()
+            .copied()
+            .filter(|p| p.model != GPT_5_CODEX_MEDIUM_MODEL)
+            .collect(),
+        _ => PRESETS.to_vec(),
+    }
 }

codex-rs/core/Cargo.toml

@@ -12,81 +12,81 @@ path = "src/lib.rs"
 workspace = true
 
 [dependencies]
-anyhow = { workspace = true }
-askama = { workspace = true }
-async-channel = { workspace = true }
-base64 = { workspace = true }
-bytes = { workspace = true }
-chrono = { workspace = true, features = ["serde"] }
-codex-apply-patch = { workspace = true }
-codex-file-search = { workspace = true }
-codex-mcp-client = { workspace = true }
-codex-protocol = { workspace = true }
-dirs = { workspace = true }
-env-flags = { workspace = true }
-eventsource-stream = { workspace = true }
-futures = { workspace = true }
-libc = { workspace = true }
-mcp-types = { workspace = true }
-os_info = { workspace = true }
-portable-pty = { workspace = true }
-rand = { workspace = true }
-regex-lite = { workspace = true }
-reqwest = { workspace = true, features = ["json", "stream"] }
-serde = { workspace = true, features = ["derive"] }
-serde_json = { workspace = true }
-sha1 = { workspace = true }
-shlex = { workspace = true }
-similar = { workspace = true }
-strum_macros = { workspace = true }
-tempfile = { workspace = true }
-thiserror = { workspace = true }
-time = { workspace = true, features = [
+anyhow = "1"
+askama = "0.12"
+async-channel = "2.3.1"
+base64 = "0.22"
+bytes = "1.10.1"
+chrono = { version = "0.4", features = ["serde"] }
+codex-apply-patch = { path = "../apply-patch" }
+codex-file-search = { path = "../file-search" }
+codex-mcp-client = { path = "../mcp-client" }
+codex-protocol = { path = "../protocol" }
+dirs = "6"
+env-flags = "0.1.1"
+eventsource-stream = "0.2.3"
+futures = "0.3"
+libc = "0.2.175"
+mcp-types = { path = "../mcp-types" }
+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_json = "1"
+sha1 = "0.10.6"
+shlex = "1.3.0"
+similar = "2.7.0"
+strum_macros = "0.27.2"
+tempfile = "3"
+thiserror = "2.0.16"
+time = { version = "0.3", features = [
     "formatting",
     "parsing",
     "local-offset",
     "macros",
 ] }
-tokio = { workspace = true, features = [
+tokio = { version = "1", features = [
     "io-std",
     "macros",
     "process",
     "rt-multi-thread",
     "signal",
 ] }
-tokio-util = { workspace = true }
-toml = { workspace = true }
-toml_edit = { workspace = true }
-tracing = { workspace = true, features = ["log"] }
-tree-sitter = { workspace = true }
-tree-sitter-bash = { workspace = true }
-uuid = { workspace = true, features = ["serde", "v4"] }
-which = { workspace = true }
-wildmatch = { workspace = true }
+tokio-util = "0.7.16"
+toml = "0.9.5"
+toml_edit = "0.23.4"
+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"
+wildmatch = "2.5.0"
 
 
 [target.'cfg(target_os = "linux")'.dependencies]
-landlock = { workspace = true }
-seccompiler = { workspace = true }
+landlock = "0.4.1"
+seccompiler = "0.5.0"
 
 # Build OpenSSL from source for musl builds.
 [target.x86_64-unknown-linux-musl.dependencies]
-openssl-sys = { workspace = true, features = ["vendored"] }
+openssl-sys = { version = "*", features = ["vendored"] }
 
 # Build OpenSSL from source for musl builds.
 [target.aarch64-unknown-linux-musl.dependencies]
-openssl-sys = { workspace = true, features = ["vendored"] }
+openssl-sys = { version = "*", features = ["vendored"] }
 
 [dev-dependencies]
-assert_cmd = { workspace = true }
-core_test_support = { workspace = true }
-maplit = { workspace = true }
-predicates = { workspace = true }
-pretty_assertions = { workspace = true }
-tempfile = { workspace = true }
-tokio-test = { workspace = true }
-walkdir = { workspace = true }
-wiremock = { workspace = true }
+assert_cmd = "2"
+core_test_support = { path = "tests/common" }
+maplit = "1.0.2"
+predicates = "3"
+pretty_assertions = "1.4.1"
+tempfile = "3"
+tokio-test = "0.4"
+walkdir = "2.5.0"
+wiremock = "0.6"
 
 [package.metadata.cargo-shear]
 ignored = ["openssl-sys"]

codex-rs/core/src/bash.rs

@@ -1,4 +1,3 @@
-use tree_sitter::Node;
 use tree_sitter::Parser;
 use tree_sitter::Tree;
 use tree_sitter_bash::LANGUAGE as BASH;
@@ -75,7 +74,7 @@ pub fn try_parse_word_only_commands_sequence(tree: &Tree, src: &str) -> Option<V
     }
 
     // Walk uses a stack (LIFO), so re-sort by position to restore source order.
-    command_nodes.sort_by_key(Node::start_byte);
+    command_nodes.sort_by_key(|node| node.start_byte());
 
     let mut commands = Vec::new();
     for node in command_nodes {

codex-rs/core/src/chat_completions.rs

@@ -35,12 +35,6 @@ pub(crate) async fn stream_chat_completions(
     client: &reqwest::Client,
     provider: &ModelProviderInfo,
 ) -> Result<ResponseStream> {
-    if prompt.output_schema.is_some() {
-        return Err(CodexErr::UnsupportedOperation(
-            "output_schema is not supported for Chat Completions API".to_string(),
-        ));
-    }
-
     // Build messages array
     let mut messages = Vec::<serde_json::Value>::new();
 
@@ -468,7 +462,7 @@ async fn process_chat_sse<S>(
             if let Some(reasoning_val) = choice.get("delta").and_then(|d| d.get("reasoning")) {
                 let mut maybe_text = reasoning_val
                     .as_str()
-                    .map(str::to_string)
+                    .map(|s| s.to_string())
                     .filter(|s| !s.is_empty());
 
                 if maybe_text.is_none() && reasoning_val.is_object() {

codex-rs/core/src/client.rs

@@ -4,7 +4,6 @@ use std::sync::OnceLock;
 use std::time::Duration;
 
 use crate::AuthManager;
-use crate::auth::CodexAuth;
 use bytes::Bytes;
 use codex_protocol::mcp_protocol::AuthMode;
 use codex_protocol::mcp_protocol::ConversationId;
@@ -42,7 +41,7 @@ use crate::model_provider_info::ModelProviderInfo;
 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::RateLimitSnapshot;
+use crate::protocol::RateLimitSnapshotEvent;
 use crate::protocol::TokenUsage;
 use crate::token_data::PlanType;
 use crate::util::backoff;
@@ -185,7 +184,7 @@ impl ModelClient {
 
         // Only include `text.verbosity` for GPT-5 family models
         let text = if self.config.model_family.family == "gpt-5" {
-            create_text_param_for_request(self.config.model_verbosity, &prompt.output_schema)
+            create_text_param_for_request(self.config.model_verbosity)
         } else {
             if self.config.model_verbosity.is_some() {
                 warn!(
@@ -330,7 +329,6 @@ impl ModelClient {
                     }
 
                     if status == StatusCode::TOO_MANY_REQUESTS {
-                        let rate_limit_snapshot = parse_rate_limit_snapshot(res.headers());
                         let body = res.json::<ErrorResponse>().await.ok();
                         if let Some(ErrorResponse { error }) = body {
                             if error.r#type.as_deref() == Some("usage_limit_reached") {
@@ -339,12 +337,11 @@ impl ModelClient {
                                 // token.
                                 let plan_type = error
                                     .plan_type
-                                    .or_else(|| auth.as_ref().and_then(CodexAuth::get_plan_type));
+                                    .or_else(|| auth.as_ref().and_then(|a| a.get_plan_type()));
                                 let resets_in_seconds = error.resets_in_seconds;
                                 return Err(CodexErr::UsageLimitReached(UsageLimitReachedError {
                                     plan_type,
                                     resets_in_seconds,
-                                    rate_limits: rate_limit_snapshot,
                                 }));
                             } else if error.r#type.as_deref() == Some("usage_not_included") {
                                 return Err(CodexErr::UsageNotIncluded);
@@ -487,20 +484,20 @@ fn attach_item_ids(payload_json: &mut Value, original_items: &[ResponseItem]) {
     }
 }
 
-fn parse_rate_limit_snapshot(headers: &HeaderMap) -> Option<RateLimitSnapshot> {
+fn parse_rate_limit_snapshot(headers: &HeaderMap) -> Option<RateLimitSnapshotEvent> {
     let primary_used_percent = parse_header_f64(headers, "x-codex-primary-used-percent")?;
-    let secondary_used_percent = parse_header_f64(headers, "x-codex-secondary-used-percent")?;
-    let primary_to_secondary_ratio_percent =
-        parse_header_f64(headers, "x-codex-primary-over-secondary-limit-percent")?;
+    let weekly_used_percent = parse_header_f64(headers, "x-codex-protection-used-percent")?;
+    let primary_to_weekly_ratio_percent =
+        parse_header_f64(headers, "x-codex-primary-over-protection-limit-percent")?;
     let primary_window_minutes = parse_header_u64(headers, "x-codex-primary-window-minutes")?;
-    let secondary_window_minutes = parse_header_u64(headers, "x-codex-secondary-window-minutes")?;
+    let weekly_window_minutes = parse_header_u64(headers, "x-codex-protection-window-minutes")?;
 
-    Some(RateLimitSnapshot {
+    Some(RateLimitSnapshotEvent {
         primary_used_percent,
-        secondary_used_percent,
-        primary_to_secondary_ratio_percent,
+        weekly_used_percent,
+        primary_to_weekly_ratio_percent,
         primary_window_minutes,
-        secondary_window_minutes,
+        weekly_window_minutes,
     })
 }
 

codex-rs/core/src/client_common.rs

@@ -1,7 +1,7 @@
 use crate::error::Result;
 use crate::model_family::ModelFamily;
 use crate::openai_tools::OpenAiTool;
-use crate::protocol::RateLimitSnapshot;
+use crate::protocol::RateLimitSnapshotEvent;
 use crate::protocol::TokenUsage;
 use codex_apply_patch::APPLY_PATCH_TOOL_INSTRUCTIONS;
 use codex_protocol::config_types::ReasoningEffort as ReasoningEffortConfig;
@@ -10,7 +10,6 @@ use codex_protocol::config_types::Verbosity as VerbosityConfig;
 use codex_protocol::models::ResponseItem;
 use futures::Stream;
 use serde::Serialize;
-use serde_json::Value;
 use std::borrow::Cow;
 use std::ops::Deref;
 use std::pin::Pin;
@@ -33,9 +32,6 @@ pub struct Prompt {
 
     /// Optional override for the built-in BASE_INSTRUCTIONS.
     pub base_instructions_override: Option<String>,
-
-    /// Optional the output schema for the model's response.
-    pub output_schema: Option<Value>,
 }
 
 impl Prompt {
@@ -83,7 +79,7 @@ pub enum ResponseEvent {
     WebSearchCallBegin {
         call_id: String,
     },
-    RateLimits(RateLimitSnapshot),
+    RateLimits(RateLimitSnapshotEvent),
 }
 
 #[derive(Debug, Serialize)]
@@ -94,31 +90,14 @@ pub(crate) struct Reasoning {
     pub(crate) summary: Option<ReasoningSummaryConfig>,
 }
 
-#[derive(Debug, Serialize, Default, Clone)]
-#[serde(rename_all = "snake_case")]
-pub(crate) enum TextFormatType {
-    #[default]
-    JsonSchema,
-}
-
-#[derive(Debug, Serialize, Default, Clone)]
-pub(crate) struct TextFormat {
-    pub(crate) r#type: TextFormatType,
-    pub(crate) strict: bool,
-    pub(crate) schema: Value,
-    pub(crate) name: String,
-}
-
 /// Controls under the `text` field in the Responses API for GPT-5.
-#[derive(Debug, Serialize, Default, Clone)]
+#[derive(Debug, Serialize, Default, Clone, Copy)]
 pub(crate) struct TextControls {
     #[serde(skip_serializing_if = "Option::is_none")]
     pub(crate) verbosity: Option<OpenAiVerbosity>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub(crate) format: Option<TextFormat>,
 }
 
-#[derive(Debug, Serialize, Default, Clone)]
+#[derive(Debug, Serialize, Default, Clone, Copy)]
 #[serde(rename_all = "lowercase")]
 pub(crate) enum OpenAiVerbosity {
     Low,
@@ -177,20 +156,9 @@ pub(crate) fn create_reasoning_param_for_request(
 
 pub(crate) fn create_text_param_for_request(
     verbosity: Option<VerbosityConfig>,
-    output_schema: &Option<Value>,
 ) -> Option<TextControls> {
-    if verbosity.is_none() && output_schema.is_none() {
-        return None;
-    }
-
-    Some(TextControls {
-        verbosity: verbosity.map(std::convert::Into::into),
-        format: output_schema.as_ref().map(|schema| TextFormat {
-            r#type: TextFormatType::JsonSchema,
-            strict: true,
-            schema: schema.clone(),
-            name: "codex_output_schema".to_string(),
-        }),
+    verbosity.map(|v| TextControls {
+        verbosity: Some(v.into()),
     })
 }
 
@@ -287,7 +255,6 @@ mod tests {
             prompt_cache_key: None,
             text: Some(TextControls {
                 verbosity: Some(OpenAiVerbosity::Low),
-                format: None,
             }),
         };
 
@@ -300,52 +267,6 @@ mod tests {
         );
     }
 
-    #[test]
-    fn serializes_text_schema_with_strict_format() {
-        let input: Vec<ResponseItem> = vec![];
-        let tools: Vec<serde_json::Value> = vec![];
-        let schema = serde_json::json!({
-            "type": "object",
-            "properties": {
-                "answer": {"type": "string"}
-            },
-            "required": ["answer"],
-        });
-        let text_controls =
-            create_text_param_for_request(None, &Some(schema.clone())).expect("text controls");
-
-        let req = ResponsesApiRequest {
-            model: "gpt-5",
-            instructions: "i",
-            input: &input,
-            tools: &tools,
-            tool_choice: "auto",
-            parallel_tool_calls: false,
-            reasoning: None,
-            store: false,
-            stream: true,
-            include: vec![],
-            prompt_cache_key: None,
-            text: Some(text_controls),
-        };
-
-        let v = serde_json::to_value(&req).expect("json");
-        let text = v.get("text").expect("text field");
-        assert!(text.get("verbosity").is_none());
-        let format = text.get("format").expect("format field");
-
-        assert_eq!(
-            format.get("name"),
-            Some(&serde_json::Value::String("codex_output_schema".into()))
-        );
-        assert_eq!(
-            format.get("type"),
-            Some(&serde_json::Value::String("json_schema".into()))
-        );
-        assert_eq!(format.get("strict"), Some(&serde_json::Value::Bool(true)));
-        assert_eq!(format.get("schema"), Some(&schema));
-    }
-
     #[test]
     fn omits_text_when_not_set() {
         let input: Vec<ResponseItem> = vec![];

codex-rs/core/src/codex.rs

@@ -1,5 +1,6 @@
 use std::borrow::Cow;
 use std::collections::HashMap;
+use std::collections::HashSet;
 use std::path::Path;
 use std::path::PathBuf;
 use std::sync::Arc;
@@ -10,7 +11,6 @@ use crate::AuthManager;
 use crate::client_common::REVIEW_PROMPT;
 use crate::event_mapping::map_response_item_to_event_messages;
 use crate::review_format::format_review_findings_block;
-use crate::user_notification::UserNotifier;
 use async_channel::Receiver;
 use async_channel::Sender;
 use codex_apply_patch::ApplyPatchAction;
@@ -30,7 +30,6 @@ use mcp_types::CallToolResult;
 use serde::Deserialize;
 use serde::Serialize;
 use serde_json;
-use serde_json::Value;
 use tokio::sync::Mutex;
 use tokio::sync::oneshot;
 use tokio::task::AbortHandle;
@@ -99,7 +98,7 @@ use crate::protocol::ListCustomPromptsResponseEvent;
 use crate::protocol::Op;
 use crate::protocol::PatchApplyBeginEvent;
 use crate::protocol::PatchApplyEndEvent;
-use crate::protocol::RateLimitSnapshot;
+use crate::protocol::RateLimitSnapshotEvent;
 use crate::protocol::ReviewDecision;
 use crate::protocol::ReviewOutputEvent;
 use crate::protocol::SandboxPolicy;
@@ -109,6 +108,7 @@ use crate::protocol::Submission;
 use crate::protocol::TaskCompleteEvent;
 use crate::protocol::TokenCountEvent;
 use crate::protocol::TokenUsage;
+use crate::protocol::TokenUsageInfo;
 use crate::protocol::TurnDiffEvent;
 use crate::protocol::WebSearchBeginEvent;
 use crate::rollout::RolloutRecorder;
@@ -116,9 +116,7 @@ use crate::rollout::RolloutRecorderParams;
 use crate::safety::SafetyCheck;
 use crate::safety::assess_command_safety;
 use crate::safety::assess_safety_for_untrusted_command;
-use crate::services::SessionServices;
 use crate::shell;
-use crate::state::ActiveTurn;
 use crate::turn_diff_tracker::TurnDiffTracker;
 use crate::unified_exec::UnifiedExecSessionManager;
 use crate::user_instructions::UserInstructions;
@@ -188,7 +186,7 @@ impl Codex {
             base_instructions: config.base_instructions.clone(),
             approval_policy: config.approval_policy,
             sandbox_policy: config.sandbox_policy.clone(),
-            notify: UserNotifier::new(config.notify.clone()),
+            notify: config.notify.clone(),
             cwd: config.cwd.clone(),
         };
 
@@ -252,7 +250,17 @@ impl Codex {
     }
 }
 
-use crate::state::SessionState;
+/// Mutable state of the agent
+#[derive(Default)]
+struct State {
+    approved_commands: HashSet<Vec<String>>,
+    current_task: Option<AgentTask>,
+    pending_approvals: HashMap<String, oneshot::Sender<ReviewDecision>>,
+    pending_input: Vec<ResponseInputItem>,
+    history: ConversationHistory,
+    token_info: Option<TokenUsageInfo>,
+    latest_rate_limits: Option<RateLimitSnapshotEvent>,
+}
 
 /// Context for an initialized model agent
 ///
@@ -260,9 +268,23 @@ use crate::state::SessionState;
 pub(crate) struct Session {
     conversation_id: ConversationId,
     tx_event: Sender<Event>,
-    state: Mutex<SessionState>,
-    active_turn: Mutex<Option<ActiveTurn>>,
-    services: SessionServices,
+
+    /// 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.
+    notify: Option<Vec<String>>,
+
+    /// Optional rollout recorder for persisting the conversation transcript so
+    /// sessions can be replayed or inspected later.
+    rollout: Mutex<Option<RolloutRecorder>>,
+    state: Mutex<State>,
+    codex_linux_sandbox_exe: Option<PathBuf>,
+    user_shell: shell::Shell,
+    show_raw_agent_reasoning: bool,
     next_internal_sub_id: AtomicU64,
 }
 
@@ -281,7 +303,6 @@ pub(crate) struct TurnContext {
     pub(crate) shell_environment_policy: ShellEnvironmentPolicy,
     pub(crate) tools_config: ToolsConfig,
     pub(crate) is_review_mode: bool,
-    pub(crate) final_output_json_schema: Option<Value>,
 }
 
 impl TurnContext {
@@ -314,7 +335,10 @@ struct ConfigureSession {
     /// How to sandbox commands executed in the system
     sandbox_policy: SandboxPolicy,
 
-    notify: UserNotifier,
+    /// Optional external notifier command tokens. Present only when the
+    /// client wants the agent to spawn a program after each completed
+    /// turn.
+    notify: Option<Vec<String>>,
 
     /// Working directory that should be treated as the *root* of the
     /// session. All relative paths supplied by the model as well as the
@@ -390,7 +414,10 @@ impl Session {
         })?;
         let rollout_path = rollout_recorder.rollout_path.clone();
         // Create the mutable state for the Session.
-        let state = SessionState::new();
+        let state = State {
+            history: ConversationHistory::new(),
+            ..Default::default()
+        };
 
         // Handle MCP manager result and record any startup failures.
         let (mcp_connection_manager, failed_clients) = match mcp_res {
@@ -446,25 +473,19 @@ impl Session {
             shell_environment_policy: config.shell_environment_policy.clone(),
             cwd,
             is_review_mode: false,
-            final_output_json_schema: None,
         };
-        let services = SessionServices {
+        let sess = Arc::new(Session {
+            conversation_id,
+            tx_event: tx_event.clone(),
             mcp_connection_manager,
             session_manager: ExecSessionManager::default(),
             unified_exec_manager: UnifiedExecSessionManager::default(),
-            notifier: notify,
+            notify,
+            state: Mutex::new(state),
             rollout: Mutex::new(Some(rollout_recorder)),
             codex_linux_sandbox_exe: config.codex_linux_sandbox_exe.clone(),
             user_shell: default_shell,
             show_raw_agent_reasoning: config.show_raw_agent_reasoning,
-        };
-
-        let sess = Arc::new(Session {
-            conversation_id,
-            tx_event: tx_event.clone(),
-            state: Mutex::new(state),
-            active_turn: Mutex::new(None),
-            services,
             next_internal_sub_id: AtomicU64::new(0),
         });
 
@@ -500,15 +521,6 @@ impl Session {
             current_task.abort(TurnAbortReason::Replaced);
         }
         state.current_task = Some(task);
-        if let Some(current_task) = &state.current_task {
-            let mut active = self.active_turn.lock().await;
-            *active = Some(ActiveTurn {
-                sub_id: current_task.sub_id.clone(),
-                turn_state: std::sync::Arc::new(tokio::sync::Mutex::new(
-                    crate::state::TurnState::default(),
-                )),
-            });
-        }
     }
 
     pub async fn remove_task(&self, sub_id: &str) {
@@ -518,12 +530,6 @@ impl Session {
         {
             state.current_task.take();
         }
-        let mut active = self.active_turn.lock().await;
-        if let Some(at) = &*active
-            && at.sub_id == sub_id
-        {
-            *active = None;
-        }
     }
 
     fn next_internal_sub_id(&self) -> String {
@@ -580,19 +586,13 @@ impl Session {
         command: Vec<String>,
         cwd: PathBuf,
         reason: Option<String>,
-    ) -> ReviewDecision {
+    ) -> oneshot::Receiver<ReviewDecision> {
         // Add the tx_approve callback to the map before sending the request.
         let (tx_approve, rx_approve) = oneshot::channel();
         let event_id = sub_id.clone();
         let prev_entry = {
-            let mut active = self.active_turn.lock().await;
-            match active.as_mut() {
-                Some(at) => {
-                    let mut ts = at.turn_state.lock().await;
-                    ts.insert_pending_approval(sub_id, tx_approve)
-                }
-                None => None,
-            }
+            let mut state = self.state.lock().await;
+            state.pending_approvals.insert(sub_id, tx_approve)
         };
         if prev_entry.is_some() {
             warn!("Overwriting existing pending approval for sub_id: {event_id}");
@@ -608,7 +608,7 @@ impl Session {
             }),
         };
         self.send_event(event).await;
-        rx_approve.await.unwrap_or_default()
+        rx_approve
     }
 
     pub async fn request_patch_approval(
@@ -623,14 +623,8 @@ impl Session {
         let (tx_approve, rx_approve) = oneshot::channel();
         let event_id = sub_id.clone();
         let prev_entry = {
-            let mut active = self.active_turn.lock().await;
-            match active.as_mut() {
-                Some(at) => {
-                    let mut ts = at.turn_state.lock().await;
-                    ts.insert_pending_approval(sub_id, tx_approve)
-                }
-                None => None,
-            }
+            let mut state = self.state.lock().await;
+            state.pending_approvals.insert(sub_id, tx_approve)
         };
         if prev_entry.is_some() {
             warn!("Overwriting existing pending approval for sub_id: {event_id}");
@@ -651,14 +645,8 @@ impl Session {
 
     pub async fn notify_approval(&self, sub_id: &str, decision: ReviewDecision) {
         let entry = {
-            let mut active = self.active_turn.lock().await;
-            match active.as_mut() {
-                Some(at) => {
-                    let mut ts = at.turn_state.lock().await;
-                    ts.remove_pending_approval(sub_id)
-                }
-                None => None,
-            }
+            let mut state = self.state.lock().await;
+            state.pending_approvals.remove(sub_id)
         };
         match entry {
             Some(tx_approve) => {
@@ -672,7 +660,7 @@ impl Session {
 
     pub async fn add_approved_command(&self, cmd: Vec<String>) {
         let mut state = self.state.lock().await;
-        state.add_approved_command(cmd);
+        state.approved_commands.insert(cmd);
     }
 
     /// Records input items: always append to conversation history and
@@ -712,7 +700,7 @@ impl Session {
     /// Append ResponseItems to the in-memory conversation history only.
     async fn record_into_history(&self, items: &[ResponseItem]) {
         let mut state = self.state.lock().await;
-        state.record_items(items.iter());
+        state.history.record_items(items.iter());
     }
 
     async fn persist_rollout_response_items(&self, items: &[ResponseItem]) {
@@ -733,14 +721,14 @@ impl Session {
             Some(turn_context.cwd.clone()),
             Some(turn_context.approval_policy),
             Some(turn_context.sandbox_policy.clone()),
-            Some(self.services.user_shell.clone()),
+            Some(self.user_shell.clone()),
         )));
         items
     }
 
     async fn persist_rollout_items(&self, items: &[RolloutItem]) {
         let recorder = {
-            let guard = self.services.rollout.lock().await;
+            let guard = self.rollout.lock().await;
             guard.clone()
         };
         if let Some(rec) = recorder
@@ -750,47 +738,33 @@ impl Session {
         }
     }
 
-    pub(crate) async fn history_snapshot(&self) -> Vec<ResponseItem> {
-        let state = self.state.lock().await;
-        state.history_snapshot()
-    }
-
     async fn update_token_usage_info(
         &self,
-        sub_id: &str,
         turn_context: &TurnContext,
         token_usage: Option<&TokenUsage>,
     ) {
-        {
-            let mut state = self.state.lock().await;
-            if let Some(token_usage) = token_usage {
-                state.update_token_info_from_usage(
-                    token_usage,
-                    turn_context.client.get_model_context_window(),
-                );
-            }
+        let mut state = self.state.lock().await;
+        if let Some(token_usage) = token_usage {
+            let info = TokenUsageInfo::new_or_append(
+                &state.token_info,
+                &Some(token_usage.clone()),
+                turn_context.client.get_model_context_window(),
+            );
+            state.token_info = info;
         }
-        self.send_token_count_event(sub_id).await;
     }
 
-    async fn update_rate_limits(&self, sub_id: &str, new_rate_limits: RateLimitSnapshot) {
-        {
-            let mut state = self.state.lock().await;
-            state.set_rate_limits(new_rate_limits);
-        }
-        self.send_token_count_event(sub_id).await;
+    async fn update_rate_limits(&self, new_rate_limits: RateLimitSnapshotEvent) {
+        let mut state = self.state.lock().await;
+        state.latest_rate_limits = Some(new_rate_limits);
     }
 
-    async fn send_token_count_event(&self, sub_id: &str) {
-        let (info, rate_limits) = {
-            let state = self.state.lock().await;
-            state.token_info_and_rate_limits()
-        };
-        let event = Event {
-            id: sub_id.to_string(),
-            msg: EventMsg::TokenCount(TokenCountEvent { info, rate_limits }),
-        };
-        self.send_event(event).await;
+    async fn get_token_count_event(&self) -> TokenCountEvent {
+        let state = self.state.lock().await;
+        TokenCountEvent {
+            info: state.token_info.clone(),
+            rate_limits: state.latest_rate_limits.clone(),
+        }
     }
 
     /// Record a user input item to conversation history and also persist a
@@ -802,10 +776,8 @@ impl Session {
             .await;
 
         // Derive user message events and persist only UserMessage to rollout
-        let msgs = map_response_item_to_event_messages(
-            &response_item,
-            self.services.show_raw_agent_reasoning,
-        );
+        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 {
@@ -1004,20 +976,16 @@ impl Session {
     pub async fn turn_input_with_history(&self, extra: Vec<ResponseItem>) -> Vec<ResponseItem> {
         let history = {
             let state = self.state.lock().await;
-            state.history_snapshot()
+            state.history.contents()
         };
         [history, extra].concat()
     }
 
     /// Returns the input if there was no task running to inject into
     pub async fn inject_input(&self, input: Vec<InputItem>) -> Result<(), Vec<InputItem>> {
-        let state = self.state.lock().await;
+        let mut state = self.state.lock().await;
         if state.current_task.is_some() {
-            let mut active = self.active_turn.lock().await;
-            if let Some(at) = active.as_mut() {
-                let mut ts = at.turn_state.lock().await;
-                ts.push_pending_input(input.into());
-            }
+            state.pending_input.push(input.into());
             Ok(())
         } else {
             Err(input)
@@ -1025,12 +993,13 @@ impl Session {
     }
 
     pub async fn get_pending_input(&self) -> Vec<ResponseInputItem> {
-        let mut active = self.active_turn.lock().await;
-        if let Some(at) = active.as_mut() {
-            let mut ts = at.turn_state.lock().await;
-            ts.take_pending_input()
-        } else {
+        let mut state = self.state.lock().await;
+        if state.pending_input.is_empty() {
             Vec::with_capacity(0)
+        } else {
+            let mut ret = Vec::new();
+            std::mem::swap(&mut ret, &mut state.pending_input);
+            ret
         }
     }
 
@@ -1039,21 +1008,18 @@ impl Session {
         server: &str,
         tool: &str,
         arguments: Option<serde_json::Value>,
+        timeout: Option<Duration>,
     ) -> anyhow::Result<CallToolResult> {
-        self.services
-            .mcp_connection_manager
-            .call_tool(server, tool, arguments)
+        self.mcp_connection_manager
+            .call_tool(server, tool, arguments, timeout)
             .await
     }
 
     pub async fn interrupt_task(&self) {
         info!("interrupt received: abort current task, if any");
         let mut state = self.state.lock().await;
-        let mut active = self.active_turn.lock().await;
-        if let Some(at) = active.as_mut() {
-            let mut ts = at.turn_state.lock().await;
-            ts.clear_pending();
-        }
+        state.pending_approvals.clear();
+        state.pending_input.clear();
         if let Some(task) = state.current_task.take() {
             task.abort(TurnAbortReason::Interrupted);
         }
@@ -1061,20 +1027,41 @@ impl Session {
 
     fn interrupt_task_sync(&self) {
         if let Ok(mut state) = self.state.try_lock() {
-            if let Ok(mut active) = self.active_turn.try_lock()
-                && let Some(at) = active.as_mut()
-                && let Ok(mut ts) = at.turn_state.try_lock()
-            {
-                ts.clear_pending();
-            }
+            state.pending_approvals.clear();
+            state.pending_input.clear();
             if let Some(task) = state.current_task.take() {
                 task.abort(TurnAbortReason::Interrupted);
             }
         }
     }
 
-    pub(crate) fn notifier(&self) -> &UserNotifier {
-        &self.services.notifier
+    /// Spawn the configured notifier (if any) with the given JSON payload as
+    /// the last argument. Failures are logged but otherwise ignored so that
+    /// notification issues do not interfere with the main workflow.
+    fn maybe_notify(&self, notification: UserNotification) {
+        let Some(notify_command) = &self.notify else {
+            return;
+        };
+
+        if notify_command.is_empty() {
+            return;
+        }
+
+        let Ok(json) = serde_json::to_string(&notification) else {
+            error!("failed to serialise notification payload");
+            return;
+        };
+
+        let mut command = std::process::Command::new(&notify_command[0]);
+        if notify_command.len() > 1 {
+            command.args(&notify_command[1..]);
+        }
+        command.arg(json);
+
+        // Fire-and-forget – we do not wait for completion.
+        if let Err(e) = command.spawn() {
+            warn!("failed to spawn notifier '{}': {e}", notify_command[0]);
+        }
     }
 }
 
@@ -1160,13 +1147,16 @@ impl AgentTask {
         turn_context: Arc<TurnContext>,
         sub_id: String,
         input: Vec<InputItem>,
+        compact_instructions: String,
     ) -> Self {
         let handle = {
             let sess = sess.clone();
             let sub_id = sub_id.clone();
             let tc = Arc::clone(&turn_context);
-            tokio::spawn(async move { compact::run_compact_task(sess, tc, sub_id, input).await })
-                .abort_handle()
+            tokio::spawn(async move {
+                compact::run_compact_task(sess, tc, sub_id, input, compact_instructions).await
+            })
+            .abort_handle()
         };
         Self {
             sess,
@@ -1280,7 +1270,6 @@ async fn submission_loop(
                     shell_environment_policy: prev.shell_environment_policy.clone(),
                     cwd: new_cwd.clone(),
                     is_review_mode: false,
-                    final_output_json_schema: None,
                 };
 
                 // Install the new persistent context for subsequent tasks/turns.
@@ -1315,7 +1304,6 @@ async fn submission_loop(
                 model,
                 effort,
                 summary,
-                final_output_json_schema,
             } => {
                 // attempt to inject input into current task
                 if let Err(items) = sess.inject_input(items).await {
@@ -1366,7 +1354,6 @@ async fn submission_loop(
                         shell_environment_policy: turn_context.shell_environment_policy.clone(),
                         cwd,
                         is_review_mode: false,
-                        final_output_json_schema,
                     };
 
                     // if the environment context has changed, record it in the conversation history
@@ -1446,7 +1433,7 @@ async fn submission_loop(
                 let sub_id = sub.id.clone();
 
                 // This is a cheap lookup from the connection manager's cache.
-                let tools = sess.services.mcp_connection_manager.list_all_tools();
+                let tools = sess.mcp_connection_manager.list_all_tools();
                 let event = Event {
                     id: sub_id,
                     msg: EventMsg::McpListToolsResponse(
@@ -1477,7 +1464,7 @@ async fn submission_loop(
                 // Attempt to inject input into current task
                 if let Err(items) = sess
                     .inject_input(vec![InputItem::Text {
-                        text: compact::SUMMARIZATION_PROMPT.to_string(),
+                        text: compact::COMPACT_TRIGGER_TEXT.to_string(),
                     }])
                     .await
                 {
@@ -1496,7 +1483,7 @@ async fn submission_loop(
                 // Gracefully flush and shutdown rollout recorder on session end so tests
                 // that inspect the rollout file do not race with the background writer.
                 let recorder_opt = {
-                    let mut guard = sess.services.rollout.lock().await;
+                    let mut guard = sess.rollout.lock().await;
                     guard.take()
                 };
                 if let Some(rec) = recorder_opt
@@ -1523,7 +1510,7 @@ async fn submission_loop(
                 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.services.rollout.lock().await;
+                    let guard = sess.rollout.lock().await;
                     match guard.as_ref() {
                         Some(rec) => (rec.get_rollout_path(), Some(rec.clone())),
                         None => {
@@ -1621,7 +1608,6 @@ async fn spawn_review_thread(
         shell_environment_policy: parent_turn_context.shell_environment_policy.clone(),
         cwd: parent_turn_context.cwd.clone(),
         is_review_mode: true,
-        final_output_json_schema: None,
     };
 
     // Seed the child task with the review prompt as the initial user message.
@@ -1762,7 +1748,7 @@ async fn run_task(
                     .unwrap_or(i64::MAX);
                 let total_usage_tokens = total_token_usage
                     .as_ref()
-                    .map(TokenUsage::tokens_in_context_window);
+                    .map(|usage| usage.tokens_in_context_window());
                 let token_limit_reached = total_usage_tokens
                     .map(|tokens| (tokens as i64) >= limit)
                     .unwrap_or(false);
@@ -1898,12 +1884,11 @@ async fn run_task(
                     last_agent_message = get_last_assistant_message_from_turn(
                         &items_to_record_in_conversation_history,
                     );
-                    sess.notifier()
-                        .notify(&UserNotification::AgentTurnComplete {
-                            turn_id: sub_id.clone(),
-                            input_messages: turn_input_messages,
-                            last_assistant_message: last_agent_message.clone(),
-                        });
+                    sess.maybe_notify(UserNotification::AgentTurnComplete {
+                        turn_id: sub_id.clone(),
+                        input_messages: turn_input_messages,
+                        last_assistant_message: last_agent_message.clone(),
+                    });
                     break;
                 }
                 continue;
@@ -1981,14 +1966,13 @@ async fn run_turn(
 ) -> CodexResult<TurnRunResult> {
     let tools = get_openai_tools(
         &turn_context.tools_config,
-        Some(sess.services.mcp_connection_manager.list_all_tools()),
+        Some(sess.mcp_connection_manager.list_all_tools()),
     );
 
     let prompt = Prompt {
         input,
         tools,
         base_instructions_override: turn_context.base_instructions.clone(),
-        output_schema: turn_context.final_output_json_schema.clone(),
     };
 
     let mut retries = 0;
@@ -1997,14 +1981,9 @@ async fn run_turn(
             Ok(output) => return Ok(output),
             Err(CodexErr::Interrupted) => return Err(CodexErr::Interrupted),
             Err(CodexErr::EnvVar(var)) => return Err(CodexErr::EnvVar(var)),
-            Err(CodexErr::UsageLimitReached(e)) => {
-                let rate_limits = e.rate_limits.clone();
-                if let Some(rate_limits) = rate_limits {
-                    sess.update_rate_limits(&sub_id, rate_limits).await;
-                }
-                return Err(CodexErr::UsageLimitReached(e));
+            Err(e @ (CodexErr::UsageLimitReached(_) | CodexErr::UsageNotIncluded)) => {
+                return Err(e);
             }
-            Err(CodexErr::UsageNotIncluded) => return Err(CodexErr::UsageNotIncluded),
             Err(e) => {
                 // Use the configured provider-specific stream retry budget.
                 let max_retries = turn_context.client.get_provider().stream_max_retries();
@@ -2177,13 +2156,20 @@ async fn try_run_turn(
             ResponseEvent::RateLimits(snapshot) => {
                 // Update internal state with latest rate limits, but defer sending until
                 // token usage is available to avoid duplicate TokenCount events.
-                sess.update_rate_limits(sub_id, snapshot).await;
+                sess.update_rate_limits(snapshot).await;
             }
             ResponseEvent::Completed {
                 response_id: _,
                 token_usage,
             } => {
-                sess.update_token_usage_info(sub_id, turn_context, token_usage.as_ref())
+                sess.update_token_usage_info(turn_context, token_usage.as_ref())
+                    .await;
+                let token_event = sess.get_token_count_event().await;
+                let _ = sess
+                    .send_event(Event {
+                        id: sub_id.to_string(),
+                        msg: EventMsg::TokenCount(token_event),
+                    })
                     .await;
 
                 let unified_diff = turn_diff_tracker.get_unified_diff();
@@ -2231,7 +2217,7 @@ async fn try_run_turn(
                 sess.send_event(event).await;
             }
             ResponseEvent::ReasoningContentDelta(delta) => {
-                if sess.services.show_raw_agent_reasoning {
+                if sess.show_raw_agent_reasoning {
                     let event = Event {
                         id: sub_id.to_string(),
                         msg: EventMsg::AgentReasoningRawContentDelta(
@@ -2353,10 +2339,7 @@ async fn handle_response_item(
                     trace!("suppressing assistant Message in review mode");
                     Vec::new()
                 }
-                _ => map_response_item_to_event_messages(
-                    &item,
-                    sess.services.show_raw_agent_reasoning,
-                ),
+                _ => map_response_item_to_event_messages(&item, sess.show_raw_agent_reasoning),
             };
             for msg in msgs {
                 let event = Event {
@@ -2402,11 +2385,7 @@ async fn handle_unified_exec_tool_call(
         timeout_ms,
     };
 
-    let result = sess
-        .services
-        .unified_exec_manager
-        .handle_request(request)
-        .await;
+    let result = sess.unified_exec_manager.handle_request(request).await;
 
     let output_payload = match result {
         Ok(value) => {
@@ -2581,7 +2560,6 @@ async fn handle_function_call(
                 }
             };
             let result = sess
-                .services
                 .session_manager
                 .handle_exec_command_request(exec_params)
                 .await;
@@ -2605,7 +2583,6 @@ async fn handle_function_call(
                 }
             };
             let result = sess
-                .services
                 .session_manager
                 .handle_write_stdin_request(write_stdin_params)
                 .await;
@@ -2617,9 +2594,14 @@ async fn handle_function_call(
             }
         }
         _ => {
-            match sess.services.mcp_connection_manager.parse_tool_name(&name) {
+            match sess.mcp_connection_manager.parse_tool_name(&name) {
                 Some((server, tool_name)) => {
-                    handle_mcp_tool_call(sess, &sub_id, call_id, server, tool_name, arguments).await
+                    // TODO(mbolin): Determine appropriate timeout for tool call.
+                    let timeout = None;
+                    handle_mcp_tool_call(
+                        sess, &sub_id, call_id, server, tool_name, arguments, timeout,
+                    )
+                    .await
                 }
                 None => {
                     // Unknown function: reply with structured failure so the model can adapt.
@@ -2735,12 +2717,11 @@ fn maybe_translate_shell_command(
     sess: &Session,
     turn_context: &TurnContext,
 ) -> ExecParams {
-    let should_translate = matches!(sess.services.user_shell, crate::shell::Shell::PowerShell(_))
+    let should_translate = matches!(sess.user_shell, crate::shell::Shell::PowerShell(_))
         || turn_context.shell_environment_policy.use_profile;
 
     if should_translate
         && let Some(command) = sess
-            .services
             .user_shell
             .format_default_shell_invocation(params.command.clone())
     {
@@ -2855,7 +2836,7 @@ async fn handle_container_exec_with_params(
                     &params.command,
                     turn_context.approval_policy,
                     &turn_context.sandbox_policy,
-                    state.approved_commands_ref(),
+                    &state.approved_commands,
                     params.with_escalated_permissions.unwrap_or(false),
                 )
             };
@@ -2867,7 +2848,7 @@ async fn handle_container_exec_with_params(
     let sandbox_type = match safety {
         SafetyCheck::AutoApprove { sandbox_type } => sandbox_type,
         SafetyCheck::AskUser => {
-            let decision = sess
+            let rx_approve = sess
                 .request_command_approval(
                     sub_id.clone(),
                     call_id.clone(),
@@ -2876,7 +2857,7 @@ async fn handle_container_exec_with_params(
                     params.justification.clone(),
                 )
                 .await;
-            match decision {
+            match rx_approve.await.unwrap_or_default() {
                 ReviewDecision::Approved => (),
                 ReviewDecision::ApprovedForSession => {
                     sess.add_approved_command(params.command.clone()).await;
@@ -2934,7 +2915,7 @@ async fn handle_container_exec_with_params(
                 sandbox_type,
                 sandbox_policy: &turn_context.sandbox_policy,
                 sandbox_cwd: &turn_context.cwd,
-                codex_linux_sandbox_exe: &sess.services.codex_linux_sandbox_exe,
+                codex_linux_sandbox_exe: &sess.codex_linux_sandbox_exe,
                 stdout_stream: if exec_command_context.apply_patch.is_some() {
                     None
                 } else {
@@ -3037,7 +3018,7 @@ async fn handle_sandbox_error(
     sess.notify_background_event(&sub_id, format!("Execution failed: {error}"))
         .await;
 
-    let decision = sess
+    let rx_approve = sess
         .request_command_approval(
             sub_id.clone(),
             call_id.clone(),
@@ -3047,7 +3028,7 @@ async fn handle_sandbox_error(
         )
         .await;
 
-    match decision {
+    match rx_approve.await.unwrap_or_default() {
         ReviewDecision::Approved | ReviewDecision::ApprovedForSession => {
             // Persist this command as pre‑approved for the
             // remainder of the session so future
@@ -3069,7 +3050,7 @@ async fn handle_sandbox_error(
                         sandbox_type: SandboxType::None,
                         sandbox_policy: &turn_context.sandbox_policy,
                         sandbox_cwd: &turn_context.cwd,
-                        codex_linux_sandbox_exe: &sess.services.codex_linux_sandbox_exe,
+                        codex_linux_sandbox_exe: &sess.codex_linux_sandbox_exe,
                         stdout_stream: if exec_command_context.apply_patch.is_some() {
                             None
                         } else {
@@ -3423,7 +3404,7 @@ mod tests {
             }),
         ));
 
-        let actual = tokio_test::block_on(async { session.state.lock().await.history_snapshot() });
+        let actual = tokio_test::block_on(async { session.state.lock().await.history.contents() });
         assert_eq!(expected, actual);
     }
 
@@ -3436,7 +3417,7 @@ mod tests {
             session.record_initial_history(&turn_context, InitialHistory::Forked(rollout_items)),
         );
 
-        let actual = tokio_test::block_on(async { session.state.lock().await.history_snapshot() });
+        let actual = tokio_test::block_on(async { session.state.lock().await.history.contents() });
         assert_eq!(expected, actual);
     }
 
@@ -3660,24 +3641,22 @@ mod tests {
             shell_environment_policy: config.shell_environment_policy.clone(),
             tools_config,
             is_review_mode: false,
-            final_output_json_schema: None,
-        };
-        let services = SessionServices {
-            mcp_connection_manager: McpConnectionManager::default(),
-            session_manager: ExecSessionManager::default(),
-            unified_exec_manager: UnifiedExecSessionManager::default(),
-            notifier: UserNotifier::default(),
-            rollout: Mutex::new(None),
-            codex_linux_sandbox_exe: None,
-            user_shell: shell::Shell::Unknown,
-            show_raw_agent_reasoning: config.show_raw_agent_reasoning,
         };
         let session = Session {
             conversation_id,
             tx_event,
-            state: Mutex::new(SessionState::new()),
-            active_turn: Mutex::new(None),
-            services,
+            mcp_connection_manager: McpConnectionManager::default(),
+            session_manager: ExecSessionManager::default(),
+            unified_exec_manager: UnifiedExecSessionManager::default(),
+            notify: None,
+            rollout: Mutex::new(None),
+            state: Mutex::new(State {
+                history: ConversationHistory::new(),
+                ..Default::default()
+            }),
+            codex_linux_sandbox_exe: None,
+            user_shell: shell::Shell::Unknown,
+            show_raw_agent_reasoning: config.show_raw_agent_reasoning,
             next_internal_sub_id: AtomicU64::new(0),
         };
         (session, turn_context)

codex-rs/core/src/codex/compact.rs

@@ -18,7 +18,6 @@ use crate::protocol::InputMessageKind;
 use crate::protocol::TaskCompleteEvent;
 use crate::protocol::TaskStartedEvent;
 use crate::protocol::TurnContextItem;
-use crate::truncate::truncate_middle;
 use crate::util::backoff;
 use askama::Template;
 use codex_protocol::models::ContentItem;
@@ -27,8 +26,8 @@ use codex_protocol::models::ResponseItem;
 use codex_protocol::protocol::RolloutItem;
 use futures::prelude::*;
 
-pub const SUMMARIZATION_PROMPT: &str = include_str!("../../templates/compact/prompt.md");
-const COMPACT_USER_MESSAGE_MAX_TOKENS: usize = 20_000;
+pub(super) const COMPACT_TRIGGER_TEXT: &str = "Start Summarization";
+const SUMMARIZATION_PROMPT: &str = include_str!("../../templates/compact/prompt.md");
 
 #[derive(Template)]
 #[template(path = "compact/history_bridge.md", escape = "none")]
@@ -43,7 +42,13 @@ pub(super) async fn spawn_compact_task(
     sub_id: String,
     input: Vec<InputItem>,
 ) {
-    let task = AgentTask::compact(sess.clone(), turn_context, sub_id, input);
+    let task = AgentTask::compact(
+        sess.clone(),
+        turn_context,
+        sub_id,
+        input,
+        SUMMARIZATION_PROMPT.to_string(),
+    );
     sess.set_task(task).await;
 }
 
@@ -53,9 +58,17 @@ pub(super) async fn run_inline_auto_compact_task(
 ) {
     let sub_id = sess.next_internal_sub_id();
     let input = vec![InputItem::Text {
-        text: SUMMARIZATION_PROMPT.to_string(),
+        text: COMPACT_TRIGGER_TEXT.to_string(),
     }];
-    run_compact_task_inner(sess, turn_context, sub_id, input, false).await;
+    run_compact_task_inner(
+        sess,
+        turn_context,
+        sub_id,
+        input,
+        SUMMARIZATION_PROMPT.to_string(),
+        false,
+    )
+    .await;
 }
 
 pub(super) async fn run_compact_task(
@@ -63,6 +76,7 @@ pub(super) async fn run_compact_task(
     turn_context: Arc<TurnContext>,
     sub_id: String,
     input: Vec<InputItem>,
+    compact_instructions: String,
 ) {
     let start_event = Event {
         id: sub_id.clone(),
@@ -71,7 +85,15 @@ pub(super) async fn run_compact_task(
         }),
     };
     sess.send_event(start_event).await;
-    run_compact_task_inner(sess.clone(), turn_context, sub_id.clone(), input, true).await;
+    run_compact_task_inner(
+        sess.clone(),
+        turn_context,
+        sub_id.clone(),
+        input,
+        compact_instructions,
+        true,
+    )
+    .await;
     let event = Event {
         id: sub_id,
         msg: EventMsg::TaskComplete(TaskCompleteEvent {
@@ -86,16 +108,19 @@ async fn run_compact_task_inner(
     turn_context: Arc<TurnContext>,
     sub_id: String,
     input: Vec<InputItem>,
+    compact_instructions: String,
     remove_task_on_completion: bool,
 ) {
     let initial_input_for_turn: ResponseInputItem = ResponseInputItem::from(input);
+    let instructions_override = compact_instructions;
     let turn_input = sess
         .turn_input_with_history(vec![initial_input_for_turn.clone().into()])
         .await;
 
     let prompt = Prompt {
         input: turn_input,
-        ..Default::default()
+        tools: Vec::new(),
+        base_instructions_override: Some(instructions_override),
     };
 
     let max_retries = turn_context.client.get_provider().stream_max_retries();
@@ -151,14 +176,17 @@ async fn run_compact_task_inner(
     if remove_task_on_completion {
         sess.remove_task(&sub_id).await;
     }
-    let history_snapshot = sess.history_snapshot().await;
+    let history_snapshot = {
+        let state = sess.state.lock().await;
+        state.history.contents()
+    };
     let summary_text = get_last_assistant_message_from_turn(&history_snapshot).unwrap_or_default();
     let user_messages = collect_user_messages(&history_snapshot);
     let initial_context = sess.build_initial_context(turn_context.as_ref());
     let new_history = build_compacted_history(initial_context, &user_messages, &summary_text);
     {
         let mut state = sess.state.lock().await;
-        state.replace_history(new_history);
+        state.history.replace(new_history);
     }
 
     let rollout_item = RolloutItem::Compacted(CompactedItem {
@@ -220,17 +248,11 @@ pub(crate) fn build_compacted_history(
     summary_text: &str,
 ) -> Vec<ResponseItem> {
     let mut history = initial_context;
-    let mut user_messages_text = if user_messages.is_empty() {
+    let user_messages_text = if user_messages.is_empty() {
         "(none)".to_string()
     } else {
         user_messages.join("\n\n")
     };
-    // Truncate the concatenated prior user messages so the bridge message
-    // stays well under the context window (approx. 4 bytes/token).
-    let max_bytes = COMPACT_USER_MESSAGE_MAX_TOKENS * 4;
-    if user_messages_text.len() > max_bytes {
-        user_messages_text = truncate_middle(&user_messages_text, max_bytes).0;
-    }
     let summary_text = if summary_text.is_empty() {
         "(no summary available)".to_string()
     } else {
@@ -267,7 +289,8 @@ async fn drain_to_completed(
         };
         match event {
             Ok(ResponseEvent::OutputItemDone(item)) => {
-                sess.record_into_history(std::slice::from_ref(&item)).await;
+                let mut state = sess.state.lock().await;
+                state.history.record_items(std::slice::from_ref(&item));
             }
             Ok(ResponseEvent::Completed { .. }) => {
                 return Ok(());
@@ -373,38 +396,4 @@ mod tests {
 
         assert_eq!(vec!["real user message".to_string()], collected);
     }
-
-    #[test]
-    fn build_compacted_history_truncates_overlong_user_messages() {
-        // Prepare a very large prior user message so the aggregated
-        // `user_messages_text` exceeds the truncation threshold used by
-        // `build_compacted_history` (80k bytes).
-        let big = "X".repeat(200_000);
-        let history = build_compacted_history(Vec::new(), std::slice::from_ref(&big), "SUMMARY");
-
-        // Expect exactly one bridge message added to history (plus any initial context we provided, which is none).
-        assert_eq!(history.len(), 1);
-
-        // Extract the text content of the bridge message.
-        let bridge_text = match &history[0] {
-            ResponseItem::Message { role, content, .. } if role == "user" => {
-                content_items_to_text(content).unwrap_or_default()
-            }
-            other => panic!("unexpected item in history: {other:?}"),
-        };
-
-        // The bridge should contain the truncation marker and not the full original payload.
-        assert!(
-            bridge_text.contains("tokens truncated"),
-            "expected truncation marker in bridge message"
-        );
-        assert!(
-            !bridge_text.contains(&big),
-            "bridge should not include the full oversized user text"
-        );
-        assert!(
-            bridge_text.contains("SUMMARY"),
-            "bridge should include the provided summary text"
-        );
-    }
 }

codex-rs/core/src/config.rs

@@ -37,7 +37,7 @@ use toml_edit::DocumentMut;
 use toml_edit::Item as TomlItem;
 use toml_edit::Table as TomlTable;
 
-const OPENAI_DEFAULT_MODEL: &str = "gpt-5-codex";
+const OPENAI_DEFAULT_MODEL: &str = "gpt-5";
 const OPENAI_DEFAULT_REVIEW_MODEL: &str = "gpt-5-codex";
 pub const GPT_5_CODEX_MEDIUM_MODEL: &str = "gpt-5-codex";
 
@@ -54,7 +54,7 @@ pub struct Config {
     /// Optional override of model selection.
     pub model: String,
 
-    /// Model used specifically for review sessions. Defaults to "gpt-5-codex".
+    /// Model used specifically for review sessions. Defaults to "gpt-5".
     pub review_model: String,
 
     pub model_family: ModelFamily,
@@ -333,12 +333,14 @@ pub fn write_global_mcp_servers(
                 entry["env"] = TomlItem::Table(env_table);
             }
 
-            if let Some(timeout) = config.startup_timeout_sec {
-                entry["startup_timeout_sec"] = toml_edit::value(timeout.as_secs_f64());
-            }
-
-            if let Some(timeout) = config.tool_timeout_sec {
-                entry["tool_timeout_sec"] = toml_edit::value(timeout.as_secs_f64());
+            if let Some(timeout) = config.startup_timeout_ms {
+                let timeout = i64::try_from(timeout).map_err(|_| {
+                    std::io::Error::new(
+                        std::io::ErrorKind::InvalidData,
+                        "startup_timeout_ms exceeds supported range",
+                    )
+                })?;
+                entry["startup_timeout_ms"] = toml_edit::value(timeout);
             }
 
             doc["mcp_servers"][name.as_str()] = TomlItem::Table(entry);
@@ -1166,7 +1168,6 @@ mod tests {
     use super::*;
     use pretty_assertions::assert_eq;
 
-    use std::time::Duration;
     use tempfile::TempDir;
 
     #[test]
@@ -1291,8 +1292,7 @@ exclude_slash_tmp = true
                 command: "echo".to_string(),
                 args: vec!["hello".to_string()],
                 env: None,
-                startup_timeout_sec: Some(Duration::from_secs(3)),
-                tool_timeout_sec: Some(Duration::from_secs(5)),
+                startup_timeout_ms: None,
             },
         );
 
@@ -1303,8 +1303,6 @@ exclude_slash_tmp = true
         let docs = loaded.get("docs").expect("docs entry");
         assert_eq!(docs.command, "echo");
         assert_eq!(docs.args, vec!["hello".to_string()]);
-        assert_eq!(docs.startup_timeout_sec, Some(Duration::from_secs(3)));
-        assert_eq!(docs.tool_timeout_sec, Some(Duration::from_secs(5)));
 
         let empty = BTreeMap::new();
         write_global_mcp_servers(codex_home.path(), &empty)?;
@@ -1314,28 +1312,6 @@ exclude_slash_tmp = true
         Ok(())
     }
 
-    #[test]
-    fn load_global_mcp_servers_accepts_legacy_ms_field() -> anyhow::Result<()> {
-        let codex_home = TempDir::new()?;
-        let config_path = codex_home.path().join(CONFIG_TOML_FILE);
-
-        std::fs::write(
-            &config_path,
-            r#"
-[mcp_servers]
-[mcp_servers.docs]
-command = "echo"
-startup_timeout_ms = 2500
-"#,
-        )?;
-
-        let servers = load_global_mcp_servers(codex_home.path())?;
-        let docs = servers.get("docs").expect("docs entry");
-        assert_eq!(docs.startup_timeout_sec, Some(Duration::from_millis(2500)));
-
-        Ok(())
-    }
-
     #[tokio::test]
     async fn persist_model_selection_updates_defaults() -> anyhow::Result<()> {
         let codex_home = TempDir::new()?;
@@ -1366,7 +1342,7 @@ startup_timeout_ms = 2500
         tokio::fs::write(
             &config_path,
             r#"
-model = "gpt-5-codex"
+model = "gpt-5"
 model_reasoning_effort = "medium"
 
 [profiles.dev]
@@ -1441,7 +1417,7 @@ model = "gpt-4"
 model_reasoning_effort = "medium"
 
 [profiles.prod]
-model = "gpt-5-codex"
+model = "gpt-5"
 "#,
         )
         .await?;
@@ -1472,7 +1448,7 @@ model = "gpt-5-codex"
                 .profiles
                 .get("prod")
                 .and_then(|profile| profile.model.as_deref()),
-            Some("gpt-5-codex"),
+            Some("gpt-5"),
         );
 
         Ok(())

codex-rs/core/src/config_edit.rs

@@ -136,7 +136,7 @@ async fn persist_overrides_with_behavior(
     } else {
         doc.get("profile")
             .and_then(|i| i.as_str())
-            .map(str::to_string)
+            .map(|s| s.to_string())
     };
 
     let mut mutated = false;
@@ -228,7 +228,7 @@ mod tests {
             codex_home,
             None,
             &[
-                (&[CONFIG_KEY_MODEL], "gpt-5-codex"),
+                (&[CONFIG_KEY_MODEL], "gpt-5"),
                 (&[CONFIG_KEY_EFFORT], "high"),
             ],
         )
@@ -236,7 +236,7 @@ mod tests {
         .expect("persist");
 
         let contents = read_config(codex_home).await;
-        let expected = r#"model = "gpt-5-codex"
+        let expected = r#"model = "gpt-5"
 model_reasoning_effort = "high"
 "#;
         assert_eq!(contents, expected);
@@ -348,7 +348,7 @@ model_reasoning_effort = "high"
             &[
                 (&["a", "b", "c"], "v"),
                 (&["x"], "y"),
-                (&["profiles", "p1", CONFIG_KEY_MODEL], "gpt-5-codex"),
+                (&["profiles", "p1", CONFIG_KEY_MODEL], "gpt-5"),
             ],
         )
         .await
@@ -361,7 +361,7 @@ model_reasoning_effort = "high"
 c = "v"
 
 [profiles.p1]
-model = "gpt-5-codex"
+model = "gpt-5"
 "#;
         assert_eq!(contents, expected);
     }
@@ -454,7 +454,7 @@ existing = "keep"
             codex_home,
             None,
             &[
-                (&[CONFIG_KEY_MODEL], "gpt-5-codex"),
+                (&[CONFIG_KEY_MODEL], "gpt-5"),
                 (&[CONFIG_KEY_EFFORT], "minimal"),
             ],
         )
@@ -466,7 +466,7 @@ existing = "keep"
 # should be preserved
 
 existing = "keep"
-model = "gpt-5-codex"
+model = "gpt-5"
 model_reasoning_effort = "minimal"
 "#;
         assert_eq!(contents, expected);
@@ -524,7 +524,7 @@ model = "o3"
         let codex_home = tmpdir.path();
 
         // Seed with a model value only
-        let seed = "model = \"gpt-5-codex\"\n";
+        let seed = "model = \"gpt-5\"\n";
         tokio::fs::write(codex_home.join(CONFIG_TOML_FILE), seed)
             .await
             .expect("seed write");
@@ -535,7 +535,7 @@ model = "o3"
             .expect("persist");
 
         let contents = read_config(codex_home).await;
-        let expected = r#"model = "gpt-5-codex"
+        let expected = r#"model = "gpt-5"
 model_reasoning_effort = "high"
 "#;
         assert_eq!(contents, expected);
@@ -579,7 +579,7 @@ model = "o4-mini"
 
         // No active profile key; we'll target an explicit override
         let seed = r#"[profiles.team]
-model = "gpt-5-codex"
+model = "gpt-5"
 "#;
         tokio::fs::write(codex_home.join(CONFIG_TOML_FILE), seed)
             .await
@@ -595,7 +595,7 @@ model = "gpt-5-codex"
 
         let contents = read_config(codex_home).await;
         let expected = r#"[profiles.team]
-model = "gpt-5-codex"
+model = "gpt-5"
 model_reasoning_effort = "minimal"
 "#;
         assert_eq!(contents, expected);
@@ -611,7 +611,7 @@ model_reasoning_effort = "minimal"
             codex_home,
             None,
             &[
-                (&[CONFIG_KEY_MODEL], Some("gpt-5-codex")),
+                (&[CONFIG_KEY_MODEL], Some("gpt-5")),
                 (&[CONFIG_KEY_EFFORT], None),
             ],
         )
@@ -619,7 +619,7 @@ model_reasoning_effort = "minimal"
         .expect("persist");
 
         let contents = read_config(codex_home).await;
-        let expected = "model = \"gpt-5-codex\"\n";
+        let expected = "model = \"gpt-5\"\n";
         assert_eq!(contents, expected);
     }
 
@@ -670,7 +670,7 @@ model = "o3"
         let tmpdir = tempdir().expect("tmp");
         let codex_home = tmpdir.path();
 
-        let seed = r#"model = "gpt-5-codex"
+        let seed = r#"model = "gpt-5"
 model_reasoning_effort = "medium"
 "#;
         tokio::fs::write(codex_home.join(CONFIG_TOML_FILE), seed)

codex-rs/core/src/config_types.rs

@@ -5,15 +5,11 @@
 
 use std::collections::HashMap;
 use std::path::PathBuf;
-use std::time::Duration;
 use wildmatch::WildMatchPattern;
 
 use serde::Deserialize;
-use serde::Deserializer;
-use serde::Serialize;
-use serde::de::Error as SerdeError;
 
-#[derive(Serialize, Debug, Clone, PartialEq)]
+#[derive(Deserialize, Debug, Clone, PartialEq)]
 pub struct McpServerConfig {
     pub command: String,
 
@@ -23,84 +19,9 @@ pub struct McpServerConfig {
     #[serde(default)]
     pub env: Option<HashMap<String, String>>,
 
-    /// Startup timeout in seconds for initializing MCP server & initially listing tools.
-    #[serde(
-        default,
-        with = "option_duration_secs",
-        skip_serializing_if = "Option::is_none"
-    )]
-    pub startup_timeout_sec: Option<Duration>,
-
-    /// Default timeout for MCP tool calls initiated via this server.
-    #[serde(default, with = "option_duration_secs")]
-    pub tool_timeout_sec: Option<Duration>,
-}
-
-impl<'de> Deserialize<'de> for McpServerConfig {
-    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
-    where
-        D: Deserializer<'de>,
-    {
-        #[derive(Deserialize)]
-        struct RawMcpServerConfig {
-            command: String,
-            #[serde(default)]
-            args: Vec<String>,
-            #[serde(default)]
-            env: Option<HashMap<String, String>>,
-            #[serde(default)]
-            startup_timeout_sec: Option<f64>,
-            #[serde(default)]
-            startup_timeout_ms: Option<u64>,
-            #[serde(default, with = "option_duration_secs")]
-            tool_timeout_sec: Option<Duration>,
-        }
-
-        let raw = RawMcpServerConfig::deserialize(deserializer)?;
-
-        let startup_timeout_sec = match (raw.startup_timeout_sec, raw.startup_timeout_ms) {
-            (Some(sec), _) => {
-                let duration = Duration::try_from_secs_f64(sec).map_err(SerdeError::custom)?;
-                Some(duration)
-            }
-            (None, Some(ms)) => Some(Duration::from_millis(ms)),
-            (None, None) => None,
-        };
-
-        Ok(Self {
-            command: raw.command,
-            args: raw.args,
-            env: raw.env,
-            startup_timeout_sec,
-            tool_timeout_sec: raw.tool_timeout_sec,
-        })
-    }
-}
-
-mod option_duration_secs {
-    use serde::Deserialize;
-    use serde::Deserializer;
-    use serde::Serializer;
-    use std::time::Duration;
-
-    pub fn serialize<S>(value: &Option<Duration>, serializer: S) -> Result<S::Ok, S::Error>
-    where
-        S: Serializer,
-    {
-        match value {
-            Some(duration) => serializer.serialize_some(&duration.as_secs_f64()),
-            None => serializer.serialize_none(),
-        }
-    }
-
-    pub fn deserialize<'de, D>(deserializer: D) -> Result<Option<Duration>, D::Error>
-    where
-        D: Deserializer<'de>,
-    {
-        let secs = Option::<f64>::deserialize(deserializer)?;
-        secs.map(|secs| Duration::try_from_secs_f64(secs).map_err(serde::de::Error::custom))
-            .transpose()
-    }
+    /// Startup timeout in milliseconds for initializing MCP server & initially listing tools.
+    #[serde(default)]
+    pub startup_timeout_ms: Option<u64>,
 }
 
 #[derive(Deserialize, Debug, Copy, Clone, PartialEq)]

codex-rs/core/src/custom_prompts.rs

@@ -52,7 +52,7 @@ pub async fn discover_prompts_in_excluding(
         let Some(name) = path
             .file_stem()
             .and_then(|s| s.to_str())
-            .map(str::to_string)
+            .map(|s| s.to_string())
         else {
             continue;
         };

codex-rs/core/src/error.rs

@@ -2,7 +2,6 @@ use crate::exec::ExecToolCallOutput;
 use crate::token_data::KnownPlan;
 use crate::token_data::PlanType;
 use codex_protocol::mcp_protocol::ConversationId;
-use codex_protocol::protocol::RateLimitSnapshot;
 use reqwest::StatusCode;
 use serde_json;
 use std::io;
@@ -105,9 +104,6 @@ pub enum CodexErr {
     #[error("codex-linux-sandbox was required but not provided")]
     LandlockSandboxExecutableNotProvided,
 
-    #[error("unsupported operation: {0}")]
-    UnsupportedOperation(String),
-
     // -----------------------------------------------------------------
     // Automatic conversions for common external error types
     // -----------------------------------------------------------------
@@ -139,7 +135,6 @@ pub enum CodexErr {
 pub struct UsageLimitReachedError {
     pub(crate) plan_type: Option<PlanType>,
     pub(crate) resets_in_seconds: Option<u64>,
-    pub(crate) rate_limits: Option<RateLimitSnapshot>,
 }
 
 impl std::fmt::Display for UsageLimitReachedError {
@@ -268,22 +263,11 @@ pub fn get_error_message_ui(e: &CodexErr) -> String {
 mod tests {
     use super::*;
 
-    fn rate_limit_snapshot() -> RateLimitSnapshot {
-        RateLimitSnapshot {
-            primary_used_percent: 0.5,
-            secondary_used_percent: 0.3,
-            primary_to_secondary_ratio_percent: 0.7,
-            primary_window_minutes: 60,
-            secondary_window_minutes: 120,
-        }
-    }
-
     #[test]
     fn usage_limit_reached_error_formats_plus_plan() {
         let err = UsageLimitReachedError {
             plan_type: Some(PlanType::Known(KnownPlan::Plus)),
             resets_in_seconds: None,
-            rate_limits: Some(rate_limit_snapshot()),
         };
         assert_eq!(
             err.to_string(),
@@ -296,7 +280,6 @@ mod tests {
         let err = UsageLimitReachedError {
             plan_type: Some(PlanType::Known(KnownPlan::Free)),
             resets_in_seconds: Some(3600),
-            rate_limits: Some(rate_limit_snapshot()),
         };
         assert_eq!(
             err.to_string(),
@@ -309,7 +292,6 @@ mod tests {
         let err = UsageLimitReachedError {
             plan_type: None,
             resets_in_seconds: None,
-            rate_limits: Some(rate_limit_snapshot()),
         };
         assert_eq!(
             err.to_string(),
@@ -322,7 +304,6 @@ mod tests {
         let err = UsageLimitReachedError {
             plan_type: Some(PlanType::Known(KnownPlan::Team)),
             resets_in_seconds: Some(3600),
-            rate_limits: Some(rate_limit_snapshot()),
         };
         assert_eq!(
             err.to_string(),
@@ -335,7 +316,6 @@ mod tests {
         let err = UsageLimitReachedError {
             plan_type: Some(PlanType::Known(KnownPlan::Business)),
             resets_in_seconds: None,
-            rate_limits: Some(rate_limit_snapshot()),
         };
         assert_eq!(
             err.to_string(),
@@ -348,7 +328,6 @@ mod tests {
         let err = UsageLimitReachedError {
             plan_type: Some(PlanType::Known(KnownPlan::Pro)),
             resets_in_seconds: None,
-            rate_limits: Some(rate_limit_snapshot()),
         };
         assert_eq!(
             err.to_string(),
@@ -361,7 +340,6 @@ mod tests {
         let err = UsageLimitReachedError {
             plan_type: None,
             resets_in_seconds: Some(5 * 60),
-            rate_limits: Some(rate_limit_snapshot()),
         };
         assert_eq!(
             err.to_string(),
@@ -374,7 +352,6 @@ mod tests {
         let err = UsageLimitReachedError {
             plan_type: Some(PlanType::Known(KnownPlan::Plus)),
             resets_in_seconds: Some(3 * 3600 + 32 * 60),
-            rate_limits: Some(rate_limit_snapshot()),
         };
         assert_eq!(
             err.to_string(),
@@ -387,7 +364,6 @@ mod tests {
         let err = UsageLimitReachedError {
             plan_type: None,
             resets_in_seconds: Some(2 * 86_400 + 3 * 3600 + 5 * 60),
-            rate_limits: Some(rate_limit_snapshot()),
         };
         assert_eq!(
             err.to_string(),
@@ -400,7 +376,6 @@ mod tests {
         let err = UsageLimitReachedError {
             plan_type: None,
             resets_in_seconds: Some(30),
-            rate_limits: Some(rate_limit_snapshot()),
         };
         assert_eq!(
             err.to_string(),

codex-rs/core/src/git_info.rs

@@ -108,61 +108,6 @@ pub async fn collect_git_info(cwd: &Path) -> Option<GitInfo> {
     Some(git_info)
 }
 
-/// A minimal commit summary entry used for pickers (subject + timestamp + sha).
-#[derive(Clone, Debug, Serialize, Deserialize)]
-pub struct CommitLogEntry {
-    pub sha: String,
-    /// Unix timestamp (seconds since epoch) of the commit time (committer time).
-    pub timestamp: i64,
-    /// Single-line subject of the commit message.
-    pub subject: String,
-}
-
-/// Return the last `limit` commits reachable from HEAD for the current branch.
-/// Each entry contains the SHA, commit timestamp (seconds), and subject line.
-/// Returns an empty vector if not in a git repo or on error/timeout.
-pub async fn recent_commits(cwd: &Path, limit: usize) -> Vec<CommitLogEntry> {
-    // Ensure we're in a git repo first to avoid noisy errors.
-    let Some(out) = run_git_command_with_timeout(&["rev-parse", "--git-dir"], cwd).await else {
-        return Vec::new();
-    };
-    if !out.status.success() {
-        return Vec::new();
-    }
-
-    let fmt = "%H%x1f%ct%x1f%s"; // <sha> <US> <commit_time> <US> <subject>
-    let n = limit.max(1).to_string();
-    let Some(log_out) =
-        run_git_command_with_timeout(&["log", "-n", &n, &format!("--pretty=format:{fmt}")], cwd)
-            .await
-    else {
-        return Vec::new();
-    };
-    if !log_out.status.success() {
-        return Vec::new();
-    }
-
-    let text = String::from_utf8_lossy(&log_out.stdout);
-    let mut entries: Vec<CommitLogEntry> = Vec::new();
-    for line in text.lines() {
-        let mut parts = line.split('\u{001f}');
-        let sha = parts.next().unwrap_or("").trim();
-        let ts_s = parts.next().unwrap_or("").trim();
-        let subject = parts.next().unwrap_or("").trim();
-        if sha.is_empty() || ts_s.is_empty() {
-            continue;
-        }
-        let timestamp = ts_s.parse::<i64>().unwrap_or(0);
-        entries.push(CommitLogEntry {
-            sha: sha.to_string(),
-            timestamp,
-            subject: subject.to_string(),
-        });
-    }
-
-    entries
-}
-
 /// Returns the closest git sha to HEAD that is on a remote as well as the diff to that sha.
 pub async fn git_diff_to_remote(cwd: &Path) -> Option<GitDiffToRemote> {
     get_git_repo_root(cwd)?;
@@ -200,7 +145,7 @@ async fn get_git_remotes(cwd: &Path) -> Option<Vec<String>> {
     let mut remotes: Vec<String> = String::from_utf8(output.stdout)
         .ok()?
         .lines()
-        .map(str::to_string)
+        .map(|s| s.to_string())
         .collect();
     if let Some(pos) = remotes.iter().position(|r| r == "origin") {
         let origin = remotes.remove(pos);
@@ -257,11 +202,6 @@ async fn get_default_branch(cwd: &Path) -> Option<String> {
     }
 
     // No remote-derived default; try common local defaults if they exist
-    get_default_branch_local(cwd).await
-}
-
-/// Attempt to determine the repository's default branch name from local branches.
-async fn get_default_branch_local(cwd: &Path) -> Option<String> {
     for candidate in ["main", "master"] {
         if let Some(verify) = run_git_command_with_timeout(
             &[
@@ -477,7 +417,7 @@ async fn diff_against_sha(cwd: &Path, sha: &GitSha) -> Option<String> {
         let untracked: Vec<String> = String::from_utf8(untracked_output.stdout)
             .ok()?
             .lines()
-            .map(str::to_string)
+            .map(|s| s.to_string())
             .filter(|s| !s.is_empty())
             .collect();
 
@@ -545,46 +485,6 @@ pub fn resolve_root_git_project_for_trust(cwd: &Path) -> Option<PathBuf> {
     git_dir_path.parent().map(Path::to_path_buf)
 }
 
-/// Returns a list of local git branches.
-/// Includes the default branch at the beginning of the list, if it exists.
-pub async fn local_git_branches(cwd: &Path) -> Vec<String> {
-    let mut branches: Vec<String> = if let Some(out) =
-        run_git_command_with_timeout(&["branch", "--format=%(refname:short)"], cwd).await
-        && out.status.success()
-    {
-        String::from_utf8_lossy(&out.stdout)
-            .lines()
-            .map(|s| s.trim().to_string())
-            .filter(|s| !s.is_empty())
-            .collect()
-    } else {
-        Vec::new()
-    };
-
-    branches.sort_unstable();
-
-    if let Some(base) = get_default_branch_local(cwd).await
-        && let Some(pos) = branches.iter().position(|name| name == &base)
-    {
-        let base_branch = branches.remove(pos);
-        branches.insert(0, base_branch);
-    }
-
-    branches
-}
-
-/// Returns the current checked out branch name.
-pub async fn current_branch_name(cwd: &Path) -> Option<String> {
-    let out = run_git_command_with_timeout(&["branch", "--show-current"], cwd).await?;
-    if !out.status.success() {
-        return None;
-    }
-    String::from_utf8(out.stdout)
-        .ok()
-        .map(|s| s.trim().to_string())
-        .filter(|name| !name.is_empty())
-}
-
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -651,80 +551,6 @@ mod tests {
         repo_path
     }
 
-    #[tokio::test]
-    async fn test_recent_commits_non_git_directory_returns_empty() {
-        let temp_dir = TempDir::new().expect("Failed to create temp dir");
-        let entries = recent_commits(temp_dir.path(), 10).await;
-        assert!(entries.is_empty(), "expected no commits outside a git repo");
-    }
-
-    #[tokio::test]
-    async fn test_recent_commits_orders_and_limits() {
-        use tokio::time::Duration;
-        use tokio::time::sleep;
-
-        let temp_dir = TempDir::new().expect("Failed to create temp dir");
-        let repo_path = create_test_git_repo(&temp_dir).await;
-
-        // Make three distinct commits with small delays to ensure ordering by timestamp.
-        fs::write(repo_path.join("file.txt"), "one").unwrap();
-        Command::new("git")
-            .args(["add", "file.txt"])
-            .current_dir(&repo_path)
-            .output()
-            .await
-            .expect("git add");
-        Command::new("git")
-            .args(["commit", "-m", "first change"])
-            .current_dir(&repo_path)
-            .output()
-            .await
-            .expect("git commit 1");
-
-        sleep(Duration::from_millis(1100)).await;
-
-        fs::write(repo_path.join("file.txt"), "two").unwrap();
-        Command::new("git")
-            .args(["add", "file.txt"])
-            .current_dir(&repo_path)
-            .output()
-            .await
-            .expect("git add 2");
-        Command::new("git")
-            .args(["commit", "-m", "second change"])
-            .current_dir(&repo_path)
-            .output()
-            .await
-            .expect("git commit 2");
-
-        sleep(Duration::from_millis(1100)).await;
-
-        fs::write(repo_path.join("file.txt"), "three").unwrap();
-        Command::new("git")
-            .args(["add", "file.txt"])
-            .current_dir(&repo_path)
-            .output()
-            .await
-            .expect("git add 3");
-        Command::new("git")
-            .args(["commit", "-m", "third change"])
-            .current_dir(&repo_path)
-            .output()
-            .await
-            .expect("git commit 3");
-
-        // Request the latest 3 commits; should be our three changes in reverse time order.
-        let entries = recent_commits(&repo_path, 3).await;
-        assert_eq!(entries.len(), 3);
-        assert_eq!(entries[0].subject, "third change");
-        assert_eq!(entries[1].subject, "second change");
-        assert_eq!(entries[2].subject, "first change");
-        // Basic sanity on SHA formatting
-        for e in entries {
-            assert!(e.sha.len() >= 7 && e.sha.chars().all(|c| c.is_ascii_hexdigit()));
-        }
-    }
-
     async fn create_test_git_repo_with_remote(temp_dir: &TempDir) -> (PathBuf, String) {
         let repo_path = create_test_git_repo(temp_dir).await;
         let remote_path = temp_dir.path().join("remote.git");

codex-rs/core/src/internal_storage.rs

@@ -7,27 +7,14 @@ use std::path::PathBuf;
 
 pub(crate) const INTERNAL_STORAGE_FILE: &str = "internal_storage.json";
 
-#[derive(Debug, Clone, Serialize, Deserialize)]
+#[derive(Debug, Default, Clone, Serialize, Deserialize)]
 pub struct InternalStorage {
     #[serde(skip)]
     storage_path: PathBuf,
-    #[serde(default = "default_gpt_5_codex_model_prompt_seen")]
+    #[serde(default)]
     pub gpt_5_codex_model_prompt_seen: bool,
 }
 
-const fn default_gpt_5_codex_model_prompt_seen() -> bool {
-    true
-}
-
-impl Default for InternalStorage {
-    fn default() -> Self {
-        Self {
-            storage_path: PathBuf::new(),
-            gpt_5_codex_model_prompt_seen: default_gpt_5_codex_model_prompt_seen(),
-        }
-    }
-}
-
 // TODO(jif) generalise all the file writers and build proper async channel inserters.
 impl InternalStorage {
     pub fn load(codex_home: &Path) -> Self {

codex-rs/core/src/is_safe_command.rs

@@ -160,10 +160,9 @@ fn is_valid_sed_n_arg(arg: Option<&str>) -> bool {
 #[cfg(test)]
 mod tests {
     use super::*;
-    use std::string::ToString;
 
     fn vec_str(args: &[&str]) -> Vec<String> {
-        args.iter().map(ToString::to_string).collect()
+        args.iter().map(|s| s.to_string()).collect()
     }
 
     #[test]

codex-rs/core/src/lib.rs

@@ -47,7 +47,6 @@ pub use model_provider_info::create_oss_provider_with_base_url;
 mod conversation_manager;
 mod event_mapping;
 pub mod review_format;
-mod services;
 pub use codex_protocol::protocol::InitialHistory;
 pub use conversation_manager::ConversationManager;
 pub use conversation_manager::NewConversation;
@@ -76,7 +75,6 @@ pub use rollout::find_conversation_path_by_id_str;
 pub use rollout::list::ConversationItem;
 pub use rollout::list::ConversationsPage;
 pub use rollout::list::Cursor;
-mod state;
 mod user_notification;
 pub mod util;
 

codex-rs/core/src/mcp_connection_manager.rs

@@ -40,9 +40,6 @@ const MAX_TOOL_NAME_LENGTH: usize = 64;
 /// Default timeout for initializing MCP server & initially listing tools.
 const DEFAULT_STARTUP_TIMEOUT: Duration = Duration::from_secs(10);
 
-/// Default timeout for individual tool calls.
-const DEFAULT_TOOL_TIMEOUT: Duration = Duration::from_secs(60);
-
 /// Map that holds a startup error for every MCP server that could **not** be
 /// spawned successfully.
 pub type ClientStartErrors = HashMap<String, anyhow::Error>;
@@ -88,7 +85,6 @@ struct ToolInfo {
 struct ManagedClient {
     client: Arc<McpClient>,
     startup_timeout: Duration,
-    tool_timeout: Option<Duration>,
 }
 
 /// A thin wrapper around a set of running [`McpClient`] instances.
@@ -136,9 +132,10 @@ impl McpConnectionManager {
                 continue;
             }
 
-            let startup_timeout = cfg.startup_timeout_sec.unwrap_or(DEFAULT_STARTUP_TIMEOUT);
-
-            let tool_timeout = cfg.tool_timeout_sec.unwrap_or(DEFAULT_TOOL_TIMEOUT);
+            let startup_timeout = cfg
+                .startup_timeout_ms
+                .map(Duration::from_millis)
+                .unwrap_or(DEFAULT_STARTUP_TIMEOUT);
 
             join_set.spawn(async move {
                 let McpServerConfig {
@@ -174,19 +171,19 @@ impl McpConnectionManager {
                             protocol_version: mcp_types::MCP_SCHEMA_VERSION.to_owned(),
                         };
                         let initialize_notification_params = None;
-                        let init_result = client
+                        match client
                             .initialize(
                                 params,
                                 initialize_notification_params,
                                 Some(startup_timeout),
                             )
-                            .await;
-                        (
-                            (server_name, tool_timeout),
-                            init_result.map(|_| (client, startup_timeout)),
-                        )
+                            .await
+                        {
+                            Ok(_response) => (server_name, Ok((client, startup_timeout))),
+                            Err(e) => (server_name, Err(e)),
+                        }
                     }
-                    Err(e) => ((server_name, tool_timeout), Err(e.into())),
+                    Err(e) => (server_name, Err(e.into())),
                 }
             });
         }
@@ -194,8 +191,8 @@ impl McpConnectionManager {
         let mut clients: HashMap<String, ManagedClient> = HashMap::with_capacity(join_set.len());
 
         while let Some(res) = join_set.join_next().await {
-            let ((server_name, tool_timeout), client_res) = match res {
-                Ok(result) => result,
+            let (server_name, client_res) = match res {
+                Ok((server_name, client_res)) => (server_name, client_res),
                 Err(e) => {
                     warn!("Task panic when starting MCP server: {e:#}");
                     continue;
@@ -209,7 +206,6 @@ impl McpConnectionManager {
                         ManagedClient {
                             client: Arc::new(client),
                             startup_timeout,
-                            tool_timeout: Some(tool_timeout),
                         },
                     );
                 }
@@ -247,13 +243,14 @@ impl McpConnectionManager {
         server: &str,
         tool: &str,
         arguments: Option<serde_json::Value>,
+        timeout: Option<Duration>,
     ) -> Result<mcp_types::CallToolResult> {
-        let managed = self
+        let client = self
             .clients
             .get(server)
-            .ok_or_else(|| anyhow!("unknown MCP server '{server}'"))?;
-        let client = managed.client.clone();
-        let timeout = managed.tool_timeout;
+            .ok_or_else(|| anyhow!("unknown MCP server '{server}'"))?
+            .client
+            .clone();
 
         client
             .call_tool(tool.to_string(), arguments, timeout)

codex-rs/core/src/mcp_tool_call.rs

@@ -1,3 +1,4 @@
+use std::time::Duration;
 use std::time::Instant;
 
 use tracing::error;
@@ -20,6 +21,7 @@ pub(crate) async fn handle_mcp_tool_call(
     server: String,
     tool_name: String,
     arguments: String,
+    timeout: Option<Duration>,
 ) -> ResponseInputItem {
     // Parse the `arguments` as JSON. An empty string is OK, but invalid JSON
     // is not.
@@ -56,7 +58,7 @@ pub(crate) async fn handle_mcp_tool_call(
     let start = Instant::now();
     // Perform the tool call.
     let result = sess
-        .call_tool(&server, &tool_name, arguments_value.clone())
+        .call_tool(&server, &tool_name, arguments_value.clone(), timeout)
         .await
         .map_err(|e| format!("tool call error: {e}"));
     let tool_call_end_event = EventMsg::McpToolCallEnd(McpToolCallEndEvent {

codex-rs/core/src/openai_model_info.rs

@@ -61,12 +61,6 @@ pub(crate) fn get_model_info(model_family: &ModelFamily) -> Option<ModelInfo> {
         // https://platform.openai.com/docs/models/gpt-3.5-turbo
         "gpt-3.5-turbo" => Some(ModelInfo::new(16_385, 4_096)),
 
-        _ if slug.starts_with("gpt-5-codex") => Some(ModelInfo {
-            context_window: 272_000,
-            max_output_tokens: 128_000,
-            auto_compact_token_limit: Some(250_000),
-        }),
-
         _ if slug.starts_with("gpt-5") => Some(ModelInfo::new(272_000, 128_000)),
 
         _ if slug.starts_with("codex-") => Some(ModelInfo::new(272_000, 128_000)),

codex-rs/core/src/openai_tools.rs

@@ -400,7 +400,10 @@ fn sanitize_json_schema(value: &mut JsonValue) {
             }
 
             // Normalize/ensure type
-            let mut ty = map.get("type").and_then(|v| v.as_str()).map(str::to_string);
+            let mut ty = map
+                .get("type")
+                .and_then(|v| v.as_str())
+                .map(|s| s.to_string());
 
             // If type is an array (union), pick first supported; else leave to inference
             if ty.is_none()

codex-rs/core/src/parse_command.rs

@@ -40,7 +40,7 @@ impl From<ParsedCommand> for codex_protocol::parse_command::ParsedCommand {
 }
 
 fn shlex_join(tokens: &[String]) -> String {
-    shlex_try_join(tokens.iter().map(String::as_str))
+    shlex_try_join(tokens.iter().map(|s| s.as_str()))
         .unwrap_or_else(|_| "<command included NUL byte>".to_string())
 }
 
@@ -72,14 +72,13 @@ pub fn parse_command(command: &[String]) -> Vec<ParsedCommand> {
 /// Tests are at the top to encourage using TDD + Codex to fix the implementation.
 mod tests {
     use super::*;
-    use std::string::ToString;
 
     fn shlex_split_safe(s: &str) -> Vec<String> {
-        shlex_split(s).unwrap_or_else(|| s.split_whitespace().map(ToString::to_string).collect())
+        shlex_split(s).unwrap_or_else(|| s.split_whitespace().map(|s| s.to_string()).collect())
     }
 
     fn vec_str(args: &[&str]) -> Vec<String> {
-        args.iter().map(ToString::to_string).collect()
+        args.iter().map(|s| s.to_string()).collect()
     }
 
     fn assert_parsed(args: &[String], expected: Vec<ParsedCommand>) {
@@ -895,7 +894,7 @@ fn simplify_once(commands: &[ParsedCommand]) -> Option<Vec<ParsedCommand>> {
 
     // echo ... && ...rest => ...rest
     if let ParsedCommand::Unknown { cmd } = &commands[0]
-        && shlex_split(cmd).is_some_and(|t| t.first().map(String::as_str) == Some("echo"))
+        && shlex_split(cmd).is_some_and(|t| t.first().map(|s| s.as_str()) == Some("echo"))
     {
         return Some(commands[1..].to_vec());
     }
@@ -903,7 +902,7 @@ fn simplify_once(commands: &[ParsedCommand]) -> Option<Vec<ParsedCommand>> {
     // cd foo && [any command] => [any command] (keep non-cd when a cd is followed by something)
     if let Some(idx) = commands.iter().position(|pc| match pc {
         ParsedCommand::Unknown { cmd } => {
-            shlex_split(cmd).is_some_and(|t| t.first().map(String::as_str) == Some("cd"))
+            shlex_split(cmd).is_some_and(|t| t.first().map(|s| s.as_str()) == Some("cd"))
         }
         _ => false,
     }) && commands.len() > idx + 1
@@ -1036,7 +1035,7 @@ fn short_display_path(path: &str) -> String {
     });
     parts
         .next()
-        .map(str::to_string)
+        .map(|s| s.to_string())
         .unwrap_or_else(|| trimmed.to_string())
 }
 
@@ -1191,8 +1190,8 @@ fn parse_bash_lc_commands(original: &[String]) -> Option<Vec<ParsedCommand>> {
                         if had_connectors {
                             let has_pipe = script_tokens.iter().any(|t| t == "|");
                             let has_sed_n = script_tokens.windows(2).any(|w| {
-                                w.first().map(String::as_str) == Some("sed")
-                                    && w.get(1).map(String::as_str) == Some("-n")
+                                w.first().map(|s| s.as_str()) == Some("sed")
+                                    && w.get(1).map(|s| s.as_str()) == Some("-n")
                             });
                             if has_pipe && has_sed_n {
                                 ParsedCommand::Read {
@@ -1272,7 +1271,7 @@ fn is_small_formatting_command(tokens: &[String]) -> bool {
             // Keep `sed -n <range> file` (treated as a file read elsewhere);
             // otherwise consider it a formatting helper in a pipeline.
             tokens.len() < 4
-                || !(tokens[1] == "-n" && is_valid_sed_n_arg(tokens.get(2).map(String::as_str)))
+                || !(tokens[1] == "-n" && is_valid_sed_n_arg(tokens.get(2).map(|s| s.as_str())))
         }
         _ => false,
     }
@@ -1319,7 +1318,7 @@ fn summarize_main_tokens(main_cmd: &[String]) -> ParsedCommand {
                 (None, non_flags.first().map(|s| short_display_path(s)))
             } else {
                 (
-                    non_flags.first().cloned().map(String::from),
+                    non_flags.first().cloned().map(|s| s.to_string()),
                     non_flags.get(1).map(|s| short_display_path(s)),
                 )
             };
@@ -1354,7 +1353,7 @@ fn summarize_main_tokens(main_cmd: &[String]) -> ParsedCommand {
                 .collect();
             // Do not shorten the query: grep patterns may legitimately contain slashes
             // and should be preserved verbatim. Only paths should be shortened.
-            let query = non_flags.first().cloned().map(String::from);
+            let query = non_flags.first().cloned().map(|s| s.to_string());
             let path = non_flags.get(1).map(|s| short_display_path(s));
             ParsedCommand::Search {
                 cmd: shlex_join(main_cmd),
@@ -1364,7 +1363,7 @@ fn summarize_main_tokens(main_cmd: &[String]) -> ParsedCommand {
         }
         Some((head, tail)) if head == "cat" => {
             // Support both `cat <file>` and `cat -- <file>` forms.
-            let effective_tail: &[String] = if tail.first().map(String::as_str) == Some("--") {
+            let effective_tail: &[String] = if tail.first().map(|s| s.as_str()) == Some("--") {
                 &tail[1..]
             } else {
                 tail
@@ -1480,7 +1479,7 @@ fn summarize_main_tokens(main_cmd: &[String]) -> ParsedCommand {
             if head == "sed"
                 && tail.len() >= 3
                 && tail[0] == "-n"
-                && is_valid_sed_n_arg(tail.get(1).map(String::as_str)) =>
+                && is_valid_sed_n_arg(tail.get(1).map(|s| s.as_str())) =>
         {
             if let Some(path) = tail.get(2) {
                 let name = short_display_path(path);

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

@@ -1,23 +0,0 @@
-//! Group long‑lived helpers/managers for a session.
-
-use std::path::PathBuf;
-
-use tokio::sync::Mutex;
-
-use crate::exec_command::ExecSessionManager;
-use crate::mcp_connection_manager::McpConnectionManager;
-use crate::rollout::RolloutRecorder;
-use crate::unified_exec::UnifiedExecSessionManager;
-use crate::user_notification::UserNotifier;
-
-/// Container for side‑effectful services and helpers used by `Session`.
-pub(crate) struct SessionServices {
-    pub(crate) mcp_connection_manager: McpConnectionManager,
-    pub(crate) session_manager: ExecSessionManager,
-    pub(crate) unified_exec_manager: UnifiedExecSessionManager,
-    pub(crate) notifier: UserNotifier,
-    pub(crate) rollout: Mutex<Option<RolloutRecorder>>,
-    pub(crate) codex_linux_sandbox_exe: Option<PathBuf>,
-    pub(crate) user_shell: crate::shell::Shell,
-    pub(crate) show_raw_agent_reasoning: bool,
-}

codex-rs/core/src/shell.rs

@@ -73,7 +73,7 @@ impl Shell {
                         return Some(command);
                     }
 
-                    let joined = shlex::try_join(command.iter().map(String::as_str)).ok();
+                    let joined = shlex::try_join(command.iter().map(|s| s.as_str())).ok();
                     return joined.map(|arg| {
                         vec![
                             ps.exe.clone(),
@@ -111,7 +111,7 @@ fn format_shell_invocation_with_rc(
     rc_path: &str,
 ) -> Option<Vec<String>> {
     let joined = strip_bash_lc(command)
-        .or_else(|| shlex::try_join(command.iter().map(String::as_str)).ok())?;
+        .or_else(|| shlex::try_join(command.iter().map(|s| s.as_str())).ok())?;
 
     let rc_command = if std::path::Path::new(rc_path).exists() {
         format!("source {rc_path} && ({joined})")
@@ -224,7 +224,6 @@ pub async fn default_user_shell() -> Shell {
 mod tests {
     use super::*;
     use std::process::Command;
-    use std::string::ToString;
 
     #[tokio::test]
     async fn test_current_shell_detects_zsh() {
@@ -328,7 +327,7 @@ mod tests {
             });
 
             let actual_cmd = shell
-                .format_default_shell_invocation(input.iter().map(ToString::to_string).collect());
+                .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()))
@@ -372,7 +371,6 @@ mod tests {
 #[cfg(target_os = "macos")]
 mod macos_tests {
     use super::*;
-    use std::string::ToString;
 
     #[tokio::test]
     async fn test_run_with_profile_escaping_and_execution() {
@@ -436,7 +434,7 @@ mod macos_tests {
             });
 
             let actual_cmd = shell
-                .format_default_shell_invocation(input.iter().map(ToString::to_string).collect());
+                .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()))
@@ -561,10 +559,10 @@ mod tests_windows {
 
         for (shell, input, expected_cmd) in cases {
             let actual_cmd = shell
-                .format_default_shell_invocation(input.iter().map(|s| (*s).to_string()).collect());
+                .format_default_shell_invocation(input.iter().map(|s| s.to_string()).collect());
             assert_eq!(
                 actual_cmd,
-                Some(expected_cmd.iter().map(|s| (*s).to_string()).collect())
+                Some(expected_cmd.iter().map(|s| s.to_string()).collect())
             );
         }
     }

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

@@ -1,18 +0,0 @@
-//! Session/turn state module.
-//!
-//! Encapsulates all mutable state for a Codex session and the currently active
-//! turn. The goal is to present lock-safe, narrow APIs so other modules never
-//! need to poke at raw mutexes or internal fields.
-//!
-//! Locking guidelines
-//! - Lock ordering: `SessionState` → `ActiveTurn` → `TurnState`.
-//! - Never hold a lock across an `.await`. Extract minimal data and drop the
-//!   guard before awaiting.
-//! - Prefer helper methods on these types rather than exposing fields.
-
-mod session;
-mod turn;
-
-pub(crate) use session::SessionState;
-pub(crate) use turn::ActiveTurn;
-pub(crate) use turn::TurnState;

codex-rs/core/src/state/session.rs

@@ -1,82 +0,0 @@
-//! Session-wide mutable state.
-
-use std::collections::HashSet;
-
-use codex_protocol::models::ResponseItem;
-
-use crate::codex::AgentTask;
-use crate::conversation_history::ConversationHistory;
-use crate::protocol::RateLimitSnapshot;
-use crate::protocol::TokenUsage;
-use crate::protocol::TokenUsageInfo;
-
-/// Persistent, session-scoped state previously stored directly on `Session`.
-#[derive(Default)]
-pub(crate) struct SessionState {
-    pub(crate) approved_commands: HashSet<Vec<String>>,
-    pub(crate) current_task: Option<AgentTask>,
-    pub(crate) history: ConversationHistory,
-    pub(crate) token_info: Option<TokenUsageInfo>,
-    pub(crate) latest_rate_limits: Option<RateLimitSnapshot>,
-}
-
-impl SessionState {
-    /// Create a new session state mirroring previous `State::default()` semantics.
-    pub(crate) fn new() -> Self {
-        Self {
-            history: ConversationHistory::new(),
-            ..Default::default()
-        }
-    }
-
-    // History helpers
-    pub(crate) fn record_items<I>(&mut self, items: I)
-    where
-        I: IntoIterator,
-        I::Item: std::ops::Deref<Target = ResponseItem>,
-    {
-        self.history.record_items(items)
-    }
-
-    pub(crate) fn history_snapshot(&self) -> Vec<ResponseItem> {
-        self.history.contents()
-    }
-
-    pub(crate) fn replace_history(&mut self, items: Vec<ResponseItem>) {
-        self.history.replace(items);
-    }
-
-    // Approved command helpers
-    pub(crate) fn add_approved_command(&mut self, cmd: Vec<String>) {
-        self.approved_commands.insert(cmd);
-    }
-
-    pub(crate) fn approved_commands_ref(&self) -> &HashSet<Vec<String>> {
-        &self.approved_commands
-    }
-
-    // Token/rate limit helpers
-    pub(crate) fn update_token_info_from_usage(
-        &mut self,
-        usage: &TokenUsage,
-        model_context_window: Option<u64>,
-    ) {
-        self.token_info = TokenUsageInfo::new_or_append(
-            &self.token_info,
-            &Some(usage.clone()),
-            model_context_window,
-        );
-    }
-
-    pub(crate) fn set_rate_limits(&mut self, snapshot: RateLimitSnapshot) {
-        self.latest_rate_limits = Some(snapshot);
-    }
-
-    pub(crate) fn token_info_and_rate_limits(
-        &self,
-    ) -> (Option<TokenUsageInfo>, Option<RateLimitSnapshot>) {
-        (self.token_info.clone(), self.latest_rate_limits.clone())
-    }
-
-    // Pending input/approval moved to TurnState.
-}

codex-rs/core/src/state/turn.rs

@@ -1,60 +0,0 @@
-//! Turn-scoped state and active turn metadata scaffolding.
-
-use std::collections::HashMap;
-use std::sync::Arc;
-use tokio::sync::Mutex;
-
-use codex_protocol::models::ResponseInputItem;
-use tokio::sync::oneshot;
-
-use crate::protocol::ReviewDecision;
-
-/// Metadata about the currently running turn.
-#[derive(Default)]
-pub(crate) struct ActiveTurn {
-    pub(crate) sub_id: String,
-    pub(crate) turn_state: Arc<Mutex<TurnState>>,
-}
-
-/// Mutable state for a single turn.
-#[derive(Default)]
-pub(crate) struct TurnState {
-    pending_approvals: HashMap<String, oneshot::Sender<ReviewDecision>>,
-    pending_input: Vec<ResponseInputItem>,
-}
-
-impl TurnState {
-    pub(crate) fn insert_pending_approval(
-        &mut self,
-        key: String,
-        tx: oneshot::Sender<ReviewDecision>,
-    ) -> Option<oneshot::Sender<ReviewDecision>> {
-        self.pending_approvals.insert(key, tx)
-    }
-
-    pub(crate) fn remove_pending_approval(
-        &mut self,
-        key: &str,
-    ) -> Option<oneshot::Sender<ReviewDecision>> {
-        self.pending_approvals.remove(key)
-    }
-
-    pub(crate) fn clear_pending(&mut self) {
-        self.pending_approvals.clear();
-        self.pending_input.clear();
-    }
-
-    pub(crate) fn push_pending_input(&mut self, input: ResponseInputItem) {
-        self.pending_input.push(input);
-    }
-
-    pub(crate) fn take_pending_input(&mut self) -> Vec<ResponseInputItem> {
-        if self.pending_input.is_empty() {
-            Vec::with_capacity(0)
-        } else {
-            let mut ret = Vec::new();
-            std::mem::swap(&mut ret, &mut self.pending_input);
-            ret
-        }
-    }
-}

codex-rs/core/src/turn_diff_tracker.rs

@@ -65,7 +65,7 @@ impl TurnDiffTracker {
                 let baseline_file_info = if path.exists() {
                     let mode = file_mode_for_path(path);
                     let mode_val = mode.unwrap_or(FileMode::Regular);
-                    let content = blob_bytes(path, mode_val).unwrap_or_default();
+                    let content = blob_bytes(path, &mode_val).unwrap_or_default();
                     let oid = if mode == Some(FileMode::Symlink) {
                         format!("{:x}", git_blob_sha1_hex_bytes(&content))
                     } else {
@@ -266,7 +266,7 @@ impl TurnDiffTracker {
         };
 
         let current_mode = file_mode_for_path(&current_external_path).unwrap_or(FileMode::Regular);
-        let right_bytes = blob_bytes(&current_external_path, current_mode);
+        let right_bytes = blob_bytes(&current_external_path, &current_mode);
 
         // Compute displays with &mut self before borrowing any baseline content.
         let left_display = self.relative_to_git_root_str(&baseline_external_path);
@@ -388,7 +388,7 @@ enum FileMode {
 }
 
 impl FileMode {
-    fn as_str(self) -> &'static str {
+    fn as_str(&self) -> &'static str {
         match self {
             FileMode::Regular => "100644",
             #[cfg(unix)]
@@ -427,9 +427,9 @@ fn file_mode_for_path(_path: &Path) -> Option<FileMode> {
     Some(FileMode::Regular)
 }
 
-fn blob_bytes(path: &Path, mode: FileMode) -> Option<Vec<u8>> {
+fn blob_bytes(path: &Path, mode: &FileMode) -> Option<Vec<u8>> {
     if path.exists() {
-        let contents = if mode == FileMode::Symlink {
+        let contents = if *mode == FileMode::Symlink {
             symlink_blob_bytes(path)
                 .ok_or_else(|| anyhow!("failed to read symlink target for {}", path.display()))
         } else {

codex-rs/core/src/user_notification.rs

@@ -1,45 +1,4 @@
 use serde::Serialize;
-use tracing::error;
-use tracing::warn;
-
-#[derive(Debug, Default)]
-pub(crate) struct UserNotifier {
-    notify_command: Option<Vec<String>>,
-}
-
-impl UserNotifier {
-    pub(crate) fn notify(&self, notification: &UserNotification) {
-        if let Some(notify_command) = &self.notify_command
-            && !notify_command.is_empty()
-        {
-            self.invoke_notify(notify_command, notification)
-        }
-    }
-
-    fn invoke_notify(&self, notify_command: &[String], notification: &UserNotification) {
-        let Ok(json) = serde_json::to_string(&notification) else {
-            error!("failed to serialise notification payload");
-            return;
-        };
-
-        let mut command = std::process::Command::new(&notify_command[0]);
-        if notify_command.len() > 1 {
-            command.args(&notify_command[1..]);
-        }
-        command.arg(json);
-
-        // Fire-and-forget – we do not wait for completion.
-        if let Err(e) = command.spawn() {
-            warn!("failed to spawn notifier '{}': {e}", notify_command[0]);
-        }
-    }
-
-    pub(crate) fn new(notify: Option<Vec<String>>) -> Self {
-        Self {
-            notify_command: notify,
-        }
-    }
-}
 
 /// User can configure a program that will receive notifications. Each
 /// notification is serialized as JSON and passed as an argument to the
@@ -62,10 +21,9 @@ pub(crate) enum UserNotification {
 #[cfg(test)]
 mod tests {
     use super::*;
-    use anyhow::Result;
 
     #[test]
-    fn test_user_notification() -> Result<()> {
+    fn test_user_notification() {
         let notification = UserNotification::AgentTurnComplete {
             turn_id: "12345".to_string(),
             input_messages: vec!["Rename `foo` to `bar` and update the callsites.".to_string()],
@@ -73,11 +31,10 @@ mod tests {
                 "Rename complete and verified `cargo build` succeeds.".to_string(),
             ),
         };
-        let serialized = serde_json::to_string(&notification)?;
+        let serialized = serde_json::to_string(&notification).unwrap();
         assert_eq!(
             serialized,
             r#"{"type":"agent-turn-complete","turn-id":"12345","input-messages":["Rename `foo` to `bar` and update the callsites."],"last-assistant-message":"Rename complete and verified `cargo build` succeeds."}"#
         );
-        Ok(())
     }
 }

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

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

codex-rs/core/tests/common/lib.rs

@@ -8,7 +8,6 @@ use codex_core::config::ConfigOverrides;
 use codex_core::config::ConfigToml;
 
 pub mod responses;
-pub mod test_codex;
 
 /// Returns a default `Config` whose on-disk state is confined to the provided
 /// temporary directory. Using a per-test directory keeps tests hermetic and
@@ -127,21 +126,3 @@ where
         }
     }
 }
-
-#[macro_export]
-macro_rules! non_sandbox_test {
-    // For tests that return ()
-    () => {{
-        if ::std::env::var("CODEX_SANDBOX_NETWORK_DISABLED").is_ok() {
-            println!("Skipping test because it cannot execute when network is disabled in a Codex sandbox.");
-            return;
-        }
-    }};
-    // For tests that return Result<(), _>
-    (result $(,)?) => {{
-        if ::std::env::var("CODEX_SANDBOX_NETWORK_DISABLED").is_ok() {
-            println!("Skipping test because it cannot execute when network is disabled in a Codex sandbox.");
-            return ::core::result::Result::Ok(());
-        }
-    }};
-}

codex-rs/core/tests/common/test_codex.rs

@@ -1,75 +0,0 @@
-use std::mem::swap;
-use std::sync::Arc;
-
-use codex_core::CodexAuth;
-use codex_core::CodexConversation;
-use codex_core::ConversationManager;
-use codex_core::ModelProviderInfo;
-use codex_core::NewConversation;
-use codex_core::built_in_model_providers;
-use codex_core::config::Config;
-use codex_core::protocol::SessionConfiguredEvent;
-use tempfile::TempDir;
-
-use crate::load_default_config_for_test;
-
-type ConfigMutator = dyn FnOnce(&mut Config);
-
-pub struct TestCodexBuilder {
-    config_mutators: Vec<Box<ConfigMutator>>,
-}
-
-impl TestCodexBuilder {
-    pub fn with_config<T>(mut self, mutator: T) -> Self
-    where
-        T: FnOnce(&mut Config) + 'static,
-    {
-        self.config_mutators.push(Box::new(mutator));
-        self
-    }
-
-    pub async fn build(&mut self, server: &wiremock::MockServer) -> anyhow::Result<TestCodex> {
-        // Build config pointing to the mock server and spawn Codex.
-        let model_provider = ModelProviderInfo {
-            base_url: Some(format!("{}/v1", server.uri())),
-            ..built_in_model_providers()["openai"].clone()
-        };
-        let home = TempDir::new()?;
-        let cwd = TempDir::new()?;
-        let mut config = load_default_config_for_test(&home);
-        config.cwd = cwd.path().to_path_buf();
-        config.model_provider = model_provider;
-        let mut mutators = vec![];
-        swap(&mut self.config_mutators, &mut mutators);
-
-        for mutator in mutators {
-            mutator(&mut config)
-        }
-        let conversation_manager = ConversationManager::with_auth(CodexAuth::from_api_key("dummy"));
-        let NewConversation {
-            conversation,
-            session_configured,
-            ..
-        } = conversation_manager.new_conversation(config).await?;
-
-        Ok(TestCodex {
-            home,
-            cwd,
-            codex: conversation,
-            session_configured,
-        })
-    }
-}
-
-pub struct TestCodex {
-    pub home: TempDir,
-    pub cwd: TempDir,
-    pub codex: Arc<CodexConversation>,
-    pub session_configured: SessionConfiguredEvent,
-}
-
-pub fn test_codex() -> TestCodexBuilder {
-    TestCodexBuilder {
-        config_mutators: vec![],
-    }
-}

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

@@ -1,7 +1,7 @@
 use assert_cmd::Command as AssertCommand;
 use codex_core::RolloutRecorder;
 use codex_core::protocol::GitInfo;
-use core_test_support::non_sandbox_test;
+use codex_core::spawn::CODEX_SANDBOX_NETWORK_DISABLED_ENV_VAR;
 use std::time::Duration;
 use std::time::Instant;
 use tempfile::TempDir;
@@ -21,7 +21,12 @@ use wiremock::matchers::path;
 /// 4. Ensures the response is received exactly once and contains "hi"
 #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
 async fn chat_mode_stream_cli() {
-    non_sandbox_test!();
+    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;
+    }
 
     let server = MockServer::start().await;
     let sse = concat!(
@@ -97,7 +102,12 @@ async fn chat_mode_stream_cli() {
 /// received by a mock OpenAI Responses endpoint.
 #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
 async fn exec_cli_applies_experimental_instructions_file() {
-    non_sandbox_test!();
+    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;
+    }
 
     // Start mock server which will capture the request and return a minimal
     // SSE stream for a single turn.
@@ -185,7 +195,12 @@ async fn exec_cli_applies_experimental_instructions_file() {
 /// 4. Ensures the fixture content is correctly streamed through the CLI
 #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
 async fn responses_api_stream_cli() {
-    non_sandbox_test!();
+    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;
+    }
 
     let fixture =
         std::path::Path::new(env!("CARGO_MANIFEST_DIR")).join("tests/cli_responses_fixture.sse");
@@ -217,7 +232,12 @@ async fn responses_api_stream_cli() {
 #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
 async fn integration_creates_and_checks_session_file() {
     // Honor sandbox network restrictions for CI parity with the other tests.
-    non_sandbox_test!();
+    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;
+    }
 
     // 1. Temp home so we read/write isolated session files.
     let home = TempDir::new().unwrap();

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

@@ -16,14 +16,13 @@ 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::spawn::CODEX_SANDBOX_NETWORK_DISABLED_ENV_VAR;
 use codex_protocol::mcp_protocol::ConversationId;
 use codex_protocol::models::ReasoningItemReasoningSummary;
 use codex_protocol::models::WebSearchAction;
 use core_test_support::load_default_config_for_test;
 use core_test_support::load_sse_fixture_with_id;
-use core_test_support::non_sandbox_test;
 use core_test_support::responses;
-use core_test_support::test_codex::test_codex;
 use core_test_support::wait_for_event;
 use futures::StreamExt;
 use serde_json::json;
@@ -127,7 +126,12 @@ fn write_auth_json(
 
 #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
 async fn resume_includes_initial_messages_and_sends_prior_items() {
-    non_sandbox_test!();
+    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;
+    }
 
     // Create a fake rollout session file with prior user + system + assistant messages.
     let tmpdir = TempDir::new().unwrap();
@@ -293,7 +297,12 @@ async fn resume_includes_initial_messages_and_sends_prior_items() {
 
 #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
 async fn includes_conversation_id_and_model_headers_in_request() {
-    non_sandbox_test!();
+    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;
@@ -418,7 +427,12 @@ async fn includes_base_instructions_override_in_request() {
 
 #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
 async fn chatgpt_auth_sends_correct_request() {
-    non_sandbox_test!();
+    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;
@@ -492,7 +506,12 @@ async fn chatgpt_auth_sends_correct_request() {
 
 #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
 async fn prefers_apikey_when_config_prefers_apikey_even_with_chatgpt_tokens() {
-    non_sandbox_test!();
+    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;
@@ -619,7 +638,12 @@ async fn includes_user_instructions_message_in_request() {
 
 #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
 async fn azure_responses_request_includes_store_and_reasoning_ids() {
-    non_sandbox_test!();
+    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;
+    }
 
     let server = MockServer::start().await;
 
@@ -762,10 +786,10 @@ async fn token_count_includes_rate_limits_snapshot() {
     let response = ResponseTemplate::new(200)
         .insert_header("content-type", "text/event-stream")
         .insert_header("x-codex-primary-used-percent", "12.5")
-        .insert_header("x-codex-secondary-used-percent", "40.0")
-        .insert_header("x-codex-primary-over-secondary-limit-percent", "75.0")
+        .insert_header("x-codex-protection-used-percent", "40.0")
+        .insert_header("x-codex-primary-over-protection-limit-percent", "75.0")
         .insert_header("x-codex-primary-window-minutes", "10")
-        .insert_header("x-codex-secondary-window-minutes", "60")
+        .insert_header("x-codex-protection-window-minutes", "60")
         .set_body_raw(sse_body, "text/event-stream");
 
     Mock::given(method("POST"))
@@ -798,33 +822,7 @@ async fn token_count_includes_rate_limits_snapshot() {
         .await
         .unwrap();
 
-    let first_token_event =
-        wait_for_event(&codex, |msg| matches!(msg, EventMsg::TokenCount(_))).await;
-    let rate_limit_only = match first_token_event {
-        EventMsg::TokenCount(ev) => ev,
-        _ => unreachable!(),
-    };
-
-    let rate_limit_json = serde_json::to_value(&rate_limit_only).unwrap();
-    pretty_assertions::assert_eq!(
-        rate_limit_json,
-        json!({
-            "info": null,
-            "rate_limits": {
-                "primary_used_percent": 12.5,
-                "secondary_used_percent": 40.0,
-                "primary_to_secondary_ratio_percent": 75.0,
-                "primary_window_minutes": 10,
-                "secondary_window_minutes": 60
-            }
-        })
-    );
-
-    let token_event = wait_for_event(
-        &codex,
-        |msg| matches!(msg, EventMsg::TokenCount(ev) if ev.info.is_some()),
-    )
-    .await;
+    let token_event = wait_for_event(&codex, |msg| matches!(msg, EventMsg::TokenCount(_))).await;
     let final_payload = match token_event {
         EventMsg::TokenCount(ev) => ev,
         _ => unreachable!(),
@@ -849,15 +847,15 @@ async fn token_count_includes_rate_limits_snapshot() {
                     "reasoning_output_tokens": 0,
                     "total_tokens": 123
                 },
-                // Default model is gpt-5-codex in tests → 272000 context window
+                // Default model is gpt-5 in tests → 272000 context window
                 "model_context_window": 272000
             },
             "rate_limits": {
                 "primary_used_percent": 12.5,
-                "secondary_used_percent": 40.0,
-                "primary_to_secondary_ratio_percent": 75.0,
+                "weekly_used_percent": 40.0,
+                "primary_to_weekly_ratio_percent": 75.0,
                 "primary_window_minutes": 10,
-                "secondary_window_minutes": 60
+                "weekly_window_minutes": 60
             }
         })
     );
@@ -873,80 +871,6 @@ async fn token_count_includes_rate_limits_snapshot() {
     wait_for_event(&codex, |msg| matches!(msg, EventMsg::TaskComplete(_))).await;
 }
 
-#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
-async fn usage_limit_error_emits_rate_limit_event() -> anyhow::Result<()> {
-    let server = MockServer::start().await;
-
-    let response = ResponseTemplate::new(429)
-        .insert_header("x-codex-primary-used-percent", "100.0")
-        .insert_header("x-codex-secondary-used-percent", "87.5")
-        .insert_header("x-codex-primary-over-secondary-limit-percent", "95.0")
-        .insert_header("x-codex-primary-window-minutes", "15")
-        .insert_header("x-codex-secondary-window-minutes", "60")
-        .set_body_json(json!({
-            "error": {
-                "type": "usage_limit_reached",
-                "message": "limit reached",
-                "resets_in_seconds": 42,
-                "plan_type": "pro"
-            }
-        }));
-
-    Mock::given(method("POST"))
-        .and(path("/v1/responses"))
-        .respond_with(response)
-        .expect(1)
-        .mount(&server)
-        .await;
-
-    let mut builder = test_codex();
-    let codex_fixture = builder.build(&server).await?;
-    let codex = codex_fixture.codex.clone();
-
-    let expected_limits = json!({
-        "primary_used_percent": 100.0,
-        "secondary_used_percent": 87.5,
-        "primary_to_secondary_ratio_percent": 95.0,
-        "primary_window_minutes": 15,
-        "secondary_window_minutes": 60
-    });
-
-    let submission_id = codex
-        .submit(Op::UserInput {
-            items: vec![InputItem::Text {
-                text: "hello".into(),
-            }],
-        })
-        .await
-        .expect("submission should succeed while emitting usage limit error events");
-
-    let token_event = wait_for_event(&codex, |msg| matches!(msg, EventMsg::TokenCount(_))).await;
-    let EventMsg::TokenCount(event) = token_event else {
-        unreachable!();
-    };
-
-    let event_json = serde_json::to_value(&event).expect("serialize token count event");
-    pretty_assertions::assert_eq!(
-        event_json,
-        json!({
-            "info": null,
-            "rate_limits": expected_limits
-        })
-    );
-
-    let error_event = wait_for_event(&codex, |msg| matches!(msg, EventMsg::Error(_))).await;
-    let EventMsg::Error(error_event) = error_event else {
-        unreachable!();
-    };
-    assert!(
-        error_event.message.to_lowercase().contains("usage limit"),
-        "unexpected error message for submission {submission_id}: {}",
-        error_event.message
-    );
-
-    Ok(())
-}
-
 #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
 async fn azure_overrides_assign_properties_used_for_responses_url() {
     let existing_env_var_with_random_value = if cfg!(windows) { "USERNAME" } else { "USER" };
@@ -1112,7 +1036,12 @@ fn create_dummy_codex_auth() -> CodexAuth {
 #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
 async fn history_dedupes_streamed_and_final_messages_across_turns() {
     // Skip under Codex sandbox network restrictions (mirrors other tests).
-    non_sandbox_test!();
+    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 that will receive three sequential requests and return the same SSE stream
     // each time: a few deltas, then a final assistant message, then completed.

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

@@ -9,7 +9,9 @@ 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::responses;
 use core_test_support::wait_for_event;
 use tempfile::TempDir;
 use wiremock::Mock;
@@ -19,17 +21,11 @@ use wiremock::ResponseTemplate;
 use wiremock::matchers::method;
 use wiremock::matchers::path;
 
-use codex_core::codex::compact::SUMMARIZATION_PROMPT;
-use core_test_support::non_sandbox_test;
-use core_test_support::responses::ev_assistant_message;
-use core_test_support::responses::ev_completed;
-use core_test_support::responses::ev_completed_with_tokens;
-use core_test_support::responses::ev_function_call;
-use core_test_support::responses::mount_sse_once;
-use core_test_support::responses::sse;
-use core_test_support::responses::sse_response;
-use core_test_support::responses::start_mock_server;
 use pretty_assertions::assert_eq;
+use responses::ev_assistant_message;
+use responses::ev_completed;
+use responses::sse;
+use responses::start_mock_server;
 use std::sync::Arc;
 use std::sync::Mutex;
 use std::sync::atomic::AtomicUsize;
@@ -38,6 +34,7 @@ use std::sync::atomic::Ordering;
 
 pub(super) const FIRST_REPLY: &str = "FIRST_REPLY";
 pub(super) const SUMMARY_TEXT: &str = "SUMMARY_ONLY_CONTEXT";
+pub(super) const SUMMARIZE_TRIGGER: &str = "Start Summarization";
 const THIRD_USER_MSG: &str = "next turn";
 const AUTO_SUMMARY_TEXT: &str = "AUTO_SUMMARY";
 const FIRST_AUTO_MSG: &str = "token limit start";
@@ -53,7 +50,12 @@ const DUMMY_CALL_ID: &str = "call-multi-auto";
 
 #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
 async fn summarize_context_three_requests_and_instructions() {
-    non_sandbox_test!();
+    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;
+    }
 
     // Set up a mock server that we can inspect after the run.
     let server = start_mock_server().await;
@@ -77,21 +79,21 @@ async fn summarize_context_three_requests_and_instructions() {
     let first_matcher = |req: &wiremock::Request| {
         let body = std::str::from_utf8(&req.body).unwrap_or("");
         body.contains("\"text\":\"hello world\"")
-            && !body.contains("You have exceeded the maximum number of tokens")
+            && !body.contains(&format!("\"text\":\"{SUMMARIZE_TRIGGER}\""))
     };
-    mount_sse_once(&server, first_matcher, sse1).await;
+    responses::mount_sse_once(&server, first_matcher, sse1).await;
 
     let second_matcher = |req: &wiremock::Request| {
         let body = std::str::from_utf8(&req.body).unwrap_or("");
-        body.contains("You have exceeded the maximum number of tokens")
+        body.contains(&format!("\"text\":\"{SUMMARIZE_TRIGGER}\""))
     };
-    mount_sse_once(&server, second_matcher, sse2).await;
+    responses::mount_sse_once(&server, second_matcher, sse2).await;
 
     let third_matcher = |req: &wiremock::Request| {
         let body = std::str::from_utf8(&req.body).unwrap_or("");
         body.contains(&format!("\"text\":\"{THIRD_USER_MSG}\""))
     };
-    mount_sse_once(&server, third_matcher, sse3).await;
+    responses::mount_sse_once(&server, third_matcher, sse3).await;
 
     // Build config pointing to the mock server and spawn Codex.
     let model_provider = ModelProviderInfo {
@@ -121,7 +123,7 @@ async fn summarize_context_three_requests_and_instructions() {
         .unwrap();
     wait_for_event(&codex, |ev| matches!(ev, EventMsg::TaskComplete(_))).await;
 
-    // 2) Summarize – second hit should include the summarization prompt.
+    // 2) Summarize – second hit with summarization instructions.
     codex.submit(Op::Compact).await.unwrap();
     wait_for_event(&codex, |ev| matches!(ev, EventMsg::TaskComplete(_))).await;
 
@@ -148,12 +150,16 @@ async fn summarize_context_three_requests_and_instructions() {
     let body2 = req2.body_json::<serde_json::Value>().unwrap();
     let body3 = req3.body_json::<serde_json::Value>().unwrap();
 
-    // Manual compact should keep the baseline developer instructions.
+    // System instructions should change for the summarization turn.
     let instr1 = body1.get("instructions").and_then(|v| v.as_str()).unwrap();
     let instr2 = body2.get("instructions").and_then(|v| v.as_str()).unwrap();
-    assert_eq!(
+    assert_ne!(
         instr1, instr2,
-        "manual compact should keep the standard developer instructions"
+        "summarization should override base instructions"
+    );
+    assert!(
+        instr2.contains("You have exceeded the maximum number of tokens"),
+        "summarization instructions not applied"
     );
 
     // The summarization request should include the injected user input marker.
@@ -163,14 +169,14 @@ async fn summarize_context_three_requests_and_instructions() {
     assert_eq!(last2.get("type").unwrap().as_str().unwrap(), "message");
     assert_eq!(last2.get("role").unwrap().as_str().unwrap(), "user");
     let text2 = last2["content"][0]["text"].as_str().unwrap();
-    assert_eq!(
-        text2, SUMMARIZATION_PROMPT,
+    assert!(
+        text2.contains(SUMMARIZE_TRIGGER),
         "expected summarize trigger, got `{text2}`"
     );
 
     // Third request must contain the refreshed instructions, bridge summary message and new user msg.
     let input3 = body3.get("input").and_then(|v| v.as_array()).unwrap();
-
+    println!("third request body: {body3}");
     assert!(
         input3.len() >= 3,
         "expected refreshed context and new user message in third request"
@@ -211,13 +217,13 @@ async fn summarize_context_three_requests_and_instructions() {
         "bridge should capture earlier user messages"
     );
     assert!(
-        !bridge_text.contains(SUMMARIZATION_PROMPT),
+        !bridge_text.contains(SUMMARIZE_TRIGGER),
         "bridge text should not echo the summarize trigger"
     );
     assert!(
         !messages
             .iter()
-            .any(|(_, text)| text.contains(SUMMARIZATION_PROMPT)),
+            .any(|(_, text)| text.contains(SUMMARIZE_TRIGGER)),
         "third request should not include the summarize trigger"
     );
 
@@ -270,23 +276,28 @@ async fn summarize_context_three_requests_and_instructions() {
 #[cfg_attr(windows, tokio::test(flavor = "multi_thread", worker_threads = 4))]
 #[cfg_attr(not(windows), tokio::test(flavor = "multi_thread", worker_threads = 2))]
 async fn auto_compact_runs_after_token_limit_hit() {
-    non_sandbox_test!();
+    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;
+    }
 
     let server = start_mock_server().await;
 
     let sse1 = sse(vec![
         ev_assistant_message("m1", FIRST_REPLY),
-        ev_completed_with_tokens("r1", 70_000),
+        responses::ev_completed_with_tokens("r1", 70_000),
     ]);
 
     let sse2 = sse(vec![
         ev_assistant_message("m2", "SECOND_REPLY"),
-        ev_completed_with_tokens("r2", 330_000),
+        responses::ev_completed_with_tokens("r2", 330_000),
     ]);
 
     let sse3 = sse(vec![
         ev_assistant_message("m3", AUTO_SUMMARY_TEXT),
-        ev_completed_with_tokens("r3", 200),
+        responses::ev_completed_with_tokens("r3", 200),
     ]);
 
     let first_matcher = |req: &wiremock::Request| {
@@ -298,7 +309,7 @@ async fn auto_compact_runs_after_token_limit_hit() {
     Mock::given(method("POST"))
         .and(path("/v1/responses"))
         .and(first_matcher)
-        .respond_with(sse_response(sse1))
+        .respond_with(responses::sse_response(sse1))
         .mount(&server)
         .await;
 
@@ -311,7 +322,7 @@ async fn auto_compact_runs_after_token_limit_hit() {
     Mock::given(method("POST"))
         .and(path("/v1/responses"))
         .and(second_matcher)
-        .respond_with(sse_response(sse2))
+        .respond_with(responses::sse_response(sse2))
         .mount(&server)
         .await;
 
@@ -322,7 +333,7 @@ async fn auto_compact_runs_after_token_limit_hit() {
     Mock::given(method("POST"))
         .and(path("/v1/responses"))
         .and(third_matcher)
-        .respond_with(sse_response(sse3))
+        .respond_with(responses::sse_response(sse3))
         .mount(&server)
         .await;
 
@@ -391,7 +402,6 @@ async fn auto_compact_runs_after_token_limit_hit() {
         "auto compact should add a third request"
     );
 
-    let body_first = requests[0].body_json::<serde_json::Value>().unwrap();
     let body3 = requests[auto_compact_index]
         .body_json::<serde_json::Value>()
         .unwrap();
@@ -399,54 +409,36 @@ async fn auto_compact_runs_after_token_limit_hit() {
         .get("instructions")
         .and_then(|v| v.as_str())
         .unwrap_or_default();
-    let baseline_instructions = body_first
-        .get("instructions")
-        .and_then(|v| v.as_str())
-        .unwrap_or_default()
-        .to_string();
-    assert_eq!(
-        instructions, baseline_instructions,
-        "auto compact should keep the standard developer instructions",
-    );
-
-    let input3 = body3.get("input").and_then(|v| v.as_array()).unwrap();
-    let last3 = input3
-        .last()
-        .expect("auto compact request should append a user message");
-    assert_eq!(last3.get("type").and_then(|v| v.as_str()), Some("message"));
-    assert_eq!(last3.get("role").and_then(|v| v.as_str()), Some("user"));
-    let last_text = last3
-        .get("content")
-        .and_then(|v| v.as_array())
-        .and_then(|items| items.first())
-        .and_then(|item| item.get("text"))
-        .and_then(|text| text.as_str())
-        .unwrap_or_default();
-    assert_eq!(
-        last_text, SUMMARIZATION_PROMPT,
-        "auto compact should send the summarization prompt as a user message",
+    assert!(
+        instructions.contains("You have exceeded the maximum number of tokens"),
+        "auto compact should reuse summarization instructions"
     );
 }
 
 #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
 async fn auto_compact_persists_rollout_entries() {
-    non_sandbox_test!();
+    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;
+    }
 
     let server = start_mock_server().await;
 
     let sse1 = sse(vec![
         ev_assistant_message("m1", FIRST_REPLY),
-        ev_completed_with_tokens("r1", 70_000),
+        responses::ev_completed_with_tokens("r1", 70_000),
     ]);
 
     let sse2 = sse(vec![
         ev_assistant_message("m2", "SECOND_REPLY"),
-        ev_completed_with_tokens("r2", 330_000),
+        responses::ev_completed_with_tokens("r2", 330_000),
     ]);
 
     let sse3 = sse(vec![
         ev_assistant_message("m3", AUTO_SUMMARY_TEXT),
-        ev_completed_with_tokens("r3", 200),
+        responses::ev_completed_with_tokens("r3", 200),
     ]);
 
     let first_matcher = |req: &wiremock::Request| {
@@ -458,7 +450,7 @@ async fn auto_compact_persists_rollout_entries() {
     Mock::given(method("POST"))
         .and(path("/v1/responses"))
         .and(first_matcher)
-        .respond_with(sse_response(sse1))
+        .respond_with(responses::sse_response(sse1))
         .mount(&server)
         .await;
 
@@ -471,7 +463,7 @@ async fn auto_compact_persists_rollout_entries() {
     Mock::given(method("POST"))
         .and(path("/v1/responses"))
         .and(second_matcher)
-        .respond_with(sse_response(sse2))
+        .respond_with(responses::sse_response(sse2))
         .mount(&server)
         .await;
 
@@ -482,7 +474,7 @@ async fn auto_compact_persists_rollout_entries() {
     Mock::given(method("POST"))
         .and(path("/v1/responses"))
         .and(third_matcher)
-        .respond_with(sse_response(sse3))
+        .respond_with(responses::sse_response(sse3))
         .mount(&server)
         .await;
 
@@ -558,23 +550,28 @@ async fn auto_compact_persists_rollout_entries() {
 
 #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
 async fn auto_compact_stops_after_failed_attempt() {
-    non_sandbox_test!();
+    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;
+    }
 
     let server = start_mock_server().await;
 
     let sse1 = sse(vec![
         ev_assistant_message("m1", FIRST_REPLY),
-        ev_completed_with_tokens("r1", 500),
+        responses::ev_completed_with_tokens("r1", 500),
     ]);
 
     let sse2 = sse(vec![
         ev_assistant_message("m2", SUMMARY_TEXT),
-        ev_completed_with_tokens("r2", 50),
+        responses::ev_completed_with_tokens("r2", 50),
     ]);
 
     let sse3 = sse(vec![
         ev_assistant_message("m3", STILL_TOO_BIG_REPLY),
-        ev_completed_with_tokens("r3", 500),
+        responses::ev_completed_with_tokens("r3", 500),
     ]);
 
     let first_matcher = |req: &wiremock::Request| {
@@ -585,7 +582,7 @@ async fn auto_compact_stops_after_failed_attempt() {
     Mock::given(method("POST"))
         .and(path("/v1/responses"))
         .and(first_matcher)
-        .respond_with(sse_response(sse1.clone()))
+        .respond_with(responses::sse_response(sse1.clone()))
         .mount(&server)
         .await;
 
@@ -596,7 +593,7 @@ async fn auto_compact_stops_after_failed_attempt() {
     Mock::given(method("POST"))
         .and(path("/v1/responses"))
         .and(second_matcher)
-        .respond_with(sse_response(sse2.clone()))
+        .respond_with(responses::sse_response(sse2.clone()))
         .mount(&server)
         .await;
 
@@ -608,7 +605,7 @@ async fn auto_compact_stops_after_failed_attempt() {
     Mock::given(method("POST"))
         .and(path("/v1/responses"))
         .and(third_matcher)
-        .respond_with(sse_response(sse3.clone()))
+        .respond_with(responses::sse_response(sse3.clone()))
         .mount(&server)
         .await;
 
@@ -655,57 +652,50 @@ async fn auto_compact_stops_after_failed_attempt() {
     );
 
     let last_body = requests[2].body_json::<serde_json::Value>().unwrap();
-    let input = last_body
-        .get("input")
-        .and_then(|v| v.as_array())
-        .unwrap_or_else(|| panic!("unexpected request format: {last_body}"));
-    let contains_prompt = input.iter().any(|item| {
-        item.get("type").and_then(|v| v.as_str()) == Some("message")
-            && item.get("role").and_then(|v| v.as_str()) == Some("user")
-            && item
-                .get("content")
-                .and_then(|v| v.as_array())
-                .and_then(|items| items.first())
-                .and_then(|entry| entry.get("text"))
-                .and_then(|text| text.as_str())
-                .map(|text| text == SUMMARIZATION_PROMPT)
-                .unwrap_or(false)
-    });
+    let instructions = last_body
+        .get("instructions")
+        .and_then(|v| v.as_str())
+        .unwrap_or_default();
     assert!(
-        !contains_prompt,
-        "third request should be the follow-up turn, not another summarization",
+        !instructions.contains("You have exceeded the maximum number of tokens"),
+        "third request should be the follow-up turn, not another summarization"
     );
 }
 
 #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
 async fn auto_compact_allows_multiple_attempts_when_interleaved_with_other_turn_events() {
-    non_sandbox_test!();
+    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;
+    }
 
     let server = start_mock_server().await;
 
     let sse1 = sse(vec![
         ev_assistant_message("m1", FIRST_REPLY),
-        ev_completed_with_tokens("r1", 500),
+        responses::ev_completed_with_tokens("r1", 500),
     ]);
     let sse2 = sse(vec![
         ev_assistant_message("m2", FIRST_AUTO_SUMMARY),
-        ev_completed_with_tokens("r2", 50),
+        responses::ev_completed_with_tokens("r2", 50),
     ]);
     let sse3 = sse(vec![
-        ev_function_call(DUMMY_CALL_ID, DUMMY_FUNCTION_NAME, "{}"),
-        ev_completed_with_tokens("r3", 150),
+        responses::ev_function_call(DUMMY_CALL_ID, DUMMY_FUNCTION_NAME, "{}"),
+        responses::ev_completed_with_tokens("r3", 150),
     ]);
     let sse4 = sse(vec![
         ev_assistant_message("m4", SECOND_LARGE_REPLY),
-        ev_completed_with_tokens("r4", 450),
+        responses::ev_completed_with_tokens("r4", 450),
     ]);
     let sse5 = sse(vec![
         ev_assistant_message("m5", SECOND_AUTO_SUMMARY),
-        ev_completed_with_tokens("r5", 60),
+        responses::ev_completed_with_tokens("r5", 60),
     ]);
     let sse6 = sse(vec![
         ev_assistant_message("m6", FINAL_REPLY),
-        ev_completed_with_tokens("r6", 120),
+        responses::ev_completed_with_tokens("r6", 120),
     ]);
 
     #[derive(Clone)]
@@ -817,7 +807,7 @@ async fn auto_compact_allows_multiple_attempts_when_interleaved_with_other_turn_
     );
     assert!(
         request_bodies[1].contains("You have exceeded the maximum number of tokens"),
-        "first auto compact request should include the summarization prompt"
+        "first auto compact request should use summarization instructions"
     );
     assert!(
         request_bodies[3].contains(&format!("unsupported call: {DUMMY_FUNCTION_NAME}")),
@@ -825,6 +815,6 @@ async fn auto_compact_allows_multiple_attempts_when_interleaved_with_other_turn_
     );
     assert!(
         request_bodies[4].contains("You have exceeded the maximum number of tokens"),
-        "second auto compact request should include the summarization prompt"
+        "second auto compact request should reuse summarization instructions"
     );
 }

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

@@ -8,6 +8,7 @@
 //! model-visible history matches the expected sequence of messages.
 
 use super::compact::FIRST_REPLY;
+use super::compact::SUMMARIZE_TRIGGER;
 use super::compact::SUMMARY_TEXT;
 use codex_core::CodexAuth;
 use codex_core::CodexConversation;
@@ -15,7 +16,6 @@ use codex_core::ConversationManager;
 use codex_core::ModelProviderInfo;
 use codex_core::NewConversation;
 use codex_core::built_in_model_providers;
-use codex_core::codex::compact::SUMMARIZATION_PROMPT;
 use codex_core::config::Config;
 use codex_core::protocol::ConversationPathResponseEvent;
 use codex_core::protocol::EventMsg;
@@ -133,7 +133,7 @@ async fn compact_resume_and_fork_preserve_model_history_view() {
         .to_string();
     let user_turn_1 = json!(
     {
-      "model": "gpt-5-codex",
+      "model": "gpt-5",
       "instructions": prompt,
       "input": [
         {
@@ -182,8 +182,12 @@ async fn compact_resume_and_fork_preserve_model_history_view() {
     });
     let compact_1 = json!(
     {
-      "model": "gpt-5-codex",
-      "instructions": prompt,
+      "model": "gpt-5",
+      "instructions": "You have exceeded the maximum number of tokens, please stop coding and instead write a short memento message for the next agent. Your note should:
+- Summarize what you finished and what still needs work. If there was a recent update_plan call, repeat its steps verbatim.
+- List outstanding TODOs with file paths / line numbers so they're easy to find.
+- Flag code that needs more tests (edge cases, performance, integration, etc.).
+- Record any open bugs, quirks, or setup steps that will make it easier for the next agent to pick up where you left off.",
       "input": [
         {
           "type": "message",
@@ -231,7 +235,7 @@ async fn compact_resume_and_fork_preserve_model_history_view() {
           "content": [
             {
               "type": "input_text",
-              "text": SUMMARIZATION_PROMPT
+              "text": "Start Summarization"
             }
           ]
         }
@@ -251,7 +255,7 @@ async fn compact_resume_and_fork_preserve_model_history_view() {
     });
     let user_turn_2_after_compact = json!(
     {
-      "model": "gpt-5-codex",
+      "model": "gpt-5",
       "instructions": prompt,
       "input": [
         {
@@ -316,7 +320,7 @@ SUMMARY_ONLY_CONTEXT"
     });
     let usert_turn_3_after_resume = json!(
     {
-      "model": "gpt-5-codex",
+      "model": "gpt-5",
       "instructions": prompt,
       "input": [
         {
@@ -401,7 +405,7 @@ SUMMARY_ONLY_CONTEXT"
     });
     let user_turn_3_after_fork = json!(
     {
-      "model": "gpt-5-codex",
+      "model": "gpt-5",
       "instructions": prompt,
       "input": [
         {
@@ -484,14 +488,13 @@ SUMMARY_ONLY_CONTEXT"
       ],
       "prompt_cache_key": fork_prompt_cache_key
     });
-    let mut expected = json!([
+    let expected = json!([
         user_turn_1,
         compact_1,
         user_turn_2_after_compact,
         usert_turn_3_after_resume,
         user_turn_3_after_fork
     ]);
-    normalize_line_endings(&mut expected);
     assert_eq!(requests.len(), 5);
     assert_eq!(json!(requests), expected);
 }
@@ -577,7 +580,7 @@ async fn compact_resume_after_second_compaction_preserves_history() {
         .unwrap_or_default()
         .to_string();
 
-    let mut expected = json!([
+    let expected = json!([
       {
         "instructions": prompt,
         "input": [
@@ -634,7 +637,6 @@ async fn compact_resume_after_second_compaction_preserves_history() {
         ],
       }
     ]);
-    normalize_line_endings(&mut expected);
     let last_request_after_2_compacts = json!([{
         "instructions": requests[requests.len() -1]["instructions"],
         "input": requests[requests.len() -1]["input"],
@@ -696,8 +698,7 @@ async fn mount_initial_flow(server: &MockServer) {
     let match_first = |req: &wiremock::Request| {
         let body = std::str::from_utf8(&req.body).unwrap_or("");
         body.contains("\"text\":\"hello world\"")
-            && !body.contains("You have exceeded the maximum number of tokens")
-            && !body.contains(&format!("\"text\":\"{SUMMARY_TEXT}\""))
+            && !body.contains(&format!("\"text\":\"{SUMMARIZE_TRIGGER}\""))
             && !body.contains("\"text\":\"AFTER_COMPACT\"")
             && !body.contains("\"text\":\"AFTER_RESUME\"")
             && !body.contains("\"text\":\"AFTER_FORK\"")
@@ -706,7 +707,7 @@ async fn mount_initial_flow(server: &MockServer) {
 
     let match_compact = |req: &wiremock::Request| {
         let body = std::str::from_utf8(&req.body).unwrap_or("");
-        body.contains("You have exceeded the maximum number of tokens")
+        body.contains(&format!("\"text\":\"{SUMMARIZE_TRIGGER}\""))
     };
     mount_sse_once(server, match_compact, sse2).await;
 
@@ -740,8 +741,7 @@ async fn mount_second_compact_flow(server: &MockServer) {
 
     let match_second_compact = |req: &wiremock::Request| {
         let body = std::str::from_utf8(&req.body).unwrap_or("");
-        body.contains("You have exceeded the maximum number of tokens")
-            && body.contains("AFTER_FORK")
+        body.contains(&format!("\"text\":\"{SUMMARIZE_TRIGGER}\"")) && body.contains("AFTER_FORK")
     };
     mount_sse_once(server, match_second_compact, sse6).await;
 

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

@@ -1,7 +1,6 @@
 #![cfg(target_os = "macos")]
 
 use std::collections::HashMap;
-use std::string::ToString;
 
 use codex_core::exec::ExecParams;
 use codex_core::exec::ExecToolCallOutput;
@@ -30,7 +29,7 @@ async fn run_test_cmd(tmp: TempDir, cmd: Vec<&str>) -> Result<ExecToolCallOutput
     assert_eq!(sandbox_type, SandboxType::MacosSeatbelt);
 
     let params = ExecParams {
-        command: cmd.iter().map(ToString::to_string).collect(),
+        command: cmd.iter().map(|s| s.to_string()).collect(),
         cwd: tmp.path().to_path_buf(),
         timeout_ms: Some(1000),
         env: HashMap::new(),

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

@@ -1,97 +0,0 @@
-#![cfg(not(target_os = "windows"))]
-
-use codex_core::protocol::AskForApproval;
-use codex_core::protocol::EventMsg;
-use codex_core::protocol::InputItem;
-use codex_core::protocol::Op;
-use codex_core::protocol::SandboxPolicy;
-use codex_protocol::config_types::ReasoningSummary;
-use core_test_support::non_sandbox_test;
-use core_test_support::responses;
-use core_test_support::test_codex::TestCodex;
-use core_test_support::test_codex::test_codex;
-use core_test_support::wait_for_event;
-use pretty_assertions::assert_eq;
-use responses::ev_assistant_message;
-use responses::ev_completed;
-use responses::sse;
-use responses::start_mock_server;
-
-const SCHEMA: &str = r#"
-{
-    "type": "object",
-    "properties": {
-        "explanation": { "type": "string" },
-        "final_answer": { "type": "string" }
-    },
-    "required": ["explanation", "final_answer"],
-    "additionalProperties": false
-}
-"#;
-
-#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
-async fn codex_returns_json_result() -> anyhow::Result<()> {
-    non_sandbox_test!(result);
-
-    let server = start_mock_server().await;
-
-    let sse1 = sse(vec![
-        ev_assistant_message(
-            "m2",
-            r#"{"explanation": "explanation", "final_answer": "final_answer"}"#,
-        ),
-        ev_completed("r1"),
-    ]);
-
-    let expected_schema: serde_json::Value = serde_json::from_str(SCHEMA)?;
-    let match_json_text_param = move |req: &wiremock::Request| {
-        let body: serde_json::Value = serde_json::from_slice(&req.body).unwrap_or_default();
-        let Some(text) = body.get("text") else {
-            return false;
-        };
-        let Some(format) = text.get("format") else {
-            return false;
-        };
-
-        format.get("name") == Some(&serde_json::Value::String("codex_output_schema".into()))
-            && format.get("type") == Some(&serde_json::Value::String("json_schema".into()))
-            && format.get("strict") == Some(&serde_json::Value::Bool(true))
-            && format.get("schema") == Some(&expected_schema)
-    };
-    responses::mount_sse_once(&server, match_json_text_param, sse1).await;
-
-    let TestCodex { codex, cwd, .. } = test_codex().build(&server).await?;
-
-    // 1) Normal user input – should hit server once.
-    codex
-        .submit(Op::UserTurn {
-            items: vec![InputItem::Text {
-                text: "hello world".into(),
-            }],
-            final_output_json_schema: Some(serde_json::from_str(SCHEMA)?),
-            cwd: cwd.path().to_path_buf(),
-            approval_policy: AskForApproval::Never,
-            sandbox_policy: SandboxPolicy::DangerFullAccess,
-            model: "gpt-5".to_string(),
-            effort: None,
-            summary: ReasoningSummary::Auto,
-        })
-        .await?;
-
-    let message = wait_for_event(&codex, |ev| matches!(ev, EventMsg::AgentMessage(_))).await;
-    if let EventMsg::AgentMessage(message) = message {
-        let json: serde_json::Value = serde_json::from_str(&message.message)?;
-        assert_eq!(
-            json.get("explanation"),
-            Some(&serde_json::Value::String("explanation".into()))
-        );
-        assert_eq!(
-            json.get("final_answer"),
-            Some(&serde_json::Value::String("final_answer".into()))
-        );
-    } else {
-        anyhow::bail!("expected agent message event");
-    }
-
-    Ok(())
-}

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

@@ -7,7 +7,6 @@ mod compact_resume_fork;
 mod exec;
 mod exec_stream_events;
 mod fork_conversation;
-mod json_result;
 mod live_cli;
 mod model_overrides;
 mod prompt_caching;
@@ -16,4 +15,3 @@ mod rollout_list_find;
 mod seatbelt;
 mod stream_error_allows_next_turn;
 mod stream_no_completed;
-mod user_notification;

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

@@ -184,7 +184,6 @@ async fn prompt_tools_are_consistent_across_requests() {
 
     let conversation_manager =
         ConversationManager::with_auth(CodexAuth::from_api_key("Test API Key"));
-    let expected_instructions = config.model_family.base_instructions.clone();
     let codex = conversation_manager
         .new_conversation(config)
         .await
@@ -214,6 +213,7 @@ async fn prompt_tools_are_consistent_across_requests() {
     let requests = server.received_requests().await.unwrap();
     assert_eq!(requests.len(), 2, "expected two POST requests");
 
+    let expected_instructions: &str = include_str!("../../prompt.md");
     // our internal implementation is responsible for keeping tools in sync
     // with the OpenAI schema, so we just verify the tool presence here
     let expected_tools_names: &[&str] = &["shell", "update_plan", "apply_patch", "view_image"];
@@ -546,7 +546,6 @@ async fn per_turn_overrides_keep_cached_prefix_and_key_constant() {
             model: "o3".to_string(),
             effort: Some(ReasoningEffort::High),
             summary: ReasoningSummary::Detailed,
-            final_output_json_schema: None,
         })
         .await
         .unwrap();
@@ -656,7 +655,6 @@ async fn send_user_turn_with_no_changes_does_not_send_environment_context() {
             model: default_model.clone(),
             effort: default_effort,
             summary: default_summary,
-            final_output_json_schema: None,
         })
         .await
         .unwrap();
@@ -673,7 +671,6 @@ async fn send_user_turn_with_no_changes_does_not_send_environment_context() {
             model: default_model.clone(),
             effort: default_effort,
             summary: default_summary,
-            final_output_json_schema: None,
         })
         .await
         .unwrap();
@@ -769,7 +766,6 @@ async fn send_user_turn_with_changes_sends_environment_context() {
             model: default_model,
             effort: default_effort,
             summary: default_summary,
-            final_output_json_schema: None,
         })
         .await
         .unwrap();
@@ -786,7 +782,6 @@ async fn send_user_turn_with_changes_sends_environment_context() {
             model: "o3".to_string(),
             effort: Some(ReasoningEffort::High),
             summary: ReasoningSummary::Detailed,
-            final_output_json_schema: None,
         })
         .await
         .unwrap();

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

@@ -20,9 +20,9 @@ use codex_core::protocol::ReviewOutputEvent;
 use codex_core::protocol::ReviewRequest;
 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::load_sse_fixture_with_id_from_str;
-use core_test_support::non_sandbox_test;
 use core_test_support::wait_for_event;
 use pretty_assertions::assert_eq;
 use std::path::PathBuf;
@@ -42,7 +42,12 @@ use wiremock::matchers::path;
 #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
 async fn review_op_emits_lifecycle_and_review_output() {
     // Skip under Codex sandbox network restrictions.
-    non_sandbox_test!();
+    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;
+    }
 
     // Start mock Responses API server. Return a single assistant message whose
     // text is a JSON-encoded ReviewOutputEvent.
@@ -167,7 +172,12 @@ async fn review_op_emits_lifecycle_and_review_output() {
 #[cfg_attr(windows, tokio::test(flavor = "multi_thread", worker_threads = 4))]
 #[cfg_attr(not(windows), tokio::test(flavor = "multi_thread", worker_threads = 2))]
 async fn review_op_with_plain_text_emits_review_fallback() {
-    non_sandbox_test!();
+    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;
+    }
 
     let sse_raw = r#"[
         {"type":"response.output_item.done", "item":{
@@ -216,7 +226,12 @@ async fn review_op_with_plain_text_emits_review_fallback() {
 #[cfg_attr(windows, tokio::test(flavor = "multi_thread", worker_threads = 4))]
 #[cfg_attr(not(windows), tokio::test(flavor = "multi_thread", worker_threads = 2))]
 async fn review_does_not_emit_agent_message_on_structured_output() {
-    non_sandbox_test!();
+    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;
+    }
 
     let review_json = serde_json::json!({
         "findings": [
@@ -288,7 +303,12 @@ async fn review_does_not_emit_agent_message_on_structured_output() {
 /// request uses that model (and not the main chat model).
 #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
 async fn review_uses_custom_review_model_from_config() {
-    non_sandbox_test!();
+    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;
+    }
 
     // Minimal stream: just a completed event
     let sse_raw = r#"[
@@ -341,7 +361,12 @@ async fn review_uses_custom_review_model_from_config() {
 #[cfg_attr(windows, tokio::test(flavor = "multi_thread", worker_threads = 4))]
 #[cfg_attr(not(windows), tokio::test(flavor = "multi_thread", worker_threads = 2))]
 async fn review_input_isolated_from_parent_history() {
-    non_sandbox_test!();
+    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 for the single review request
     let sse_raw = r#"[
@@ -517,7 +542,12 @@ async fn review_input_isolated_from_parent_history() {
 /// messages in its request `input`.
 #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
 async fn review_history_does_not_leak_into_parent_session() {
-    non_sandbox_test!();
+    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;
+    }
 
     // Respond to both the review request and the subsequent parent request.
     let sse_raw = r#"[

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

@@ -1,15 +1,17 @@
 use std::time::Duration;
 
+use codex_core::CodexAuth;
+use codex_core::ConversationManager;
 use codex_core::ModelProviderInfo;
 use codex_core::WireApi;
 use codex_core::protocol::EventMsg;
 use codex_core::protocol::InputItem;
 use codex_core::protocol::Op;
+use codex_core::spawn::CODEX_SANDBOX_NETWORK_DISABLED_ENV_VAR;
+use core_test_support::load_default_config_for_test;
 use core_test_support::load_sse_fixture_with_id;
-use core_test_support::non_sandbox_test;
-use core_test_support::test_codex::TestCodex;
-use core_test_support::test_codex::test_codex;
 use core_test_support::wait_for_event_with_timeout;
+use tempfile::TempDir;
 use wiremock::Mock;
 use wiremock::MockServer;
 use wiremock::ResponseTemplate;
@@ -23,7 +25,12 @@ fn sse_completed(id: &str) -> String {
 
 #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
 async fn continue_after_stream_error() {
-    non_sandbox_test!();
+    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;
+    }
 
     let server = MockServer::start().await;
 
@@ -76,14 +83,18 @@ async fn continue_after_stream_error() {
         requires_openai_auth: false,
     };
 
-    let TestCodex { codex, .. } = test_codex()
-        .with_config(move |config| {
-            config.base_instructions = Some("You are a helpful assistant".to_string());
-            config.model_provider = provider;
-        })
-        .build(&server)
+    let home = TempDir::new().unwrap();
+    let mut config = load_default_config_for_test(&home);
+    config.base_instructions = Some("You are a helpful assistant".to_string());
+    config.model_provider = provider;
+
+    let conversation_manager =
+        ConversationManager::with_auth(CodexAuth::from_api_key("Test API Key"));
+    let codex = conversation_manager
+        .new_conversation(config)
         .await
-        .unwrap();
+        .unwrap()
+        .conversation;
 
     codex
         .submit(Op::UserInput {

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

@@ -3,16 +3,17 @@
 
 use std::time::Duration;
 
+use codex_core::CodexAuth;
+use codex_core::ConversationManager;
 use codex_core::ModelProviderInfo;
-use codex_core::WireApi;
 use codex_core::protocol::EventMsg;
 use codex_core::protocol::InputItem;
 use codex_core::protocol::Op;
+use codex_core::spawn::CODEX_SANDBOX_NETWORK_DISABLED_ENV_VAR;
+use core_test_support::load_default_config_for_test;
 use core_test_support::load_sse_fixture;
 use core_test_support::load_sse_fixture_with_id;
-use core_test_support::non_sandbox_test;
-use core_test_support::test_codex::TestCodex;
-use core_test_support::test_codex::test_codex;
+use tempfile::TempDir;
 use tokio::time::timeout;
 use wiremock::Mock;
 use wiremock::MockServer;
@@ -32,7 +33,12 @@ fn sse_completed(id: &str) -> String {
 
 #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
 async fn retries_on_early_close() {
-    non_sandbox_test!();
+    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;
+    }
 
     let server = MockServer::start().await;
 
@@ -73,7 +79,7 @@ async fn retries_on_early_close() {
         // provider is not set.
         env_key: Some("PATH".into()),
         env_key_instructions: None,
-        wire_api: WireApi::Responses,
+        wire_api: codex_core::WireApi::Responses,
         query_params: None,
         http_headers: None,
         env_http_headers: None,
@@ -84,13 +90,16 @@ async fn retries_on_early_close() {
         requires_openai_auth: false,
     };
 
-    let TestCodex { codex, .. } = test_codex()
-        .with_config(move |config| {
-            config.model_provider = model_provider;
-        })
-        .build(&server)
+    let codex_home = TempDir::new().unwrap();
+    let mut config = load_default_config_for_test(&codex_home);
+    config.model_provider = model_provider;
+    let conversation_manager =
+        ConversationManager::with_auth(CodexAuth::from_api_key("Test API Key"));
+    let codex = conversation_manager
+        .new_conversation(config)
         .await
-        .unwrap();
+        .unwrap()
+        .conversation;
 
     codex
         .submit(Op::UserInput {

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

@@ -1,73 +0,0 @@
-#![cfg(not(target_os = "windows"))]
-
-use std::os::unix::fs::PermissionsExt;
-
-use codex_core::protocol::EventMsg;
-use codex_core::protocol::InputItem;
-use codex_core::protocol::Op;
-use core_test_support::non_sandbox_test;
-use core_test_support::responses;
-use core_test_support::test_codex::TestCodex;
-use core_test_support::test_codex::test_codex;
-use core_test_support::wait_for_event;
-use tempfile::TempDir;
-use wiremock::matchers::any;
-
-use responses::ev_assistant_message;
-use responses::ev_completed;
-use responses::sse;
-use responses::start_mock_server;
-use tokio::time::Duration;
-use tokio::time::sleep;
-
-#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
-async fn summarize_context_three_requests_and_instructions() -> anyhow::Result<()> {
-    non_sandbox_test!(result);
-
-    let server = start_mock_server().await;
-
-    let sse1 = sse(vec![ev_assistant_message("m1", "Done"), ev_completed("r1")]);
-
-    responses::mount_sse_once(&server, any(), sse1).await;
-
-    let notify_dir = TempDir::new()?;
-    // write a script to the notify that touches a file next to it
-    let notify_script = notify_dir.path().join("notify.sh");
-    std::fs::write(
-        &notify_script,
-        r#"#!/bin/bash
-set -e
-echo -n "${@: -1}" > $(dirname "${0}")/notify.txt"#,
-    )?;
-    std::fs::set_permissions(&notify_script, std::fs::Permissions::from_mode(0o755))?;
-
-    let notify_file = notify_dir.path().join("notify.txt");
-    let notify_script_str = notify_script.to_str().unwrap().to_string();
-
-    let TestCodex { codex, .. } = test_codex()
-        .with_config(move |cfg| cfg.notify = Some(vec![notify_script_str]))
-        .build(&server)
-        .await?;
-
-    // 1) Normal user input – should hit server once.
-    codex
-        .submit(Op::UserInput {
-            items: vec![InputItem::Text {
-                text: "hello world".into(),
-            }],
-        })
-        .await?;
-    wait_for_event(&codex, |ev| matches!(ev, EventMsg::TaskComplete(_))).await;
-
-    // We fork the notify script, so we need to wait for it to write to the file.
-    for _ in 0..100u32 {
-        if notify_file.exists() {
-            break;
-        }
-        sleep(Duration::from_millis(100)).await;
-    }
-
-    assert!(notify_file.exists());
-
-    Ok(())
-}

codex-rs/docs/codex_mcp_interface.md

@@ -51,7 +51,7 @@ Start a new session with optional overrides:
 
 Request `newConversation` params (subset):
 
-- `model`: string model id (e.g. "o3", "gpt-5", "gpt-5-codex")
+- `model`: string model id (e.g. "o3", "gpt-5")
 - `profile`: optional named profile
 - `cwd`: optional working directory
 - `approvalPolicy`: `untrusted` | `on-request` | `on-failure` | `never`
@@ -120,3 +120,4 @@ While processing, the server emits `codex/event` notifications containing agent
 ## Compatibility and stability
 
 This interface is experimental. Method names, fields, and event shapes may evolve. For the authoritative schema, consult `protocol/src/mcp_protocol.rs` and the corresponding server wiring in `mcp-server/`.
+

codex-rs/exec/Cargo.toml

@@ -15,37 +15,37 @@ path = "src/lib.rs"
 workspace = true
 
 [dependencies]
-anyhow = { workspace = true }
-chrono = { workspace = true }
-clap = { workspace = true, features = ["derive"] }
-codex-arg0 = { workspace = true }
-codex-common = { workspace = true, features = [
+anyhow = "1"
+chrono = "0.4.40"
+clap = { version = "4", features = ["derive"] }
+codex-arg0 = { path = "../arg0" }
+codex-common = { path = "../common", features = [
     "cli",
     "elapsed",
     "sandbox_summary",
 ] }
-codex-core = { workspace = true }
-codex-ollama = { workspace = true }
-codex-protocol = { workspace = true }
-owo-colors = { workspace = true }
-serde_json = { workspace = true }
-shlex = { workspace = true }
-tokio = { workspace = true, features = [
+codex-core = { path = "../core" }
+codex-ollama = { path = "../ollama" }
+codex-protocol = { path = "../protocol" }
+owo-colors = "4.2.0"
+serde_json = "1"
+shlex = "1.3.0"
+tokio = { version = "1", features = [
     "io-std",
     "macros",
     "process",
     "rt-multi-thread",
     "signal",
 ] }
-tracing = { workspace = true, features = ["log"] }
-tracing-subscriber = { workspace = true, features = ["env-filter"] }
+tracing = { version = "0.1.41", features = ["log"] }
+tracing-subscriber = { version = "0.3.20", features = ["env-filter"] }
 
 [dev-dependencies]
-assert_cmd = { workspace = true }
-core_test_support = { workspace = true }
-libc = { workspace = true }
-predicates = { workspace = true }
-tempfile = { workspace = true }
-uuid = { workspace = true }
-walkdir = { workspace = true }
-wiremock = { workspace = true }
+assert_cmd = "2"
+core_test_support = { path = "../core/tests/common" }
+libc = "0.2"
+predicates = "3"
+tempfile = "3.13.0"
+uuid = "1"
+walkdir = "2"
+wiremock = "0.6"

codex-rs/exec/src/cli.rs

@@ -52,10 +52,6 @@ pub struct Cli {
     #[arg(long = "skip-git-repo-check", default_value_t = false)]
     pub skip_git_repo_check: bool,
 
-    /// Path to a JSON Schema file describing the model's final response shape.
-    #[arg(long = "output-schema", value_name = "FILE")]
-    pub output_schema: Option<PathBuf>,
-
     #[clap(skip)]
     pub config_overrides: CliConfigOverrides,
 
@@ -67,10 +63,6 @@ pub struct Cli {
     #[arg(long = "json", default_value_t = false)]
     pub json: bool,
 
-    /// Whether to include the plan tool in the conversation.
-    #[arg(long = "include-plan-tool", default_value_t = false)]
-    pub include_plan_tool: bool,
-
     /// Specifies file where the last message from the agent should be written.
     #[arg(long = "output-last-message")]
     pub last_message_file: Option<PathBuf>,

codex-rs/exec/src/event_processor_with_human_output.rs

@@ -539,37 +539,8 @@ impl EventProcessor for EventProcessorWithHumanOutput {
             }
             EventMsg::PlanUpdate(plan_update_event) => {
                 let UpdatePlanArgs { explanation, plan } = plan_update_event;
-
-                // Header
-                ts_println!(self, "{}", "Plan update".style(self.magenta));
-
-                // Optional explanation
-                if let Some(explanation) = explanation
-                    && !explanation.trim().is_empty()
-                {
-                    ts_println!(self, "{}", explanation.style(self.italic));
-                }
-
-                // Pretty-print the plan items with simple status markers.
-                for item in plan {
-                    use codex_core::plan_tool::StepStatus;
-                    match item.status {
-                        StepStatus::Completed => {
-                            ts_println!(self, "  {} {}", "✓".style(self.green), item.step);
-                        }
-                        StepStatus::InProgress => {
-                            ts_println!(self, "  {} {}", "→".style(self.cyan), item.step);
-                        }
-                        StepStatus::Pending => {
-                            ts_println!(
-                                self,
-                                "  {} {}",
-                                "•".style(self.dimmed),
-                                item.step.style(self.dimmed)
-                            );
-                        }
-                    }
-                }
+                ts_println!(self, "explanation: {explanation:?}");
+                ts_println!(self, "plan: {plan:?}");
             }
             EventMsg::GetHistoryEntryResponse(_) => {
                 // Currently ignored in exec output.
@@ -602,7 +573,7 @@ impl EventProcessor for EventProcessorWithHumanOutput {
 }
 
 fn escape_command(command: &[String]) -> String {
-    try_join(command.iter().map(String::as_str)).unwrap_or_else(|_| command.join(" "))
+    try_join(command.iter().map(|s| s.as_str())).unwrap_or_else(|_| command.join(" "))
 }
 
 fn format_file_change(change: &FileChange) -> &'static str {

codex-rs/exec/src/lib.rs

@@ -25,7 +25,6 @@ use codex_ollama::DEFAULT_OSS_MODEL;
 use codex_protocol::config_types::SandboxMode;
 use event_processor_with_human_output::EventProcessorWithHumanOutput;
 use event_processor_with_json_output::EventProcessorWithJsonOutput;
-use serde_json::Value;
 use tracing::debug;
 use tracing::error;
 use tracing::info;
@@ -52,8 +51,6 @@ pub async fn run_main(cli: Cli, codex_linux_sandbox_exe: Option<PathBuf>) -> any
         json: json_mode,
         sandbox_mode: sandbox_mode_cli_arg,
         prompt,
-        output_schema: output_schema_path,
-        include_plan_tool,
         config_overrides,
     } = cli;
 
@@ -99,8 +96,6 @@ pub async fn run_main(cli: Cli, codex_linux_sandbox_exe: Option<PathBuf>) -> any
         }
     };
 
-    let output_schema = load_output_schema(output_schema_path);
-
     let (stdout_with_ansi, stderr_with_ansi) = match color {
         cli::Color::Always => (true, true),
         cli::Color::Never => (false, false),
@@ -162,7 +157,7 @@ pub async fn run_main(cli: Cli, codex_linux_sandbox_exe: Option<PathBuf>) -> any
         model_provider,
         codex_linux_sandbox_exe,
         base_instructions: None,
-        include_plan_tool: Some(include_plan_tool),
+        include_plan_tool: None,
         include_apply_patch_tool: None,
         include_view_image_tool: None,
         show_raw_agent_reasoning: oss.then_some(true),
@@ -198,14 +193,7 @@ pub async fn run_main(cli: Cli, codex_linux_sandbox_exe: Option<PathBuf>) -> any
     // is using.
     event_processor.print_config_summary(&config, &prompt);
 
-    let default_cwd = config.cwd.to_path_buf();
-    let default_approval_policy = config.approval_policy;
-    let default_sandbox_policy = config.sandbox_policy.clone();
-    let default_model = config.model.clone();
-    let default_effort = config.model_reasoning_effort;
-    let default_summary = config.model_reasoning_summary;
-
-    if !skip_git_repo_check && get_git_repo_root(&default_cwd).is_none() {
+    if !skip_git_repo_check && get_git_repo_root(&config.cwd.to_path_buf()).is_none() {
         eprintln!("Not inside a trusted directory and --skip-git-repo-check was not specified.");
         std::process::exit(1);
     }
@@ -300,18 +288,7 @@ pub async fn run_main(cli: Cli, codex_linux_sandbox_exe: Option<PathBuf>) -> any
 
     // Send the prompt.
     let items: Vec<InputItem> = vec![InputItem::Text { text: prompt }];
-    let initial_prompt_task_id = conversation
-        .submit(Op::UserTurn {
-            items,
-            cwd: default_cwd,
-            approval_policy: default_approval_policy,
-            sandbox_policy: default_sandbox_policy,
-            model: default_model,
-            effort: default_effort,
-            summary: default_summary,
-            final_output_json_schema: output_schema,
-        })
-        .await?;
+    let initial_prompt_task_id = conversation.submit(Op::UserInput { items }).await?;
     info!("Sent prompt with event ID: {initial_prompt_task_id}");
 
     // Run the loop until the task is complete.
@@ -350,29 +327,3 @@ async fn resolve_resume_path(
         Ok(None)
     }
 }
-
-fn load_output_schema(path: Option<PathBuf>) -> Option<Value> {
-    let path = path?;
-
-    let schema_str = match std::fs::read_to_string(&path) {
-        Ok(contents) => contents,
-        Err(err) => {
-            eprintln!(
-                "Failed to read output schema file {}: {err}",
-                path.display()
-            );
-            std::process::exit(1);
-        }
-    };
-
-    match serde_json::from_str::<Value>(&schema_str) {
-        Ok(value) => Some(value),
-        Err(err) => {
-            eprintln!(
-                "Output schema file {} is not valid JSON: {err}",
-                path.display()
-            );
-            std::process::exit(1);
-        }
-    }
-}

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

@@ -48,9 +48,14 @@ fn test_standalone_exec_cli_can_use_apply_patch() -> anyhow::Result<()> {
 #[tokio::test(flavor = "multi_thread", worker_threads = 4)]
 async fn test_apply_patch_tool() -> anyhow::Result<()> {
     use crate::suite::common::run_e2e_exec_test;
-    use core_test_support::non_sandbox_test;
+    use codex_core::spawn::CODEX_SANDBOX_NETWORK_DISABLED_ENV_VAR;
 
-    non_sandbox_test!(result);
+    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 Ok(());
+    }
 
     let tmp_cwd = tempdir().expect("failed to create temp dir");
     let tmp_path = tmp_cwd.path().to_path_buf();
@@ -88,9 +93,14 @@ async fn test_apply_patch_tool() -> anyhow::Result<()> {
 #[tokio::test(flavor = "multi_thread", worker_threads = 4)]
 async fn test_apply_patch_freeform_tool() -> anyhow::Result<()> {
     use crate::suite::common::run_e2e_exec_test;
-    use core_test_support::non_sandbox_test;
+    use codex_core::spawn::CODEX_SANDBOX_NETWORK_DISABLED_ENV_VAR;
 
-    non_sandbox_test!(result);
+    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 Ok(());
+    }
 
     let tmp_cwd = tempdir().expect("failed to create temp dir");
     let freeform_add_patch = r#"*** Begin Patch

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

@@ -1,6 +1,5 @@
 // Aggregates all former standalone integration tests as modules.
 mod apply_patch;
 mod common;
-mod output_schema;
 mod resume;
 mod sandbox;

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

@@ -1,76 +0,0 @@
-#![cfg(not(target_os = "windows"))]
-#![allow(clippy::expect_used, clippy::unwrap_used)]
-
-use assert_cmd::prelude::*;
-use core_test_support::responses;
-use serde_json::Value;
-use std::process::Command;
-use tempfile::TempDir;
-use wiremock::matchers::any;
-
-#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
-async fn exec_includes_output_schema_in_request() -> anyhow::Result<()> {
-    let home = TempDir::new()?;
-    let workspace = TempDir::new()?;
-
-    let schema_contents = serde_json::json!({
-        "type": "object",
-        "properties": {
-            "answer": { "type": "string" }
-        },
-        "required": ["answer"],
-        "additionalProperties": false
-    });
-    let schema_path = workspace.path().join("schema.json");
-    std::fs::write(&schema_path, serde_json::to_vec_pretty(&schema_contents)?)?;
-    let expected_schema: Value = schema_contents;
-
-    let server = responses::start_mock_server().await;
-    let body = responses::sse(vec![
-        serde_json::json!({
-            "type": "response.created",
-            "response": {"id": "resp1"}
-        }),
-        responses::ev_assistant_message("m1", "fixture hello"),
-        responses::ev_completed("resp1"),
-    ]);
-    responses::mount_sse_once(&server, any(), body).await;
-
-    Command::cargo_bin("codex-exec")?
-        .current_dir(workspace.path())
-        .env("CODEX_HOME", home.path())
-        .env("OPENAI_API_KEY", "dummy")
-        .env("OPENAI_BASE_URL", format!("{}/v1", server.uri()))
-        .arg("--skip-git-repo-check")
-        .arg("-C")
-        .arg(workspace.path())
-        .arg("--output-schema")
-        .arg(&schema_path)
-        .arg("-m")
-        .arg("gpt-5")
-        .arg("tell me a joke")
-        .assert()
-        .success();
-
-    let requests = server
-        .received_requests()
-        .await
-        .expect("failed to capture requests");
-    assert_eq!(requests.len(), 1, "expected exactly one request");
-    let payload: Value = serde_json::from_slice(&requests[0].body)?;
-    let text = payload.get("text").expect("request missing text field");
-    let format = text
-        .get("format")
-        .expect("request missing text.format field");
-    assert_eq!(
-        format,
-        &serde_json::json!({
-            "name": "codex_output_schema",
-            "type": "json_schema",
-            "strict": true,
-            "schema": expected_schema,
-        })
-    );
-
-    Ok(())
-}

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

@@ -3,7 +3,6 @@ use anyhow::Context;
 use assert_cmd::prelude::*;
 use serde_json::Value;
 use std::process::Command;
-use std::string::ToString;
 use tempfile::TempDir;
 use uuid::Uuid;
 use walkdir::WalkDir;
@@ -46,7 +45,7 @@ fn find_session_file_containing_marker(
                 && payload.get("type").and_then(|t| t.as_str()) == Some("message")
                 && payload
                     .get("content")
-                    .map(ToString::to_string)
+                    .map(|c| c.to_string())
                     .unwrap_or_default()
                     .contains(marker)
             {

codex-rs/execpolicy/Cargo.toml

@@ -15,19 +15,19 @@ path = "src/lib.rs"
 workspace = true
 
 [dependencies]
-allocative = { workspace = true }
-anyhow = { workspace = true }
-clap = { workspace = true, features = ["derive"] }
-derive_more = { workspace = true, features = ["display"] }
-env_logger = { workspace = true }
-log = { workspace = true }
-multimap = { workspace = true }
-path-absolutize = { workspace = true }
-regex-lite = { workspace = true }
-serde = { workspace = true, features = ["derive"] }
-serde_json = { workspace = true }
-serde_with = { workspace = true, features = ["macros"] }
-starlark = { workspace = true }
+allocative = "0.3.3"
+anyhow = "1"
+clap = { version = "4", features = ["derive"] }
+derive_more = { version = "2", features = ["display"] }
+env_logger = "0.11.5"
+log = "0.4"
+multimap = "0.10.0"
+path-absolutize = "3.1.1"
+regex-lite = "0.1"
+serde = { version = "1", features = ["derive"] }
+serde_json = "1"
+serde_with = { version = "3", features = ["macros"] }
+starlark = "0.13.0"
 
 [dev-dependencies]
-tempfile = { workspace = true }
+tempfile = "3.13.0"

codex-rs/execpolicy/src/execv_checker.rs

@@ -1,4 +1,3 @@
-use std::borrow::Cow;
 use std::ffi::OsString;
 use std::path::Path;
 use std::path::PathBuf;
@@ -109,7 +108,7 @@ fn ensure_absolute_path(path: &str, cwd: &Option<OsString>) -> Result<PathBuf> {
         file.absolutize()
     };
     result
-        .map(Cow::into_owned)
+        .map(|path| path.into_owned())
         .map_err(|error| CannotCanonicalizePath {
             file: path.to_string(),
             error: error.kind(),
@@ -146,8 +145,6 @@ mod tests {
     use super::*;
     use crate::MatchedArg;
     use crate::PolicyParser;
-    use anyhow::Result;
-    use anyhow::anyhow;
 
     fn setup(fake_cp: &Path) -> ExecvChecker {
         let source = format!(
@@ -166,7 +163,7 @@ system_path=[{fake_cp:?}]
 
     #[test]
     fn test_check_valid_input_files() -> Result<()> {
-        let temp_dir = TempDir::new()?;
+        let temp_dir = TempDir::new().unwrap();
 
         // Create an executable file that can be used with the system_path arg.
         let fake_cp = temp_dir.path().join("cp");
@@ -174,14 +171,14 @@ system_path=[{fake_cp:?}]
         {
             use std::os::unix::fs::PermissionsExt;
 
-            let fake_cp_file = std::fs::File::create(&fake_cp)?;
-            let mut permissions = fake_cp_file.metadata()?.permissions();
+            let fake_cp_file = std::fs::File::create(&fake_cp).unwrap();
+            let mut permissions = fake_cp_file.metadata().unwrap().permissions();
             permissions.set_mode(0o755);
-            std::fs::set_permissions(&fake_cp, permissions)?;
+            std::fs::set_permissions(&fake_cp, permissions).unwrap();
         }
         #[cfg(windows)]
         {
-            std::fs::File::create(&fake_cp)?;
+            std::fs::File::create(&fake_cp).unwrap();
         }
 
         // Create root_path and reference to files under the root.
@@ -201,7 +198,7 @@ system_path=[{fake_cp:?}]
             program: "cp".into(),
             args: vec![source, dest.clone()],
         };
-        let valid_exec = match checker.r#match(&exec_call).map_err(|e| anyhow!("{e:?}"))? {
+        let valid_exec = match checker.r#match(&exec_call)? {
             MatchedExec::Match { exec } => exec,
             unexpected => panic!("Expected a safe exec but got {unexpected:?}"),
         };
@@ -246,10 +243,7 @@ system_path=[{fake_cp:?}]
             program: "cp".into(),
             args: vec![root.clone(), root],
         };
-        let valid_exec_call_folders_as_args = match checker
-            .r#match(&exec_call_folders_as_args)
-            .map_err(|e| anyhow!("{e:?}"))?
-        {
+        let valid_exec_call_folders_as_args = match checker.r#match(&exec_call_folders_as_args)? {
             MatchedExec::Match { exec } => exec,
             _ => panic!("Expected a safe exec"),
         };
@@ -271,9 +265,8 @@ system_path=[{fake_cp:?}]
                     0,
                     ArgType::ReadableFile,
                     root_path.parent().unwrap().to_str().unwrap(),
-                )
-                .map_err(|e| anyhow!("{e:?}"))?,
-                MatchedArg::new(1, ArgType::WriteableFile, &dest).map_err(|e| anyhow!("{e:?}"))?,
+                )?,
+                MatchedArg::new(1, ArgType::WriteableFile, &dest)?,
             ],
             ..Default::default()
         };

codex-rs/execpolicy/src/main.rs

@@ -10,7 +10,6 @@ use codex_execpolicy::get_default_policy;
 use serde::Deserialize;
 use serde::Serialize;
 use serde::de;
-use starlark::Error as StarlarkError;
 use std::path::PathBuf;
 use std::str::FromStr;
 
@@ -72,13 +71,13 @@ fn main() -> Result<()> {
         }
         None => get_default_policy(),
     };
-    let policy = policy.map_err(StarlarkError::into_anyhow)?;
+    let policy = policy.map_err(|err| err.into_anyhow())?;
 
     let exec = match args.command {
         Command::Check { command } => match command.split_first() {
             Some((first, rest)) => ExecArg {
                 program: first.to_string(),
-                args: rest.to_vec(),
+                args: rest.iter().map(|s| s.to_string()).collect(),
             },
             None => {
                 eprintln!("no command provided");
@@ -162,6 +161,6 @@ impl FromStr for ExecArg {
     type Err = anyhow::Error;
 
     fn from_str(s: &str) -> Result<Self, Self::Err> {
-        serde_json::from_str(s).map_err(Into::into)
+        serde_json::from_str(s).map_err(|e| e.into())
     }
 }

codex-rs/execpolicy/src/program.rs

@@ -169,7 +169,7 @@ impl ProgramSpec {
             let mut options = self
                 .required_options
                 .difference(&matched_opt_names)
-                .map(String::from)
+                .map(|s| s.to_string())
                 .collect::<Vec<_>>();
             options.sort();
             return Err(Error::MissingRequiredOptions {

codex-rs/file-search/Cargo.toml

@@ -12,10 +12,10 @@ name = "codex_file_search"
 path = "src/lib.rs"
 
 [dependencies]
-anyhow = { workspace = true }
-clap = { workspace = true, features = ["derive"] }
-ignore = { workspace = true }
-nucleo-matcher = { workspace = true }
-serde = { workspace = true, features = ["derive"] }
-serde_json = { workspace = true }
-tokio = { workspace = true, features = ["full"] }
+anyhow = "1"
+clap = { version = "4", features = ["derive"] }
+ignore = "0.4.23"
+nucleo-matcher = "0.3.1"
+serde = { version = "1", features = ["derive"] }
+serde_json = "1"
+tokio = { version = "1", features = ["full"] }

codex-rs/git-tooling/Cargo.toml

@@ -1,20 +0,0 @@
-[package]
-name = "codex-git-tooling"
-version.workspace = true
-edition.workspace = true
-readme = "README.md"
-
-[lib]
-name = "codex_git_tooling"
-path = "src/lib.rs"
-
-[dependencies]
-tempfile = "3"
-thiserror = "2"
-walkdir = "2"
-
-[lints]
-workspace = true
-
-[dev-dependencies]
-pretty_assertions = "1.4.1"

codex-rs/git-tooling/README.md

@@ -1,20 +0,0 @@
-# codex-git-tooling
-
-Helpers for interacting with git.
-
-```rust,no_run
-use std::path::Path;
-
-use codex_git_tooling::{create_ghost_commit, restore_ghost_commit, CreateGhostCommitOptions};
-
-let repo = Path::new("/path/to/repo");
-
-// Capture the current working tree as an unreferenced commit.
-let ghost = create_ghost_commit(&CreateGhostCommitOptions::new(repo))?;
-
-// Later, undo back to that state.
-restore_ghost_commit(repo, &ghost)?;
-```
-
-Pass a custom message with `.message("…")` or force-include ignored files with
-`.force_include(["ignored.log".into()])`.

codex-rs/git-tooling/src/errors.rs

@@ -1,35 +0,0 @@
-use std::path::PathBuf;
-use std::process::ExitStatus;
-use std::string::FromUtf8Error;
-
-use thiserror::Error;
-use walkdir::Error as WalkdirError;
-
-/// Errors returned while managing git worktree snapshots.
-#[derive(Debug, Error)]
-pub enum GitToolingError {
-    #[error("git command `{command}` failed with status {status}: {stderr}")]
-    GitCommand {
-        command: String,
-        status: ExitStatus,
-        stderr: String,
-    },
-    #[error("git command `{command}` produced non-UTF-8 output")]
-    GitOutputUtf8 {
-        command: String,
-        #[source]
-        source: FromUtf8Error,
-    },
-    #[error("{path:?} is not a git repository")]
-    NotAGitRepository { path: PathBuf },
-    #[error("path {path:?} must be relative to the repository root")]
-    NonRelativePath { path: PathBuf },
-    #[error("path {path:?} escapes the repository root")]
-    PathEscapesRepository { path: PathBuf },
-    #[error("failed to process path inside worktree")]
-    PathPrefix(#[from] std::path::StripPrefixError),
-    #[error(transparent)]
-    Walkdir(#[from] WalkdirError),
-    #[error(transparent)]
-    Io(#[from] std::io::Error),
-}

codex-rs/git-tooling/src/ghost_commits.rs

@@ -1,494 +0,0 @@
-use std::ffi::OsString;
-use std::path::Path;
-use std::path::PathBuf;
-
-use tempfile::Builder;
-
-use crate::GhostCommit;
-use crate::GitToolingError;
-use crate::operations::apply_repo_prefix_to_force_include;
-use crate::operations::ensure_git_repository;
-use crate::operations::normalize_relative_path;
-use crate::operations::repo_subdir;
-use crate::operations::resolve_head;
-use crate::operations::resolve_repository_root;
-use crate::operations::run_git_for_status;
-use crate::operations::run_git_for_stdout;
-
-/// Default commit message used for ghost commits when none is provided.
-const DEFAULT_COMMIT_MESSAGE: &str = "codex snapshot";
-
-/// Options to control ghost commit creation.
-pub struct CreateGhostCommitOptions<'a> {
-    pub repo_path: &'a Path,
-    pub message: Option<&'a str>,
-    pub force_include: Vec<PathBuf>,
-}
-
-impl<'a> CreateGhostCommitOptions<'a> {
-    /// Creates options scoped to the provided repository path.
-    pub fn new(repo_path: &'a Path) -> Self {
-        Self {
-            repo_path,
-            message: None,
-            force_include: Vec::new(),
-        }
-    }
-
-    /// Sets a custom commit message for the ghost commit.
-    pub fn message(mut self, message: &'a str) -> Self {
-        self.message = Some(message);
-        self
-    }
-
-    /// Supplies the entire force-include path list at once.
-    pub fn force_include<I>(mut self, paths: I) -> Self
-    where
-        I: IntoIterator<Item = PathBuf>,
-    {
-        self.force_include = paths.into_iter().collect();
-        self
-    }
-
-    /// Adds a single path to the force-include list.
-    pub fn push_force_include<P>(mut self, path: P) -> Self
-    where
-        P: Into<PathBuf>,
-    {
-        self.force_include.push(path.into());
-        self
-    }
-}
-
-/// Create a ghost commit capturing the current state of the repository's working tree.
-pub fn create_ghost_commit(
-    options: &CreateGhostCommitOptions<'_>,
-) -> Result<GhostCommit, GitToolingError> {
-    ensure_git_repository(options.repo_path)?;
-
-    let repo_root = resolve_repository_root(options.repo_path)?;
-    let repo_prefix = repo_subdir(repo_root.as_path(), options.repo_path);
-    let parent = resolve_head(repo_root.as_path())?;
-
-    let normalized_force = options
-        .force_include
-        .iter()
-        .map(|path| normalize_relative_path(path))
-        .collect::<Result<Vec<_>, _>>()?;
-    let force_include =
-        apply_repo_prefix_to_force_include(repo_prefix.as_deref(), &normalized_force);
-    let index_tempdir = Builder::new().prefix("codex-git-index-").tempdir()?;
-    let index_path = index_tempdir.path().join("index");
-    let base_env = vec![(
-        OsString::from("GIT_INDEX_FILE"),
-        OsString::from(index_path.as_os_str()),
-    )];
-
-    let mut add_args = vec![OsString::from("add"), OsString::from("--all")];
-    if let Some(prefix) = repo_prefix.as_deref() {
-        add_args.extend([OsString::from("--"), prefix.as_os_str().to_os_string()]);
-    }
-
-    run_git_for_status(repo_root.as_path(), add_args, Some(base_env.as_slice()))?;
-    if !force_include.is_empty() {
-        let mut args = Vec::with_capacity(force_include.len() + 2);
-        args.push(OsString::from("add"));
-        args.push(OsString::from("--force"));
-        args.extend(
-            force_include
-                .iter()
-                .map(|path| OsString::from(path.as_os_str())),
-        );
-        run_git_for_status(repo_root.as_path(), args, Some(base_env.as_slice()))?;
-    }
-
-    let tree_id = run_git_for_stdout(
-        repo_root.as_path(),
-        vec![OsString::from("write-tree")],
-        Some(base_env.as_slice()),
-    )?;
-
-    let mut commit_env = base_env;
-    commit_env.extend(default_commit_identity());
-    let message = options.message.unwrap_or(DEFAULT_COMMIT_MESSAGE);
-    let commit_args = {
-        let mut result = vec![OsString::from("commit-tree"), OsString::from(&tree_id)];
-        if let Some(parent) = parent.as_deref() {
-            result.extend([OsString::from("-p"), OsString::from(parent)]);
-        }
-        result.extend([OsString::from("-m"), OsString::from(message)]);
-        result
-    };
-
-    // Retrieve commit ID.
-    let commit_id = run_git_for_stdout(
-        repo_root.as_path(),
-        commit_args,
-        Some(commit_env.as_slice()),
-    )?;
-
-    Ok(GhostCommit::new(commit_id, parent))
-}
-
-/// Restore the working tree to match the provided ghost commit.
-pub fn restore_ghost_commit(repo_path: &Path, commit: &GhostCommit) -> Result<(), GitToolingError> {
-    restore_to_commit(repo_path, commit.id())
-}
-
-/// Restore the working tree to match the given commit ID.
-pub fn restore_to_commit(repo_path: &Path, commit_id: &str) -> Result<(), GitToolingError> {
-    ensure_git_repository(repo_path)?;
-
-    let repo_root = resolve_repository_root(repo_path)?;
-    let repo_prefix = repo_subdir(repo_root.as_path(), repo_path);
-
-    let mut restore_args = vec![
-        OsString::from("restore"),
-        OsString::from("--source"),
-        OsString::from(commit_id),
-        OsString::from("--worktree"),
-        OsString::from("--staged"),
-        OsString::from("--"),
-    ];
-    if let Some(prefix) = repo_prefix.as_deref() {
-        restore_args.push(prefix.as_os_str().to_os_string());
-    } else {
-        restore_args.push(OsString::from("."));
-    }
-
-    run_git_for_status(repo_root.as_path(), restore_args, None)?;
-    Ok(())
-}
-
-/// Returns the default author and committer identity for ghost commits.
-fn default_commit_identity() -> Vec<(OsString, OsString)> {
-    vec![
-        (
-            OsString::from("GIT_AUTHOR_NAME"),
-            OsString::from("Codex Snapshot"),
-        ),
-        (
-            OsString::from("GIT_AUTHOR_EMAIL"),
-            OsString::from("snapshot@codex.local"),
-        ),
-        (
-            OsString::from("GIT_COMMITTER_NAME"),
-            OsString::from("Codex Snapshot"),
-        ),
-        (
-            OsString::from("GIT_COMMITTER_EMAIL"),
-            OsString::from("snapshot@codex.local"),
-        ),
-    ]
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use crate::operations::run_git_for_stdout;
-    use pretty_assertions::assert_eq;
-    use std::process::Command;
-
-    /// Runs a git command in the test repository and asserts success.
-    fn run_git_in(repo_path: &Path, args: &[&str]) {
-        let status = Command::new("git")
-            .current_dir(repo_path)
-            .args(args)
-            .status()
-            .expect("git command");
-        assert!(status.success(), "git command failed: {args:?}");
-    }
-
-    /// Runs a git command and returns its trimmed stdout output.
-    fn run_git_stdout(repo_path: &Path, args: &[&str]) -> String {
-        let output = Command::new("git")
-            .current_dir(repo_path)
-            .args(args)
-            .output()
-            .expect("git command");
-        assert!(output.status.success(), "git command failed: {args:?}");
-        String::from_utf8_lossy(&output.stdout).trim().to_string()
-    }
-
-    /// Initializes a repository with consistent settings for cross-platform tests.
-    fn init_test_repo(repo: &Path) {
-        run_git_in(repo, &["init", "--initial-branch=main"]);
-        run_git_in(repo, &["config", "core.autocrlf", "false"]);
-    }
-
-    #[test]
-    /// Verifies a ghost commit can be created and restored end to end.
-    fn create_and_restore_roundtrip() -> Result<(), GitToolingError> {
-        let temp = tempfile::tempdir()?;
-        let repo = temp.path();
-        init_test_repo(repo);
-        std::fs::write(repo.join("tracked.txt"), "initial\n")?;
-        std::fs::write(repo.join("delete-me.txt"), "to be removed\n")?;
-        run_git_in(repo, &["add", "tracked.txt", "delete-me.txt"]);
-        run_git_in(
-            repo,
-            &[
-                "-c",
-                "user.name=Tester",
-                "-c",
-                "user.email=test@example.com",
-                "commit",
-                "-m",
-                "init",
-            ],
-        );
-
-        let tracked_contents = "modified contents\n";
-        std::fs::write(repo.join("tracked.txt"), tracked_contents)?;
-        std::fs::remove_file(repo.join("delete-me.txt"))?;
-        let new_file_contents = "hello ghost\n";
-        std::fs::write(repo.join("new-file.txt"), new_file_contents)?;
-        std::fs::write(repo.join(".gitignore"), "ignored.txt\n")?;
-        let ignored_contents = "ignored but captured\n";
-        std::fs::write(repo.join("ignored.txt"), ignored_contents)?;
-
-        let options =
-            CreateGhostCommitOptions::new(repo).force_include(vec![PathBuf::from("ignored.txt")]);
-        let ghost = create_ghost_commit(&options)?;
-
-        assert!(ghost.parent().is_some());
-        let cat = run_git_for_stdout(
-            repo,
-            vec![
-                OsString::from("show"),
-                OsString::from(format!("{}:ignored.txt", ghost.id())),
-            ],
-            None,
-        )?;
-        assert_eq!(cat, ignored_contents.trim());
-
-        std::fs::write(repo.join("tracked.txt"), "other state\n")?;
-        std::fs::write(repo.join("ignored.txt"), "changed\n")?;
-        std::fs::remove_file(repo.join("new-file.txt"))?;
-        std::fs::write(repo.join("ephemeral.txt"), "temp data\n")?;
-
-        restore_ghost_commit(repo, &ghost)?;
-
-        let tracked_after = std::fs::read_to_string(repo.join("tracked.txt"))?;
-        assert_eq!(tracked_after, tracked_contents);
-        let ignored_after = std::fs::read_to_string(repo.join("ignored.txt"))?;
-        assert_eq!(ignored_after, ignored_contents);
-        let new_file_after = std::fs::read_to_string(repo.join("new-file.txt"))?;
-        assert_eq!(new_file_after, new_file_contents);
-        assert_eq!(repo.join("delete-me.txt").exists(), false);
-        assert!(repo.join("ephemeral.txt").exists());
-
-        Ok(())
-    }
-
-    #[test]
-    /// Ensures ghost commits succeed in repositories without an existing HEAD.
-    fn create_snapshot_without_existing_head() -> Result<(), GitToolingError> {
-        let temp = tempfile::tempdir()?;
-        let repo = temp.path();
-        init_test_repo(repo);
-
-        let tracked_contents = "first contents\n";
-        std::fs::write(repo.join("tracked.txt"), tracked_contents)?;
-        let ignored_contents = "ignored but captured\n";
-        std::fs::write(repo.join(".gitignore"), "ignored.txt\n")?;
-        std::fs::write(repo.join("ignored.txt"), ignored_contents)?;
-
-        let options =
-            CreateGhostCommitOptions::new(repo).force_include(vec![PathBuf::from("ignored.txt")]);
-        let ghost = create_ghost_commit(&options)?;
-
-        assert!(ghost.parent().is_none());
-
-        let message = run_git_stdout(repo, &["log", "-1", "--format=%s", ghost.id()]);
-        assert_eq!(message, DEFAULT_COMMIT_MESSAGE);
-
-        let ignored = run_git_stdout(repo, &["show", &format!("{}:ignored.txt", ghost.id())]);
-        assert_eq!(ignored, ignored_contents.trim());
-
-        Ok(())
-    }
-
-    #[test]
-    /// Confirms custom messages are used when creating ghost commits.
-    fn create_ghost_commit_uses_custom_message() -> Result<(), GitToolingError> {
-        let temp = tempfile::tempdir()?;
-        let repo = temp.path();
-        init_test_repo(repo);
-
-        std::fs::write(repo.join("tracked.txt"), "contents\n")?;
-        run_git_in(repo, &["add", "tracked.txt"]);
-        run_git_in(
-            repo,
-            &[
-                "-c",
-                "user.name=Tester",
-                "-c",
-                "user.email=test@example.com",
-                "commit",
-                "-m",
-                "initial",
-            ],
-        );
-
-        let message = "custom message";
-        let ghost = create_ghost_commit(&CreateGhostCommitOptions::new(repo).message(message))?;
-        let commit_message = run_git_stdout(repo, &["log", "-1", "--format=%s", ghost.id()]);
-        assert_eq!(commit_message, message);
-
-        Ok(())
-    }
-
-    #[test]
-    /// Rejects force-included paths that escape the repository.
-    fn create_ghost_commit_rejects_force_include_parent_path() {
-        let temp = tempfile::tempdir().expect("tempdir");
-        let repo = temp.path();
-        init_test_repo(repo);
-        let options = CreateGhostCommitOptions::new(repo)
-            .force_include(vec![PathBuf::from("../outside.txt")]);
-        let err = create_ghost_commit(&options).unwrap_err();
-        assert!(matches!(err, GitToolingError::PathEscapesRepository { .. }));
-    }
-
-    #[test]
-    /// Restoring a ghost commit from a non-git directory fails.
-    fn restore_requires_git_repository() {
-        let temp = tempfile::tempdir().expect("tempdir");
-        let err = restore_to_commit(temp.path(), "deadbeef").unwrap_err();
-        assert!(matches!(err, GitToolingError::NotAGitRepository { .. }));
-    }
-
-    #[test]
-    /// Restoring from a subdirectory affects only that subdirectory.
-    fn restore_from_subdirectory_restores_files_relatively() -> Result<(), GitToolingError> {
-        let temp = tempfile::tempdir()?;
-        let repo = temp.path();
-        init_test_repo(repo);
-
-        std::fs::create_dir_all(repo.join("workspace"))?;
-        let workspace = repo.join("workspace");
-        std::fs::write(repo.join("root.txt"), "root contents\n")?;
-        std::fs::write(workspace.join("nested.txt"), "nested contents\n")?;
-        run_git_in(repo, &["add", "."]);
-        run_git_in(
-            repo,
-            &[
-                "-c",
-                "user.name=Tester",
-                "-c",
-                "user.email=test@example.com",
-                "commit",
-                "-m",
-                "initial",
-            ],
-        );
-
-        std::fs::write(repo.join("root.txt"), "root modified\n")?;
-        std::fs::write(workspace.join("nested.txt"), "nested modified\n")?;
-
-        let ghost = create_ghost_commit(&CreateGhostCommitOptions::new(&workspace))?;
-
-        std::fs::write(repo.join("root.txt"), "root after\n")?;
-        std::fs::write(workspace.join("nested.txt"), "nested after\n")?;
-
-        restore_ghost_commit(&workspace, &ghost)?;
-
-        let root_after = std::fs::read_to_string(repo.join("root.txt"))?;
-        assert_eq!(root_after, "root after\n");
-        let nested_after = std::fs::read_to_string(workspace.join("nested.txt"))?;
-        assert_eq!(nested_after, "nested modified\n");
-        assert!(!workspace.join("codex-rs").exists());
-
-        Ok(())
-    }
-
-    #[test]
-    /// Restoring from a subdirectory preserves ignored files in parent folders.
-    fn restore_from_subdirectory_preserves_parent_vscode() -> Result<(), GitToolingError> {
-        let temp = tempfile::tempdir()?;
-        let repo = temp.path();
-        init_test_repo(repo);
-
-        let workspace = repo.join("codex-rs");
-        std::fs::create_dir_all(&workspace)?;
-        std::fs::write(repo.join(".gitignore"), ".vscode/\n")?;
-        std::fs::write(workspace.join("tracked.txt"), "snapshot version\n")?;
-        run_git_in(repo, &["add", "."]);
-        run_git_in(
-            repo,
-            &[
-                "-c",
-                "user.name=Tester",
-                "-c",
-                "user.email=test@example.com",
-                "commit",
-                "-m",
-                "initial",
-            ],
-        );
-
-        std::fs::write(workspace.join("tracked.txt"), "snapshot delta\n")?;
-        let ghost = create_ghost_commit(&CreateGhostCommitOptions::new(&workspace))?;
-
-        std::fs::write(workspace.join("tracked.txt"), "post-snapshot\n")?;
-        let vscode = repo.join(".vscode");
-        std::fs::create_dir_all(&vscode)?;
-        std::fs::write(vscode.join("settings.json"), "{\n  \"after\": true\n}\n")?;
-
-        restore_ghost_commit(&workspace, &ghost)?;
-
-        let tracked_after = std::fs::read_to_string(workspace.join("tracked.txt"))?;
-        assert_eq!(tracked_after, "snapshot delta\n");
-        assert!(vscode.join("settings.json").exists());
-        let settings_after = std::fs::read_to_string(vscode.join("settings.json"))?;
-        assert_eq!(settings_after, "{\n  \"after\": true\n}\n");
-
-        Ok(())
-    }
-
-    #[test]
-    /// Restoring from the repository root keeps ignored files intact.
-    fn restore_preserves_ignored_files() -> Result<(), GitToolingError> {
-        let temp = tempfile::tempdir()?;
-        let repo = temp.path();
-        init_test_repo(repo);
-
-        std::fs::write(repo.join(".gitignore"), ".vscode/\n")?;
-        std::fs::write(repo.join("tracked.txt"), "snapshot version\n")?;
-        let vscode = repo.join(".vscode");
-        std::fs::create_dir_all(&vscode)?;
-        std::fs::write(vscode.join("settings.json"), "{\n  \"before\": true\n}\n")?;
-        run_git_in(repo, &["add", ".gitignore", "tracked.txt"]);
-        run_git_in(
-            repo,
-            &[
-                "-c",
-                "user.name=Tester",
-                "-c",
-                "user.email=test@example.com",
-                "commit",
-                "-m",
-                "initial",
-            ],
-        );
-
-        std::fs::write(repo.join("tracked.txt"), "snapshot delta\n")?;
-        let ghost = create_ghost_commit(&CreateGhostCommitOptions::new(repo))?;
-
-        std::fs::write(repo.join("tracked.txt"), "post-snapshot\n")?;
-        std::fs::write(vscode.join("settings.json"), "{\n  \"after\": true\n}\n")?;
-        std::fs::write(repo.join("temp.txt"), "new file\n")?;
-
-        restore_ghost_commit(repo, &ghost)?;
-
-        let tracked_after = std::fs::read_to_string(repo.join("tracked.txt"))?;
-        assert_eq!(tracked_after, "snapshot delta\n");
-        assert!(vscode.join("settings.json").exists());
-        let settings_after = std::fs::read_to_string(vscode.join("settings.json"))?;
-        assert_eq!(settings_after, "{\n  \"after\": true\n}\n");
-        assert!(repo.join("temp.txt").exists());
-
-        Ok(())
-    }
-}

codex-rs/git-tooling/src/lib.rs

@@ -1,43 +0,0 @@
-use std::fmt;
-
-mod errors;
-mod ghost_commits;
-mod operations;
-mod platform;
-
-pub use errors::GitToolingError;
-pub use ghost_commits::CreateGhostCommitOptions;
-pub use ghost_commits::create_ghost_commit;
-pub use ghost_commits::restore_ghost_commit;
-pub use ghost_commits::restore_to_commit;
-pub use platform::create_symlink;
-
-/// Details of a ghost commit created from a repository state.
-#[derive(Debug, Clone, PartialEq, Eq)]
-pub struct GhostCommit {
-    id: String,
-    parent: Option<String>,
-}
-
-impl GhostCommit {
-    /// Create a new ghost commit wrapper from a raw commit ID and optional parent.
-    pub fn new(id: String, parent: Option<String>) -> Self {
-        Self { id, parent }
-    }
-
-    /// Commit ID for the snapshot.
-    pub fn id(&self) -> &str {
-        &self.id
-    }
-
-    /// Parent commit ID, if the repository had a `HEAD` at creation time.
-    pub fn parent(&self) -> Option<&str> {
-        self.parent.as_deref()
-    }
-}
-
-impl fmt::Display for GhostCommit {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        write!(f, "{}", self.id)
-    }
-}

codex-rs/git-tooling/src/operations.rs

@@ -1,218 +0,0 @@
-use std::ffi::OsStr;
-use std::ffi::OsString;
-use std::path::Component;
-use std::path::Path;
-use std::path::PathBuf;
-use std::process::Command;
-
-use crate::GitToolingError;
-
-pub(crate) fn ensure_git_repository(path: &Path) -> Result<(), GitToolingError> {
-    match run_git_for_stdout(
-        path,
-        vec![
-            OsString::from("rev-parse"),
-            OsString::from("--is-inside-work-tree"),
-        ],
-        None,
-    ) {
-        Ok(output) if output.trim() == "true" => Ok(()),
-        Ok(_) => Err(GitToolingError::NotAGitRepository {
-            path: path.to_path_buf(),
-        }),
-        Err(GitToolingError::GitCommand { status, .. }) if status.code() == Some(128) => {
-            Err(GitToolingError::NotAGitRepository {
-                path: path.to_path_buf(),
-            })
-        }
-        Err(err) => Err(err),
-    }
-}
-
-pub(crate) fn resolve_head(path: &Path) -> Result<Option<String>, GitToolingError> {
-    match run_git_for_stdout(
-        path,
-        vec![
-            OsString::from("rev-parse"),
-            OsString::from("--verify"),
-            OsString::from("HEAD"),
-        ],
-        None,
-    ) {
-        Ok(sha) => Ok(Some(sha)),
-        Err(GitToolingError::GitCommand { status, .. }) if status.code() == Some(128) => Ok(None),
-        Err(other) => Err(other),
-    }
-}
-
-pub(crate) fn normalize_relative_path(path: &Path) -> Result<PathBuf, GitToolingError> {
-    let mut result = PathBuf::new();
-    let mut saw_component = false;
-    for component in path.components() {
-        saw_component = true;
-        match component {
-            Component::Normal(part) => result.push(part),
-            Component::CurDir => {}
-            Component::ParentDir => {
-                if !result.pop() {
-                    return Err(GitToolingError::PathEscapesRepository {
-                        path: path.to_path_buf(),
-                    });
-                }
-            }
-            Component::RootDir | Component::Prefix(_) => {
-                return Err(GitToolingError::NonRelativePath {
-                    path: path.to_path_buf(),
-                });
-            }
-        }
-    }
-
-    if !saw_component {
-        return Err(GitToolingError::NonRelativePath {
-            path: path.to_path_buf(),
-        });
-    }
-
-    Ok(result)
-}
-
-pub(crate) fn resolve_repository_root(path: &Path) -> Result<PathBuf, GitToolingError> {
-    let root = run_git_for_stdout(
-        path,
-        vec![
-            OsString::from("rev-parse"),
-            OsString::from("--show-toplevel"),
-        ],
-        None,
-    )?;
-    Ok(PathBuf::from(root))
-}
-
-pub(crate) fn apply_repo_prefix_to_force_include(
-    prefix: Option<&Path>,
-    paths: &[PathBuf],
-) -> Vec<PathBuf> {
-    if paths.is_empty() {
-        return Vec::new();
-    }
-
-    match prefix {
-        Some(prefix) => paths.iter().map(|path| prefix.join(path)).collect(),
-        None => paths.to_vec(),
-    }
-}
-
-pub(crate) fn repo_subdir(repo_root: &Path, repo_path: &Path) -> Option<PathBuf> {
-    if repo_root == repo_path {
-        return None;
-    }
-
-    repo_path
-        .strip_prefix(repo_root)
-        .ok()
-        .and_then(non_empty_path)
-        .or_else(|| {
-            let repo_root_canon = repo_root.canonicalize().ok()?;
-            let repo_path_canon = repo_path.canonicalize().ok()?;
-            repo_path_canon
-                .strip_prefix(&repo_root_canon)
-                .ok()
-                .and_then(non_empty_path)
-        })
-}
-
-fn non_empty_path(path: &Path) -> Option<PathBuf> {
-    if path.as_os_str().is_empty() {
-        None
-    } else {
-        Some(path.to_path_buf())
-    }
-}
-
-pub(crate) fn run_git_for_status<I, S>(
-    dir: &Path,
-    args: I,
-    env: Option<&[(OsString, OsString)]>,
-) -> Result<(), GitToolingError>
-where
-    I: IntoIterator<Item = S>,
-    S: AsRef<OsStr>,
-{
-    run_git(dir, args, env)?;
-    Ok(())
-}
-
-pub(crate) fn run_git_for_stdout<I, S>(
-    dir: &Path,
-    args: I,
-    env: Option<&[(OsString, OsString)]>,
-) -> Result<String, GitToolingError>
-where
-    I: IntoIterator<Item = S>,
-    S: AsRef<OsStr>,
-{
-    let run = run_git(dir, args, env)?;
-    String::from_utf8(run.output.stdout)
-        .map(|value| value.trim().to_string())
-        .map_err(|source| GitToolingError::GitOutputUtf8 {
-            command: run.command,
-            source,
-        })
-}
-
-fn run_git<I, S>(
-    dir: &Path,
-    args: I,
-    env: Option<&[(OsString, OsString)]>,
-) -> Result<GitRun, GitToolingError>
-where
-    I: IntoIterator<Item = S>,
-    S: AsRef<OsStr>,
-{
-    let iterator = args.into_iter();
-    let (lower, upper) = iterator.size_hint();
-    let mut args_vec = Vec::with_capacity(upper.unwrap_or(lower));
-    for arg in iterator {
-        args_vec.push(OsString::from(arg.as_ref()));
-    }
-    let command_string = build_command_string(&args_vec);
-    let mut command = Command::new("git");
-    command.current_dir(dir);
-    if let Some(envs) = env {
-        for (key, value) in envs {
-            command.env(key, value);
-        }
-    }
-    command.args(&args_vec);
-    let output = command.output()?;
-    if !output.status.success() {
-        let stderr = String::from_utf8_lossy(&output.stderr).trim().to_string();
-        return Err(GitToolingError::GitCommand {
-            command: command_string,
-            status: output.status,
-            stderr,
-        });
-    }
-    Ok(GitRun {
-        command: command_string,
-        output,
-    })
-}
-
-fn build_command_string(args: &[OsString]) -> String {
-    if args.is_empty() {
-        return "git".to_string();
-    }
-    let joined = args
-        .iter()
-        .map(|arg| arg.to_string_lossy().into_owned())
-        .collect::<Vec<_>>()
-        .join(" ");
-    format!("git {joined}")
-}
-
-struct GitRun {
-    command: String,
-    output: std::process::Output,
-}

codex-rs/git-tooling/src/platform.rs

@@ -1,37 +0,0 @@
-use std::path::Path;
-
-use crate::GitToolingError;
-
-#[cfg(unix)]
-pub fn create_symlink(
-    _source: &Path,
-    link_target: &Path,
-    destination: &Path,
-) -> Result<(), GitToolingError> {
-    use std::os::unix::fs::symlink;
-
-    symlink(link_target, destination)?;
-    Ok(())
-}
-
-#[cfg(windows)]
-pub fn create_symlink(
-    source: &Path,
-    link_target: &Path,
-    destination: &Path,
-) -> Result<(), GitToolingError> {
-    use std::os::windows::fs::FileTypeExt;
-    use std::os::windows::fs::symlink_dir;
-    use std::os::windows::fs::symlink_file;
-
-    let metadata = std::fs::symlink_metadata(source)?;
-    if metadata.file_type().is_symlink_dir() {
-        symlink_dir(link_target, destination)?;
-    } else {
-        symlink_file(link_target, destination)?;
-    }
-    Ok(())
-}
-
-#[cfg(not(any(unix, windows)))]
-compile_error!("codex-git-tooling symlink support is only implemented for Unix and Windows");

codex-rs/linux-sandbox/Cargo.toml

@@ -15,15 +15,15 @@ path = "src/lib.rs"
 workspace = true
 
 [target.'cfg(target_os = "linux")'.dependencies]
-clap = { workspace = true, features = ["derive"] }
-codex-core = { workspace = true }
-landlock = { workspace = true }
-libc = { workspace = true }
-seccompiler = { workspace = true }
+clap = { version = "4", features = ["derive"] }
+codex-core = { path = "../core" }
+landlock = "0.4.1"
+libc = "0.2.175"
+seccompiler = "0.5.0"
 
 [target.'cfg(target_os = "linux")'.dev-dependencies]
-tempfile = { workspace = true }
-tokio = { workspace = true, features = [
+tempfile = "3"
+tokio = { version = "1", features = [
     "io-std",
     "macros",
     "process",

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

@@ -38,7 +38,7 @@ async fn run_cmd(cmd: &[&str], writable_roots: &[PathBuf], timeout_ms: u64) {
     let cwd = std::env::current_dir().expect("cwd should exist");
     let sandbox_cwd = cwd.clone();
     let params = ExecParams {
-        command: cmd.iter().copied().map(str::to_owned).collect(),
+        command: cmd.iter().map(|elm| elm.to_string()).collect(),
         cwd,
         timeout_ms: Some(timeout_ms),
         env: create_env_from_core_vars(),
@@ -138,7 +138,7 @@ async fn assert_network_blocked(cmd: &[&str]) {
     let cwd = std::env::current_dir().expect("cwd should exist");
     let sandbox_cwd = cwd.clone();
     let params = ExecParams {
-        command: cmd.iter().copied().map(str::to_owned).collect(),
+        command: cmd.iter().map(|s| s.to_string()).collect(),
         cwd,
         // Give the tool a generous 2-second timeout so even slow DNS timeouts
         // do not stall the suite.

codex-rs/login/Cargo.toml

@@ -7,29 +7,27 @@ version = { workspace = true }
 workspace = true
 
 [dependencies]
-base64 = { workspace = true }
-chrono = { workspace = true, features = ["serde"] }
-codex-core = { workspace = true }
-codex-protocol = { workspace = true }
-rand = { workspace = true }
-reqwest = { workspace = true, features = ["json", "blocking"] }
-serde = { workspace = true, features = ["derive"] }
-serde_json = { workspace = true }
-sha2 = { workspace = true }
-tempfile = { workspace = true }
-tiny_http = { workspace = true }
-tokio = { workspace = true, features = [
+base64 = "0.22"
+chrono = { version = "0.4", features = ["serde"] }
+codex-core = { path = "../core" }
+codex-protocol = { path = "../protocol" }
+rand = "0.8"
+reqwest = { version = "0.12", features = ["json", "blocking"] }
+serde = { version = "1", features = ["derive"] }
+serde_json = "1"
+sha2 = "0.10"
+tempfile = "3"
+tiny_http = "0.12"
+tokio = { version = "1", features = [
     "io-std",
     "macros",
     "process",
     "rt-multi-thread",
     "signal",
 ] }
-url = { workspace = true }
-urlencoding = { workspace = true }
-webbrowser = { workspace = true }
+url = "2"
+urlencoding = "2.1"
+webbrowser = "1.0"
 
 [dev-dependencies]
-anyhow = { workspace = true }
-core_test_support = { workspace = true }
-tempfile = { workspace = true }
+tempfile = "3"

codex-rs/login/src/pkce.rs

@@ -11,7 +11,7 @@ pub struct PkceCodes {
 
 pub fn generate_pkce() -> PkceCodes {
     let mut bytes = [0u8; 64];
-    rand::rng().fill_bytes(&mut bytes);
+    rand::thread_rng().fill_bytes(&mut bytes);
 
     // Verifier: URL-safe base64 without padding (43..128 chars)
     let code_verifier = base64::engine::general_purpose::URL_SAFE_NO_PAD.encode(bytes);

codex-rs/login/src/server.rs

@@ -20,7 +20,6 @@ use codex_core::default_client::ORIGINATOR;
 use codex_core::token_data::TokenData;
 use codex_core::token_data::parse_id_token;
 use rand::RngCore;
-use serde_json::Value as JsonValue;
 use tiny_http::Header;
 use tiny_http::Request;
 use tiny_http::Response;
@@ -327,7 +326,7 @@ fn build_authorize_url(
 
 fn generate_state() -> String {
     let mut bytes = [0u8; 32];
-    rand::rng().fill_bytes(&mut bytes);
+    rand::thread_rng().fill_bytes(&mut bytes);
     base64::engine::general_purpose::URL_SAFE_NO_PAD.encode(bytes)
 }
 
@@ -497,11 +496,11 @@ fn compose_success_url(port: u16, issuer: &str, id_token: &str, access_token: &s
         .unwrap_or("");
     let completed_onboarding = token_claims
         .get("completed_platform_onboarding")
-        .and_then(JsonValue::as_bool)
+        .and_then(|v| v.as_bool())
         .unwrap_or(false);
     let is_org_owner = token_claims
         .get("is_org_owner")
-        .and_then(JsonValue::as_bool)
+        .and_then(|v| v.as_bool())
         .unwrap_or(false);
     let needs_setup = (!completed_onboarding) && is_org_owner;
     let plan_type = access_claims

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

@@ -5,14 +5,13 @@ use std::net::TcpListener;
 use std::thread;
 use std::time::Duration;
 
-use anyhow::Result;
 use base64::Engine;
 use codex_login::ServerOptions;
 use codex_login::run_login_server;
-use core_test_support::non_sandbox_test;
 use tempfile::tempdir;
 
 // See spawn.rs for details
+pub const CODEX_SANDBOX_NETWORK_DISABLED_ENV_VAR: &str = "CODEX_SANDBOX_NETWORK_DISABLED";
 
 fn start_mock_issuer() -> (SocketAddr, thread::JoinHandle<()>) {
     // Bind to a random available port
@@ -77,13 +76,18 @@ fn start_mock_issuer() -> (SocketAddr, thread::JoinHandle<()>) {
 }
 
 #[tokio::test]
-async fn end_to_end_login_flow_persists_auth_json() -> Result<()> {
-    non_sandbox_test!(result);
+async fn end_to_end_login_flow_persists_auth_json() {
+    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;
+    }
 
     let (issuer_addr, issuer_handle) = start_mock_issuer();
     let issuer = format!("http://{}:{}", issuer_addr.ip(), issuer_addr.port());
 
-    let tmp = tempdir()?;
+    let tmp = tempdir().unwrap();
     let codex_home = tmp.path().to_path_buf();
 
     // Seed auth.json with stale API key + tokens that should be overwritten.
@@ -98,8 +102,9 @@ async fn end_to_end_login_flow_persists_auth_json() -> Result<()> {
     });
     std::fs::write(
         codex_home.join("auth.json"),
-        serde_json::to_string_pretty(&stale_auth)?,
-    )?;
+        serde_json::to_string_pretty(&stale_auth).unwrap(),
+    )
+    .unwrap();
 
     let state = "test_state_123".to_string();
 
@@ -114,24 +119,25 @@ async fn end_to_end_login_flow_persists_auth_json() -> Result<()> {
         open_browser: false,
         force_state: Some(state),
     };
-    let server = run_login_server(opts)?;
+    let server = run_login_server(opts).unwrap();
     let login_port = server.actual_port;
 
     // Simulate browser callback, and follow redirect to /success
     let client = reqwest::Client::builder()
         .redirect(reqwest::redirect::Policy::limited(5))
-        .build()?;
+        .build()
+        .unwrap();
     let url = format!("http://127.0.0.1:{login_port}/auth/callback?code=abc&state=test_state_123");
-    let resp = client.get(&url).send().await?;
+    let resp = client.get(&url).send().await.unwrap();
     assert!(resp.status().is_success());
 
     // Wait for server shutdown
-    server.block_until_done().await?;
+    server.block_until_done().await.unwrap();
 
     // Validate auth.json
     let auth_path = codex_home.join("auth.json");
-    let data = std::fs::read_to_string(&auth_path)?;
-    let json: serde_json::Value = serde_json::from_str(&data)?;
+    let data = std::fs::read_to_string(&auth_path).unwrap();
+    let json: serde_json::Value = serde_json::from_str(&data).unwrap();
     // The following assert is here because of the old oauth flow that exchanges tokens for an
     // API key. See obtain_api_key in server.rs for details. Once we remove this old mechanism
     // from the code, this test should be updated to expect that the API key is no longer present.
@@ -142,17 +148,21 @@ async fn end_to_end_login_flow_persists_auth_json() -> Result<()> {
 
     // Stop mock issuer
     drop(issuer_handle);
-    Ok(())
 }
 
 #[tokio::test]
-async fn creates_missing_codex_home_dir() -> Result<()> {
-    non_sandbox_test!(result);
+async fn creates_missing_codex_home_dir() {
+    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;
+    }
 
     let (issuer_addr, _issuer_handle) = start_mock_issuer();
     let issuer = format!("http://{}:{}", issuer_addr.ip(), issuer_addr.port());
 
-    let tmp = tempdir()?;
+    let tmp = tempdir().unwrap();
     let codex_home = tmp.path().join("missing-subdir"); // does not exist
 
     let state = "state2".to_string();
@@ -167,32 +177,36 @@ async fn creates_missing_codex_home_dir() -> Result<()> {
         open_browser: false,
         force_state: Some(state),
     };
-    let server = run_login_server(opts)?;
+    let server = run_login_server(opts).unwrap();
     let login_port = server.actual_port;
 
     let client = reqwest::Client::new();
     let url = format!("http://127.0.0.1:{login_port}/auth/callback?code=abc&state=state2");
-    let resp = client.get(&url).send().await?;
+    let resp = client.get(&url).send().await.unwrap();
     assert!(resp.status().is_success());
 
-    server.block_until_done().await?;
+    server.block_until_done().await.unwrap();
 
     let auth_path = codex_home.join("auth.json");
     assert!(
         auth_path.exists(),
         "auth.json should be created even if parent dir was missing"
     );
-    Ok(())
 }
 
 #[tokio::test(flavor = "multi_thread", worker_threads = 4)]
-async fn cancels_previous_login_server_when_port_is_in_use() -> Result<()> {
-    non_sandbox_test!(result);
+async fn cancels_previous_login_server_when_port_is_in_use() {
+    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;
+    }
 
     let (issuer_addr, _issuer_handle) = start_mock_issuer();
     let issuer = format!("http://{}:{}", issuer_addr.ip(), issuer_addr.port());
 
-    let first_tmp = tempdir()?;
+    let first_tmp = tempdir().unwrap();
     let first_codex_home = first_tmp.path().to_path_buf();
 
     let first_opts = ServerOptions {
@@ -204,13 +218,13 @@ async fn cancels_previous_login_server_when_port_is_in_use() -> Result<()> {
         force_state: Some("cancel_state".to_string()),
     };
 
-    let first_server = run_login_server(first_opts)?;
+    let first_server = run_login_server(first_opts).unwrap();
     let login_port = first_server.actual_port;
     let first_server_task = tokio::spawn(async move { first_server.block_until_done().await });
 
     tokio::time::sleep(Duration::from_millis(100)).await;
 
-    let second_tmp = tempdir()?;
+    let second_tmp = tempdir().unwrap();
     let second_codex_home = second_tmp.path().to_path_buf();
 
     let second_opts = ServerOptions {
@@ -222,7 +236,7 @@ async fn cancels_previous_login_server_when_port_is_in_use() -> Result<()> {
         force_state: Some("cancel_state_2".to_string()),
     };
 
-    let second_server = run_login_server(second_opts)?;
+    let second_server = run_login_server(second_opts).unwrap();
     assert_eq!(second_server.actual_port, login_port);
 
     let cancel_result = first_server_task
@@ -233,12 +247,11 @@ async fn cancels_previous_login_server_when_port_is_in_use() -> Result<()> {
 
     let client = reqwest::Client::new();
     let cancel_url = format!("http://127.0.0.1:{login_port}/cancel");
-    let resp = client.get(cancel_url).send().await?;
+    let resp = client.get(cancel_url).send().await.unwrap();
     assert!(resp.status().is_success());
 
     second_server
         .block_until_done()
         .await
         .expect_err("second login server should report cancellation");
-    Ok(())
 }

codex-rs/mcp-client/Cargo.toml

@@ -7,13 +7,13 @@ edition = "2024"
 workspace = true
 
 [dependencies]
-anyhow = { workspace = true }
-mcp-types = { workspace = true }
-serde = { workspace = true, features = ["derive"] }
-serde_json = { workspace = true }
-tracing = { workspace = true, features = ["log"] }
-tracing-subscriber = { workspace = true, features = ["fmt", "env-filter"] }
-tokio = { workspace = true, features = [
+anyhow = "1"
+mcp-types = { path = "../mcp-types" }
+serde = { version = "1", features = ["derive"] }
+serde_json = "1"
+tracing = { version = "0.1.41", features = ["log"] }
+tracing-subscriber = { version = "0.3", features = ["fmt", "env-filter"] }
+tokio = { version = "1", features = [
     "io-util",
     "macros",
     "process",

codex-rs/mcp-server/Cargo.toml

@@ -15,35 +15,34 @@ path = "src/lib.rs"
 workspace = true
 
 [dependencies]
-anyhow = { workspace = true }
-codex-arg0 = { workspace = true }
-codex-common = { workspace = true, features = ["cli"] }
-codex-core = { workspace = true }
-codex-login = { workspace = true }
-codex-protocol = { workspace = true }
-mcp-types = { workspace = true }
-schemars = { workspace = true }
-serde = { workspace = true, features = ["derive"] }
-serde_json = { workspace = true }
-shlex = { workspace = true }
-tokio = { workspace = true, features = [
+anyhow = "1"
+codex-arg0 = { path = "../arg0" }
+codex-common = { path = "../common", features = ["cli"] }
+codex-core = { path = "../core" }
+codex-login = { path = "../login" }
+codex-protocol = { path = "../protocol" }
+mcp-types = { path = "../mcp-types" }
+schemars = "0.8.22"
+serde = { version = "1", features = ["derive"] }
+serde_json = "1"
+shlex = "1.3.0"
+tokio = { version = "1", features = [
     "io-std",
     "macros",
     "process",
     "rt-multi-thread",
     "signal",
 ] }
-toml = { workspace = true }
-tracing = { workspace = true, features = ["log"] }
-tracing-subscriber = { workspace = true, features = ["env-filter", "fmt"] }
-uuid = { workspace = true, features = ["serde", "v7"] }
+toml = "0.9"
+tracing = { version = "0.1.41", features = ["log"] }
+tracing-subscriber = { version = "0.3", features = ["env-filter", "fmt"] }
+uuid = { version = "1", features = ["serde", "v7"] }
 
 [dev-dependencies]
-assert_cmd = { workspace = true }
-base64 = { workspace = true }
-core_test_support = { workspace = true }
-mcp_test_support = { workspace = true }
-os_info = { workspace = true }
-pretty_assertions = { workspace = true }
-tempfile = { workspace = true }
-wiremock = { workspace = true }
+assert_cmd = "2"
+base64 = "0.22"
+mcp_test_support = { path = "tests/common" }
+os_info = "3.12.0"
+pretty_assertions = "1.4.1"
+tempfile = "3"
+wiremock = "0.6"

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

@@ -1009,7 +1009,6 @@ impl CodexMessageProcessor {
                 model,
                 effort,
                 summary,
-                final_output_json_schema: None,
             })
             .await;
 
@@ -1411,13 +1410,13 @@ fn extract_conversation_summary(
 #[cfg(test)]
 mod tests {
     use super::*;
-    use anyhow::Result;
     use pretty_assertions::assert_eq;
     use serde_json::json;
 
     #[test]
-    fn extract_conversation_summary_prefers_plain_user_messages() -> Result<()> {
-        let conversation_id = ConversationId::from_string("3f941c35-29b3-493b-b0a4-e25800d9aeb0")?;
+    fn extract_conversation_summary_prefers_plain_user_messages() {
+        let conversation_id =
+            ConversationId::from_string("3f941c35-29b3-493b-b0a4-e25800d9aeb0").unwrap();
         let timestamp = Some("2025-09-05T16:53:11.850Z".to_string());
         let path = PathBuf::from("rollout.jsonl");
 
@@ -1457,6 +1456,5 @@ mod tests {
         );
         assert_eq!(summary.path, path);
         assert_eq!(summary.preview, "Count to 5");
-        Ok(())
     }
 }