Merge branch 'dev/shaqayeq/python-sdk-pinned-artifacts' into dev/shaqayeq/python-sdk-ci

2026-11-01 19:33:35 +00:00 · 2026-03-23 16:44:12 -07:00
parent 0328f4aa94 8942547f80
commit 7fc6542998
479 changed files with 27209 additions and 7545 deletions
@@ -0,0 +1,16 @@
+---
+name: remote-tests
+description: How to run tests using remote executor.
+---
+
+Some codex integration tests support a running against a remote executor.
+This means that when CODEX_TEST_REMOTE_ENV environment variable is set they will attempt to start an executor process in a docker container CODEX_TEST_REMOTE_ENV points to and use it in tests.
+
+Docker container is built and initialized via ./scripts/test-remote-env.sh
+
+Currently running remote tests is only supported on Linux, so you need to use a devbox to run them
+
+You can list devboxes via `applied_devbox ls`, pick the one with `codex` in the name.
+Connect to devbox via `ssh <devbox_name>`.
+Reuse the same checkout of codex in `~/code/codex`. Reset files if needed. Multiple checkouts take longer to build and take up more space.
+Check whether the SHA and modified files are in sync between remote and local.
@@ -132,9 +132,11 @@ runs:
          keychain_args+=(--keychain "${APPLE_CODESIGN_KEYCHAIN}")
        fi

+        entitlements_path="$GITHUB_ACTION_PATH/codex.entitlements.plist"
+
        for binary in codex codex-responses-api-proxy; do
          path="codex-rs/target/${TARGET}/release/${binary}"
-          codesign --force --options runtime --timestamp --sign "$APPLE_CODESIGN_IDENTITY" "${keychain_args[@]}" "$path"
+          codesign --force --options runtime --timestamp --entitlements "$entitlements_path" --sign "$APPLE_CODESIGN_IDENTITY" "${keychain_args[@]}" "$path"
        done

    - name: Notarize macOS binaries
@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+	<key>com.apple.security.cs.allow-jit</key>
+	<true/>
+</dict>
+</plist>
@@ -0,0 +1,287 @@
+#!/usr/bin/env python3
+
+from __future__ import annotations
+
+import argparse
+import gzip
+import re
+import shutil
+import subprocess
+import sys
+import tempfile
+import tomllib
+from pathlib import Path
+
+
+ROOT = Path(__file__).resolve().parents[2]
+MUSL_RUNTIME_ARCHIVE_LABELS = [
+    "@llvm//runtimes/libcxx:libcxx.static",
+    "@llvm//runtimes/libcxx:libcxxabi.static",
+]
+LLVM_AR_LABEL = "@llvm//tools:llvm-ar"
+LLVM_RANLIB_LABEL = "@llvm//tools:llvm-ranlib"
+
+
+def bazel_execroot() -> Path:
+    result = subprocess.run(
+        ["bazel", "info", "execution_root"],
+        cwd=ROOT,
+        check=True,
+        capture_output=True,
+        text=True,
+    )
+    return Path(result.stdout.strip())
+
+
+def bazel_output_base() -> Path:
+    result = subprocess.run(
+        ["bazel", "info", "output_base"],
+        cwd=ROOT,
+        check=True,
+        capture_output=True,
+        text=True,
+    )
+    return Path(result.stdout.strip())
+
+
+def bazel_output_path(path: str) -> Path:
+    if path.startswith("external/"):
+        return bazel_output_base() / path
+    return bazel_execroot() / path
+
+
+def bazel_output_files(
+    platform: str,
+    labels: list[str],
+    compilation_mode: str = "fastbuild",
+) -> list[Path]:
+    expression = "set(" + " ".join(labels) + ")"
+    result = subprocess.run(
+        [
+            "bazel",
+            "cquery",
+            "-c",
+            compilation_mode,
+            f"--platforms=@llvm//platforms:{platform}",
+            "--output=files",
+            expression,
+        ],
+        cwd=ROOT,
+        check=True,
+        capture_output=True,
+        text=True,
+    )
+    return [bazel_output_path(line.strip()) for line in result.stdout.splitlines() if line.strip()]
+
+
+def bazel_build(
+    platform: str,
+    labels: list[str],
+    compilation_mode: str = "fastbuild",
+) -> None:
+    subprocess.run(
+        [
+            "bazel",
+            "build",
+            "-c",
+            compilation_mode,
+            f"--platforms=@llvm//platforms:{platform}",
+            *labels,
+        ],
+        cwd=ROOT,
+        check=True,
+    )
+
+
+def ensure_bazel_output_files(
+    platform: str,
+    labels: list[str],
+    compilation_mode: str = "fastbuild",
+) -> list[Path]:
+    outputs = bazel_output_files(platform, labels, compilation_mode)
+    if all(path.exists() for path in outputs):
+        return outputs
+
+    bazel_build(platform, labels, compilation_mode)
+    outputs = bazel_output_files(platform, labels, compilation_mode)
+    missing = [str(path) for path in outputs if not path.exists()]
+    if missing:
+        raise SystemExit(f"missing built outputs for {labels}: {missing}")
+    return outputs
+
+
+def release_pair_label(target: str) -> str:
+    target_suffix = target.replace("-", "_")
+    return f"//third_party/v8:rusty_v8_release_pair_{target_suffix}"
+
+
+def resolved_v8_crate_version() -> str:
+    cargo_lock = tomllib.loads((ROOT / "codex-rs" / "Cargo.lock").read_text())
+    versions = sorted(
+        {
+            package["version"]
+            for package in cargo_lock["package"]
+            if package["name"] == "v8"
+        }
+    )
+    if len(versions) == 1:
+        return versions[0]
+    if len(versions) > 1:
+        raise SystemExit(f"expected exactly one resolved v8 version, found: {versions}")
+
+    module_bazel = (ROOT / "MODULE.bazel").read_text()
+    matches = sorted(
+        set(
+            re.findall(
+                r'https://static\.crates\.io/crates/v8/v8-([0-9]+\.[0-9]+\.[0-9]+)\.crate',
+                module_bazel,
+            )
+        )
+    )
+    if len(matches) != 1:
+        raise SystemExit(
+            "expected exactly one pinned v8 crate version in MODULE.bazel, "
+            f"found: {matches}"
+        )
+    return matches[0]
+
+
+def staged_archive_name(target: str, source_path: Path) -> str:
+    if source_path.suffix == ".lib":
+        return f"rusty_v8_release_{target}.lib.gz"
+    return f"librusty_v8_release_{target}.a.gz"
+
+
+def is_musl_archive_target(target: str, source_path: Path) -> bool:
+    return target.endswith("-unknown-linux-musl") and source_path.suffix == ".a"
+
+
+def single_bazel_output_file(
+    platform: str,
+    label: str,
+    compilation_mode: str = "fastbuild",
+) -> Path:
+    outputs = ensure_bazel_output_files(platform, [label], compilation_mode)
+    if len(outputs) != 1:
+        raise SystemExit(f"expected exactly one output for {label}, found {outputs}")
+    return outputs[0]
+
+
+def merged_musl_archive(
+    platform: str,
+    lib_path: Path,
+    compilation_mode: str = "fastbuild",
+) -> Path:
+    llvm_ar = single_bazel_output_file(platform, LLVM_AR_LABEL, compilation_mode)
+    llvm_ranlib = single_bazel_output_file(platform, LLVM_RANLIB_LABEL, compilation_mode)
+    runtime_archives = [
+        single_bazel_output_file(platform, label, compilation_mode)
+        for label in MUSL_RUNTIME_ARCHIVE_LABELS
+    ]
+
+    temp_dir = Path(tempfile.mkdtemp(prefix="rusty-v8-musl-stage-"))
+    merged_archive = temp_dir / lib_path.name
+    merge_commands = "\n".join(
+        [
+            f"create {merged_archive}",
+            f"addlib {lib_path}",
+            *[f"addlib {archive}" for archive in runtime_archives],
+            "save",
+            "end",
+        ]
+    )
+    subprocess.run(
+        [str(llvm_ar), "-M"],
+        cwd=ROOT,
+        check=True,
+        input=merge_commands,
+        text=True,
+    )
+    subprocess.run([str(llvm_ranlib), str(merged_archive)], cwd=ROOT, check=True)
+    return merged_archive
+
+
+def stage_release_pair(
+    platform: str,
+    target: str,
+    output_dir: Path,
+    compilation_mode: str = "fastbuild",
+) -> None:
+    outputs = ensure_bazel_output_files(
+        platform,
+        [release_pair_label(target)],
+        compilation_mode,
+    )
+
+    try:
+        lib_path = next(path for path in outputs if path.suffix in {".a", ".lib"})
+    except StopIteration as exc:
+        raise SystemExit(f"missing static library output for {target}") from exc
+
+    try:
+        binding_path = next(path for path in outputs if path.suffix == ".rs")
+    except StopIteration as exc:
+        raise SystemExit(f"missing Rust binding output for {target}") from exc
+
+    output_dir.mkdir(parents=True, exist_ok=True)
+    staged_library = output_dir / staged_archive_name(target, lib_path)
+    staged_binding = output_dir / f"src_binding_release_{target}.rs"
+    source_archive = (
+        merged_musl_archive(platform, lib_path, compilation_mode)
+        if is_musl_archive_target(target, lib_path)
+        else lib_path
+    )
+
+    with source_archive.open("rb") as src, staged_library.open("wb") as dst:
+        with gzip.GzipFile(
+            filename="",
+            mode="wb",
+            fileobj=dst,
+            compresslevel=6,
+            mtime=0,
+        ) as gz:
+            shutil.copyfileobj(src, gz)
+
+    shutil.copyfile(binding_path, staged_binding)
+
+    print(staged_library)
+    print(staged_binding)
+
+
+def parse_args() -> argparse.Namespace:
+    parser = argparse.ArgumentParser()
+    subparsers = parser.add_subparsers(dest="command", required=True)
+
+    stage_release_pair_parser = subparsers.add_parser("stage-release-pair")
+    stage_release_pair_parser.add_argument("--platform", required=True)
+    stage_release_pair_parser.add_argument("--target", required=True)
+    stage_release_pair_parser.add_argument("--output-dir", required=True)
+    stage_release_pair_parser.add_argument(
+        "--compilation-mode",
+        default="fastbuild",
+        choices=["fastbuild", "opt", "dbg"],
+    )
+
+    subparsers.add_parser("resolved-v8-crate-version")
+
+    return parser.parse_args()
+
+
+def main() -> int:
+    args = parse_args()
+    if args.command == "stage-release-pair":
+        stage_release_pair(
+            platform=args.platform,
+            target=args.target,
+            output_dir=Path(args.output_dir),
+            compilation_mode=args.compilation_mode,
+        )
+        return 0
+    if args.command == "resolved-v8-crate-version":
+        print(resolved_v8_crate_version())
+        return 0
+    raise SystemExit(f"unsupported command: {args.command}")
+
+
+if __name__ == "__main__":
+    sys.exit(main())
@@ -156,7 +156,6 @@ jobs:

          bazel_args=(
            test
-            //...
            --test_verbose_timeout_warnings
            --build_metadata=REPO_URL=https://github.com/openai/codex.git
            --build_metadata=COMMIT_SHA=$(git rev-parse HEAD)
@@ -164,6 +163,13 @@ jobs:
            --build_metadata=VISIBILITY=PUBLIC
          )

+          bazel_targets=(
+            //...
+            # Keep V8 out of the ordinary Bazel CI path. Only the dedicated
+            # canary and release workflows should build `third_party/v8`.
+            -//third_party/v8:all
+          )
+
          if [[ "${RUNNER_OS:-}" != "Windows" ]]; then
            # Bazel test sandboxes on macOS may resolve an older Homebrew `node`
            # before the `actions/setup-node` runtime on PATH.
@@ -183,6 +189,8 @@ jobs:
              --bazelrc=.github/workflows/ci.bazelrc \
              "${bazel_args[@]}" \
              "--remote_header=x-buildbuddy-api-key=$BUILDBUDDY_API_KEY" \
+              -- \
+              "${bazel_targets[@]}" \
              2>&1 | tee "$bazel_console_log"
            bazel_status=${PIPESTATUS[0]}
            set -e
@@ -210,6 +218,8 @@ jobs:
              "${bazel_args[@]}" \
              --remote_cache= \
              --remote_executor= \
+              -- \
+              "${bazel_targets[@]}" \
              2>&1 | tee "$bazel_console_log"
            bazel_status=${PIPESTATUS[0]}
            set -e
@@ -91,17 +91,13 @@ jobs:
      - name: cargo shear
        run: cargo shear

-  argument_comment_lint:
-    name: Argument comment lint
+  argument_comment_lint_package:
+    name: Argument comment lint package
    runs-on: ubuntu-24.04
    needs: changed
-    if: ${{ needs.changed.outputs.argument_comment_lint == 'true' || needs.changed.outputs.workflows == 'true' || github.event_name == 'push' }}
+    if: ${{ needs.changed.outputs.argument_comment_lint_package == 'true' || github.event_name == 'push' }}
    steps:
      - uses: actions/checkout@v6
-      - name: Install Linux sandbox build dependencies
-        run: |
-          sudo DEBIAN_FRONTEND=noninteractive apt-get update
-          sudo DEBIAN_FRONTEND=noninteractive apt-get install -y --no-install-recommends pkg-config libcap-dev
      - uses: dtolnay/rust-toolchain@1.93.0
        with:
          toolchain: nightly-2025-09-18
@@ -120,14 +116,46 @@ jobs:
      - name: Install cargo-dylint tooling
        if: ${{ steps.cargo_dylint_cache.outputs.cache-hit != 'true' }}
        run: cargo install --locked cargo-dylint dylint-link
+      - name: Check source wrapper syntax
+        run: bash -n tools/argument-comment-lint/run.sh
      - name: Test argument comment lint package
-        if: ${{ needs.changed.outputs.argument_comment_lint_package == 'true' || github.event_name == 'push' }}
        working-directory: tools/argument-comment-lint
        run: cargo test
-      - name: Run argument comment lint on codex-rs
+
+  argument_comment_lint_prebuilt:
+    name: Argument comment lint - ${{ matrix.name }}
+    runs-on: ${{ matrix.runs_on || matrix.runner }}
+    needs: changed
+    if: ${{ needs.changed.outputs.argument_comment_lint == 'true' || needs.changed.outputs.workflows == 'true' || github.event_name == 'push' }}
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          - name: Linux
+            runner: ubuntu-24.04
+          - name: macOS
+            runner: macos-15-xlarge
+          - name: Windows
+            runner: windows-x64
+            runs_on:
+              group: codex-runners
+              labels: codex-windows-x64
+    steps:
+      - uses: actions/checkout@v6
+      - name: Install Linux sandbox build dependencies
+        if: ${{ runner.os == 'Linux' }}
+        shell: bash
        run: |
-          bash -n tools/argument-comment-lint/run.sh
-          ./tools/argument-comment-lint/run.sh
+          sudo DEBIAN_FRONTEND=noninteractive apt-get update
+          sudo DEBIAN_FRONTEND=noninteractive apt-get install -y --no-install-recommends pkg-config libcap-dev
+      - uses: dtolnay/rust-toolchain@1.93.0
+        with:
+          toolchain: nightly-2025-09-18
+          components: llvm-tools-preview, rustc-dev, rust-src
+      - uses: facebook/install-dotslash@v2
+      - name: Run argument comment lint on codex-rs
+        shell: bash
+        run: ./tools/argument-comment-lint/run-prebuilt-linter.sh

  # --- CI to validate on different os/targets --------------------------------
  lint_build:
@@ -419,6 +447,24 @@ jobs:
          echo "CFLAGS=${cflags}" >> "$GITHUB_ENV"
          echo "CXXFLAGS=${cxxflags}" >> "$GITHUB_ENV"

+      - if: ${{ matrix.target == 'x86_64-unknown-linux-musl' || matrix.target == 'aarch64-unknown-linux-musl' }}
+        name: Configure musl rusty_v8 artifact overrides
+        env:
+          TARGET: ${{ matrix.target }}
+        shell: bash
+        run: |
+          set -euo pipefail
+          version="$(python3 "${GITHUB_WORKSPACE}/.github/scripts/rusty_v8_bazel.py" resolved-v8-crate-version)"
+          release_tag="rusty-v8-v${version}"
+          base_url="https://github.com/openai/codex/releases/download/${release_tag}"
+          archive="https://github.com/openai/codex/releases/download/rusty-v8-v${version}/librusty_v8_release_${TARGET}.a.gz"
+          binding_dir="${RUNNER_TEMP}/rusty_v8"
+          binding_path="${binding_dir}/src_binding_release_${TARGET}.rs"
+          mkdir -p "${binding_dir}"
+          curl -fsSL "${base_url}/src_binding_release_${TARGET}.rs" -o "${binding_path}"
+          echo "RUSTY_V8_ARCHIVE=${archive}" >> "$GITHUB_ENV"
+          echo "RUSTY_V8_SRC_BINDING_PATH=${binding_path}" >> "$GITHUB_ENV"
+
      - name: Install cargo-chef
        if: ${{ matrix.profile == 'release' }}
        uses: taiki-e/install-action@44c6d64aa62cd779e873306675c7a58e86d6d532 # v2
@@ -499,7 +545,7 @@ jobs:
          key: apt-${{ matrix.runner }}-${{ matrix.target }}-v1

  tests:
-    name: Tests — ${{ matrix.runner }} - ${{ matrix.target }}
+    name: Tests — ${{ matrix.runner }} - ${{ matrix.target }}${{ matrix.remote_env == 'true' && ' (remote)' || '' }}
    runs-on: ${{ matrix.runs_on || matrix.runner }}
    timeout-minutes: 30
    needs: changed
@@ -525,6 +571,7 @@ jobs:
          - runner: ubuntu-24.04
            target: x86_64-unknown-linux-gnu
            profile: dev
+            remote_env: "true"
            runs_on:
              group: codex-runners
              labels: codex-linux-x64
@@ -562,6 +609,7 @@ jobs:
            sudo apt-get update -y
            sudo DEBIAN_FRONTEND=noninteractive apt-get install -y --no-install-recommends pkg-config libcap-dev
          fi
+
      # Some integration tests rely on DotSlash being installed.
      # See https://github.com/openai/codex/pull/7617.
      - name: Install DotSlash
@@ -646,6 +694,15 @@ jobs:
            sudo sysctl -w kernel.apparmor_restrict_unprivileged_userns=0
          fi

+      - name: Set up remote test env (Docker)
+        if: ${{ runner.os == 'Linux' && matrix.remote_env == 'true' }}
+        shell: bash
+        run: |
+          set -euo pipefail
+          export CODEX_TEST_REMOTE_ENV_CONTAINER_NAME=codex-remote-test-env
+          source "${GITHUB_WORKSPACE}/scripts/test-remote-env.sh"
+          echo "CODEX_TEST_REMOTE_ENV=${CODEX_TEST_REMOTE_ENV}" >> "$GITHUB_ENV"
+
      - name: tests
        id: test
        run: cargo nextest run --all-features --no-fail-fast --target ${{ matrix.target }} --cargo-profile ci-test --timings
@@ -698,6 +755,16 @@ jobs:
            echo '```';
          } >> "$GITHUB_STEP_SUMMARY"

+      - name: Tear down remote test env
+        if: ${{ always() && runner.os == 'Linux' && matrix.remote_env == 'true' }}
+        shell: bash
+        run: |
+          set +e
+          if [[ "${{ steps.test.outcome }}" != "success" ]]; then
+            docker logs codex-remote-test-env || true
+          fi
+          docker rm -f codex-remote-test-env >/dev/null 2>&1 || true
+
      - name: verify tests passed
        if: steps.test.outcome == 'failure'
        run: |
@@ -708,14 +775,23 @@ jobs:
  results:
    name: CI results (required)
    needs:
-      [changed, general, cargo_shear, argument_comment_lint, lint_build, tests]
+      [
+        changed,
+        general,
+        cargo_shear,
+        argument_comment_lint_package,
+        argument_comment_lint_prebuilt,
+        lint_build,
+        tests,
+      ]
    if: always()
    runs-on: ubuntu-24.04
    steps:
      - name: Summarize
        shell: bash
        run: |
-          echo "arglint: ${{ needs.argument_comment_lint.result }}"
+          echo "argpkg : ${{ needs.argument_comment_lint_package.result }}"
+          echo "arglint: ${{ needs.argument_comment_lint_prebuilt.result }}"
          echo "general: ${{ needs.general.result }}"
          echo "shear  : ${{ needs.cargo_shear.result }}"
          echo "lint   : ${{ needs.lint_build.result }}"
@@ -728,8 +804,12 @@ jobs:
            exit 0
          fi

+          if [[ '${{ needs.changed.outputs.argument_comment_lint_package }}' == 'true' || '${{ github.event_name }}' == 'push' ]]; then
+            [[ '${{ needs.argument_comment_lint_package.result }}' == 'success' ]] || { echo 'argument_comment_lint_package failed'; exit 1; }
+          fi
+
          if [[ '${{ needs.changed.outputs.argument_comment_lint }}' == 'true' || '${{ needs.changed.outputs.workflows }}' == 'true' || '${{ github.event_name }}' == 'push' ]]; then
-            [[ '${{ needs.argument_comment_lint.result }}' == 'success' ]] || { echo 'argument_comment_lint failed'; exit 1; }
+            [[ '${{ needs.argument_comment_lint_prebuilt.result }}' == 'success' ]] || { echo 'argument_comment_lint_prebuilt failed'; exit 1; }
          fi

          if [[ '${{ needs.changed.outputs.codex }}' == 'true' || '${{ needs.changed.outputs.workflows }}' == 'true' || '${{ github.event_name }}' == 'push' ]]; then
@@ -210,6 +210,24 @@ jobs:
          echo "CFLAGS=${cflags}" >> "$GITHUB_ENV"
          echo "CXXFLAGS=${cxxflags}" >> "$GITHUB_ENV"

+      - if: ${{ matrix.target == 'x86_64-unknown-linux-musl' || matrix.target == 'aarch64-unknown-linux-musl' }}
+        name: Configure musl rusty_v8 artifact overrides
+        env:
+          TARGET: ${{ matrix.target }}
+        shell: bash
+        run: |
+          set -euo pipefail
+          version="$(python3 "${GITHUB_WORKSPACE}/.github/scripts/rusty_v8_bazel.py" resolved-v8-crate-version)"
+          release_tag="rusty-v8-v${version}"
+          base_url="https://github.com/openai/codex/releases/download/${release_tag}"
+          archive="https://github.com/openai/codex/releases/download/rusty-v8-v${version}/librusty_v8_release_${TARGET}.a.gz"
+          binding_dir="${RUNNER_TEMP}/rusty_v8"
+          binding_path="${binding_dir}/src_binding_release_${TARGET}.rs"
+          mkdir -p "${binding_dir}"
+          curl -fsSL "${base_url}/src_binding_release_${TARGET}.rs" -o "${binding_path}"
+          echo "RUSTY_V8_ARCHIVE=${archive}" >> "$GITHUB_ENV"
+          echo "RUSTY_V8_SRC_BINDING_PATH=${binding_path}" >> "$GITHUB_ENV"
+
      - name: Cargo build
        shell: bash
        run: |
@@ -0,0 +1,188 @@
+name: rusty-v8-release
+
+on:
+  workflow_dispatch:
+    inputs:
+      release_tag:
+        description: Optional release tag. Defaults to rusty-v8-v<resolved_v8_version>.
+        required: false
+        type: string
+      publish:
+        description: Publish the staged musl artifacts to a GitHub release.
+        required: false
+        default: true
+        type: boolean
+
+concurrency:
+  group: ${{ github.workflow }}::${{ inputs.release_tag || github.run_id }}
+  cancel-in-progress: false
+
+jobs:
+  metadata:
+    runs-on: ubuntu-latest
+    outputs:
+      release_tag: ${{ steps.release_tag.outputs.release_tag }}
+      v8_version: ${{ steps.v8_version.outputs.version }}
+
+    steps:
+      - uses: actions/checkout@v6
+
+      - name: Set up Python
+        uses: actions/setup-python@v6
+        with:
+          python-version: "3.12"
+
+      - name: Resolve exact v8 crate version
+        id: v8_version
+        shell: bash
+        run: |
+          set -euo pipefail
+          version="$(python3 .github/scripts/rusty_v8_bazel.py resolved-v8-crate-version)"
+          echo "version=${version}" >> "$GITHUB_OUTPUT"
+
+      - name: Resolve release tag
+        id: release_tag
+        env:
+          RELEASE_TAG_INPUT: ${{ inputs.release_tag }}
+          V8_VERSION: ${{ steps.v8_version.outputs.version }}
+        shell: bash
+        run: |
+          set -euo pipefail
+
+          release_tag="${RELEASE_TAG_INPUT}"
+          if [[ -z "${release_tag}" ]]; then
+            release_tag="rusty-v8-v${V8_VERSION}"
+          fi
+
+          echo "release_tag=${release_tag}" >> "$GITHUB_OUTPUT"
+
+  build:
+    name: Build ${{ matrix.target }}
+    needs: metadata
+    runs-on: ${{ matrix.runner }}
+    permissions:
+      contents: read
+      actions: read
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          - runner: ubuntu-24.04
+            platform: linux_amd64_musl
+            target: x86_64-unknown-linux-musl
+          - runner: ubuntu-24.04-arm
+            platform: linux_arm64_musl
+            target: aarch64-unknown-linux-musl
+
+    steps:
+      - uses: actions/checkout@v6
+
+      - name: Set up Bazel
+        uses: bazelbuild/setup-bazelisk@v3
+
+      - name: Set up Python
+        uses: actions/setup-python@v6
+        with:
+          python-version: "3.12"
+
+      - name: Build Bazel V8 release pair
+        env:
+          BUILDBUDDY_API_KEY: ${{ secrets.BUILDBUDDY_API_KEY }}
+          PLATFORM: ${{ matrix.platform }}
+          TARGET: ${{ matrix.target }}
+        shell: bash
+        run: |
+          set -euo pipefail
+
+          target_suffix="${TARGET//-/_}"
+          pair_target="//third_party/v8:rusty_v8_release_pair_${target_suffix}"
+          extra_targets=()
+          if [[ "${TARGET}" == *-unknown-linux-musl ]]; then
+            extra_targets=(
+              "@llvm//runtimes/libcxx:libcxx.static"
+              "@llvm//runtimes/libcxx:libcxxabi.static"
+            )
+          fi
+
+          bazel_args=(
+            build
+            -c
+            opt
+            "--platforms=@llvm//platforms:${PLATFORM}"
+            "${pair_target}"
+            "${extra_targets[@]}"
+            --build_metadata=COMMIT_SHA=$(git rev-parse HEAD)
+          )
+
+          bazel \
+            --noexperimental_remote_repo_contents_cache \
+            --bazelrc=.github/workflows/v8-ci.bazelrc \
+            "${bazel_args[@]}" \
+            "--remote_header=x-buildbuddy-api-key=${BUILDBUDDY_API_KEY}"
+
+      - name: Stage release pair
+        env:
+          PLATFORM: ${{ matrix.platform }}
+          TARGET: ${{ matrix.target }}
+        shell: bash
+        run: |
+          set -euo pipefail
+
+          python3 .github/scripts/rusty_v8_bazel.py stage-release-pair \
+            --platform "${PLATFORM}" \
+            --target "${TARGET}" \
+            --compilation-mode opt \
+            --output-dir "dist/${TARGET}"
+
+      - name: Upload staged musl artifacts
+        uses: actions/upload-artifact@v7
+        with:
+          name: rusty-v8-${{ needs.metadata.outputs.v8_version }}-${{ matrix.target }}
+          path: dist/${{ matrix.target }}/*
+
+  publish-release:
+    if: ${{ inputs.publish }}
+    needs:
+      - metadata
+      - build
+    runs-on: ubuntu-latest
+    permissions:
+      contents: write
+      actions: read
+
+    steps:
+      - name: Ensure publishing from default branch
+        if: ${{ github.ref_name != github.event.repository.default_branch }}
+        env:
+          DEFAULT_BRANCH: ${{ github.event.repository.default_branch }}
+        shell: bash
+        run: |
+          set -euo pipefail
+          echo "Publishing is only allowed from ${DEFAULT_BRANCH}; current ref is ${GITHUB_REF_NAME}." >&2
+          exit 1
+
+      - name: Ensure release tag is new
+        env:
+          GH_TOKEN: ${{ github.token }}
+          RELEASE_TAG: ${{ needs.metadata.outputs.release_tag }}
+        shell: bash
+        run: |
+          set -euo pipefail
+
+          if gh release view "${RELEASE_TAG}" --repo "${GITHUB_REPOSITORY}" > /dev/null 2>&1; then
+            echo "Release tag ${RELEASE_TAG} already exists; musl artifact tags are immutable." >&2
+            exit 1
+          fi
+
+      - uses: actions/download-artifact@v8
+        with:
+          path: dist
+
+      - name: Create GitHub Release
+        uses: softprops/action-gh-release@v2
+        with:
+          tag_name: ${{ needs.metadata.outputs.release_tag }}
+          name: ${{ needs.metadata.outputs.release_tag }}
+          files: dist/**
+          # Keep V8 artifact releases out of Codex's normal "latest release" channel.
+          prerelease: true
@@ -0,0 +1,132 @@
+name: v8-canary
+
+on:
+  pull_request:
+    paths:
+      - ".github/scripts/rusty_v8_bazel.py"
+      - ".github/workflows/rusty-v8-release.yml"
+      - ".github/workflows/v8-canary.yml"
+      - "MODULE.bazel"
+      - "MODULE.bazel.lock"
+      - "codex-rs/Cargo.toml"
+      - "patches/BUILD.bazel"
+      - "patches/v8_*.patch"
+      - "third_party/v8/**"
+  push:
+    branches:
+      - main
+    paths:
+      - ".github/scripts/rusty_v8_bazel.py"
+      - ".github/workflows/rusty-v8-release.yml"
+      - ".github/workflows/v8-canary.yml"
+      - "MODULE.bazel"
+      - "MODULE.bazel.lock"
+      - "codex-rs/Cargo.toml"
+      - "patches/BUILD.bazel"
+      - "patches/v8_*.patch"
+      - "third_party/v8/**"
+  workflow_dispatch:
+
+concurrency:
+  group: ${{ github.workflow }}::${{ github.event.pull_request.number > 0 && format('pr-{0}', github.event.pull_request.number) || github.ref_name }}
+  cancel-in-progress: ${{ github.ref_name != 'main' }}
+
+jobs:
+  metadata:
+    runs-on: ubuntu-latest
+    outputs:
+      v8_version: ${{ steps.v8_version.outputs.version }}
+
+    steps:
+      - uses: actions/checkout@v6
+
+      - name: Set up Python
+        uses: actions/setup-python@v6
+        with:
+          python-version: "3.12"
+
+      - name: Resolve exact v8 crate version
+        id: v8_version
+        shell: bash
+        run: |
+          set -euo pipefail
+          version="$(python3 .github/scripts/rusty_v8_bazel.py resolved-v8-crate-version)"
+          echo "version=${version}" >> "$GITHUB_OUTPUT"
+
+  build:
+    name: Build ${{ matrix.target }}
+    needs: metadata
+    runs-on: ${{ matrix.runner }}
+    permissions:
+      contents: read
+      actions: read
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          - runner: ubuntu-24.04
+            platform: linux_amd64_musl
+            target: x86_64-unknown-linux-musl
+          - runner: ubuntu-24.04-arm
+            platform: linux_arm64_musl
+            target: aarch64-unknown-linux-musl
+
+    steps:
+      - uses: actions/checkout@v6
+
+      - name: Set up Bazel
+        uses: bazelbuild/setup-bazelisk@v3
+
+      - name: Set up Python
+        uses: actions/setup-python@v6
+        with:
+          python-version: "3.12"
+
+      - name: Build Bazel V8 release pair
+        env:
+          BUILDBUDDY_API_KEY: ${{ secrets.BUILDBUDDY_API_KEY }}
+          PLATFORM: ${{ matrix.platform }}
+          TARGET: ${{ matrix.target }}
+        shell: bash
+        run: |
+          set -euo pipefail
+
+          target_suffix="${TARGET//-/_}"
+          pair_target="//third_party/v8:rusty_v8_release_pair_${target_suffix}"
+          extra_targets=(
+            "@llvm//runtimes/libcxx:libcxx.static"
+            "@llvm//runtimes/libcxx:libcxxabi.static"
+          )
+
+          bazel_args=(
+            build
+            "--platforms=@llvm//platforms:${PLATFORM}"
+            "${pair_target}"
+            "${extra_targets[@]}"
+            --build_metadata=COMMIT_SHA=$(git rev-parse HEAD)
+          )
+
+          bazel \
+            --noexperimental_remote_repo_contents_cache \
+            --bazelrc=.github/workflows/v8-ci.bazelrc \
+            "${bazel_args[@]}" \
+            "--remote_header=x-buildbuddy-api-key=${BUILDBUDDY_API_KEY}"
+
+      - name: Stage release pair
+        env:
+          PLATFORM: ${{ matrix.platform }}
+          TARGET: ${{ matrix.target }}
+        shell: bash
+        run: |
+          set -euo pipefail
+
+          python3 .github/scripts/rusty_v8_bazel.py stage-release-pair \
+            --platform "${PLATFORM}" \
+            --target "${TARGET}" \
+            --output-dir "dist/${TARGET}"
+
+      - name: Upload staged musl artifacts
+        uses: actions/upload-artifact@v7
+        with:
+          name: v8-canary-${{ needs.metadata.outputs.v8_version }}-${{ matrix.target }}
+          path: dist/${{ matrix.target }}/*
@@ -0,0 +1,5 @@
+import %workspace%/.github/workflows/ci.bazelrc
+
+common --build_metadata=REPO_URL=https://github.com/openai/codex.git
+common --build_metadata=ROLE=CI
+common --build_metadata=VISIBILITY=PUBLIC
@@ -48,6 +48,8 @@ Run `just fmt` (in `codex-rs` directory) automatically after you have finished m

 Before finalizing a large change to `codex-rs`, run `just fix -p <project>` (in `codex-rs` directory) to fix any linter issues in the code. Prefer scoping with `-p` to avoid slow workspace‑wide Clippy builds; only run `just fix` without `-p` if you changed shared crates. Do not re-run tests after running `fix` or `fmt`.

+Also run `just argument-comment-lint` to ensure the codebase is clean of comment lint errors.
+
 ## TUI style conventions

 See `codex-rs/tui/styles.md`.
@@ -1,31 +1,42 @@
 module(name = "codex")

+bazel_dep(name = "bazel_skylib", version = "1.8.2")
 bazel_dep(name = "platforms", version = "1.0.0")
-bazel_dep(name = "llvm", version = "0.6.7")
+bazel_dep(name = "llvm", version = "0.6.8")

 register_toolchains("@llvm//toolchain:all")

 osx = use_extension("@llvm//extensions:osx.bzl", "osx")
-osx.framework(name = "ApplicationServices")
-osx.framework(name = "AppKit")
-osx.framework(name = "ColorSync")
-osx.framework(name = "CoreFoundation")
-osx.framework(name = "CoreGraphics")
-osx.framework(name = "CoreServices")
-osx.framework(name = "CoreText")
-osx.framework(name = "AudioToolbox")
-osx.framework(name = "CFNetwork")
-osx.framework(name = "FontServices")
-osx.framework(name = "AudioUnit")
-osx.framework(name = "CoreAudio")
-osx.framework(name = "CoreAudioTypes")
-osx.framework(name = "Foundation")
-osx.framework(name = "ImageIO")
-osx.framework(name = "IOKit")
-osx.framework(name = "Kernel")
-osx.framework(name = "OSLog")
-osx.framework(name = "Security")
-osx.framework(name = "SystemConfiguration")
+osx.from_archive(
+    sha256 = "6a4922f89487a96d7054ec6ca5065bfddd9f1d017c74d82f1d79cecf7feb8228",
+    strip_prefix = "Payload/Library/Developer/CommandLineTools/SDKs/MacOSX26.2.sdk",
+    type = "pkg",
+    urls = [
+        "https://swcdn.apple.com/content/downloads/26/44/047-81934-A_28TPKM5SD1/ps6pk6dk4x02vgfa5qsctq6tgf23t5f0w2/CLTools_macOSNMOS_SDK.pkg",
+    ],
+)
+osx.frameworks(names = [
+    "ApplicationServices",
+    "AppKit",
+    "ColorSync",
+    "CoreFoundation",
+    "CoreGraphics",
+    "CoreServices",
+    "CoreText",
+    "AudioToolbox",
+    "CFNetwork",
+    "FontServices",
+    "AudioUnit",
+    "CoreAudio",
+    "CoreAudioTypes",
+    "Foundation",
+    "ImageIO",
+    "IOKit",
+    "Kernel",
+    "OSLog",
+    "Security",
+    "SystemConfiguration",
+])
 use_repo(osx, "macos_sdk")

 # Needed to disable xcode...
@@ -132,6 +143,35 @@ crate.annotation(
    workspace_cargo_toml = "rust/runfiles/Cargo.toml",
 )

+http_archive = use_repo_rule("@bazel_tools//tools/build_defs/repo:http.bzl", "http_archive")
+http_file = use_repo_rule("@bazel_tools//tools/build_defs/repo:http.bzl", "http_file")
+new_local_repository = use_repo_rule("@bazel_tools//tools/build_defs/repo:local.bzl", "new_local_repository")
+
+new_local_repository(
+    name = "v8_targets",
+    build_file = "//third_party/v8:BUILD.bazel",
+    path = "third_party/v8",
+)
+
+crate.annotation(
+    build_script_data = [
+        "@v8_targets//:rusty_v8_archive_for_target",
+        "@v8_targets//:rusty_v8_binding_for_target",
+    ],
+    build_script_env = {
+        "RUSTY_V8_ARCHIVE": "$(execpath @v8_targets//:rusty_v8_archive_for_target)",
+        "RUSTY_V8_SRC_BINDING_PATH": "$(execpath @v8_targets//:rusty_v8_binding_for_target)",
+    },
+    crate = "v8",
+    gen_build_script = "on",
+    patch_args = ["-p1"],
+    patches = [
+        "//patches:rusty_v8_prebuilt_out_dir.patch",
+    ],
+)
+
+inject_repo(crate, "v8_targets")
+
 llvm = use_extension("@llvm//extensions:llvm.bzl", "llvm")
 use_repo(llvm, "llvm-project")

@@ -174,6 +214,109 @@ crate.annotation(

 inject_repo(crate, "alsa_lib")

+bazel_dep(name = "v8", version = "14.6.202.9")
+archive_override(
+    module_name = "v8",
+    integrity = "sha256-JphDwLAzsd9KvgRZ7eQvNtPU6qGd3XjFt/a/1QITAJU=",
+    patch_strip = 3,
+    patches = [
+        "//patches:v8_module_deps.patch",
+        "//patches:v8_bazel_rules.patch",
+        "//patches:v8_source_portability.patch",
+    ],
+    strip_prefix = "v8-14.6.202.9",
+    urls = ["https://github.com/v8/v8/archive/refs/tags/14.6.202.9.tar.gz"],
+)
+
+http_archive(
+    name = "v8_crate_146_4_0",
+    build_file = "//third_party/v8:v8_crate.BUILD.bazel",
+    sha256 = "d97bcac5cdc5a195a4813f1855a6bc658f240452aac36caa12fd6c6f16026ab1",
+    strip_prefix = "v8-146.4.0",
+    type = "tar.gz",
+    urls = ["https://static.crates.io/crates/v8/v8-146.4.0.crate"],
+)
+
+http_file(
+    name = "rusty_v8_146_4_0_aarch64_apple_darwin_archive",
+    downloaded_file_path = "librusty_v8_release_aarch64-apple-darwin.a.gz",
+    urls = [
+        "https://github.com/denoland/rusty_v8/releases/download/v146.4.0/librusty_v8_release_aarch64-apple-darwin.a.gz",
+    ],
+)
+
+http_file(
+    name = "rusty_v8_146_4_0_aarch64_unknown_linux_gnu_archive",
+    downloaded_file_path = "librusty_v8_release_aarch64-unknown-linux-gnu.a.gz",
+    urls = [
+        "https://github.com/denoland/rusty_v8/releases/download/v146.4.0/librusty_v8_release_aarch64-unknown-linux-gnu.a.gz",
+    ],
+)
+
+http_file(
+    name = "rusty_v8_146_4_0_aarch64_pc_windows_msvc_archive",
+    downloaded_file_path = "rusty_v8_release_aarch64-pc-windows-msvc.lib.gz",
+    urls = [
+        "https://github.com/denoland/rusty_v8/releases/download/v146.4.0/rusty_v8_release_aarch64-pc-windows-msvc.lib.gz",
+    ],
+)
+
+http_file(
+    name = "rusty_v8_146_4_0_x86_64_apple_darwin_archive",
+    downloaded_file_path = "librusty_v8_release_x86_64-apple-darwin.a.gz",
+    urls = [
+        "https://github.com/denoland/rusty_v8/releases/download/v146.4.0/librusty_v8_release_x86_64-apple-darwin.a.gz",
+    ],
+)
+
+http_file(
+    name = "rusty_v8_146_4_0_x86_64_unknown_linux_gnu_archive",
+    downloaded_file_path = "librusty_v8_release_x86_64-unknown-linux-gnu.a.gz",
+    urls = [
+        "https://github.com/denoland/rusty_v8/releases/download/v146.4.0/librusty_v8_release_x86_64-unknown-linux-gnu.a.gz",
+    ],
+)
+
+http_file(
+    name = "rusty_v8_146_4_0_x86_64_pc_windows_msvc_archive",
+    downloaded_file_path = "rusty_v8_release_x86_64-pc-windows-msvc.lib.gz",
+    urls = [
+        "https://github.com/denoland/rusty_v8/releases/download/v146.4.0/rusty_v8_release_x86_64-pc-windows-msvc.lib.gz",
+    ],
+)
+
+http_file(
+    name = "rusty_v8_146_4_0_aarch64_unknown_linux_musl_archive",
+    downloaded_file_path = "librusty_v8_release_aarch64-unknown-linux-musl.a.gz",
+    urls = [
+        "https://github.com/openai/codex/releases/download/rusty-v8-v146.4.0/librusty_v8_release_aarch64-unknown-linux-musl.a.gz",
+    ],
+)
+
+http_file(
+    name = "rusty_v8_146_4_0_aarch64_unknown_linux_musl_binding",
+    downloaded_file_path = "src_binding_release_aarch64-unknown-linux-musl.rs",
+    urls = [
+        "https://github.com/openai/codex/releases/download/rusty-v8-v146.4.0/src_binding_release_aarch64-unknown-linux-musl.rs",
+    ],
+)
+
+http_file(
+    name = "rusty_v8_146_4_0_x86_64_unknown_linux_musl_archive",
+    downloaded_file_path = "librusty_v8_release_x86_64-unknown-linux-musl.a.gz",
+    urls = [
+        "https://github.com/openai/codex/releases/download/rusty-v8-v146.4.0/librusty_v8_release_x86_64-unknown-linux-musl.a.gz",
+    ],
+)
+
+http_file(
+    name = "rusty_v8_146_4_0_x86_64_unknown_linux_musl_binding",
+    downloaded_file_path = "src_binding_release_x86_64-unknown-linux-musl.rs",
+    urls = [
+        "https://github.com/openai/codex/releases/download/rusty-v8-v146.4.0/src_binding_release_x86_64-unknown-linux-musl.rs",
+    ],
+)
+
 use_repo(crate, "crates")

 bazel_dep(name = "libcap", version = "2.27.bcr.1")
@@ -380,7 +380,7 @@ version = "1.1.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "40c48f72fd53cd289104fc64099abca73db4166ad86ea0b4341abe65af83dadc"
 dependencies = [
- "windows-sys 0.61.2",
+ "windows-sys 0.60.2",
 ]

 [[package]]
@@ -391,7 +391,7 @@ checksum = "291e6a250ff86cd4a820112fb8898808a366d8f9f58ce16d1f538353ad55747d"
 dependencies = [
 "anstyle",
 "once_cell_polyfill",
- "windows-sys 0.61.2",
+ "windows-sys 0.60.2",
 ]

 [[package]]
@@ -409,6 +409,7 @@ dependencies = [
 "chrono",
 "codex-app-server-protocol",
 "codex-core",
+ "codex-features",
 "codex-protocol",
 "codex-utils-cargo-bin",
 "core_test_support",
@@ -799,9 +800,9 @@ checksum = "c08606f8c3cbf4ce6ec8e28fb0014a2c086708fe954eaa885384a6165172e7e8"

 [[package]]
 name = "aws-lc-rs"
-version = "1.15.4"
+version = "1.16.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7b7b6141e96a8c160799cc2d5adecd5cbbe5054cb8c7c4af53da0f83bb7ad256"
+checksum = "a054912289d18629dc78375ba2c3726a3afe3ff71b4edba9dedfca0e3446d1fc"
 dependencies = [
 "aws-lc-sys",
 "untrusted 0.7.1",
@@ -810,9 +811,9 @@ dependencies = [

 [[package]]
 name = "aws-lc-sys"
-version = "0.37.0"
+version = "0.39.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5c34dda4df7017c8db52132f0f8a2e0f8161649d15723ed63fc00c82d0f2081a"
+checksum = "1fa7e52a4c5c547c741610a2c6f123f3881e409b714cd27e6798ef020c514f0a"
 dependencies = [
 "cc",
 "cmake",
@@ -948,6 +949,8 @@ dependencies = [
 "cexpr",
 "clang-sys",
 "itertools 0.13.0",
+ "log",
+ "prettyplease",
 "proc-macro2",
 "quote",
 "regex",
@@ -1151,6 +1154,16 @@ version = "0.1.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "ade8366b8bd5ba243f0a58f036cc0ca8a2f069cff1a2351ef1cac6b083e16fc0"

+[[package]]
+name = "calendrical_calculations"
+version = "0.2.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3a0b39595c6ee54a8d0900204ba4c401d0ab4eb45adaf07178e8d017541529e7"
+dependencies = [
+ "core_maths",
+ "displaydoc",
+]
+
 [[package]]
 name = "cassowary"
 version = "0.3.0"
@@ -1428,6 +1441,7 @@ dependencies = [
 "codex-cloud-requirements",
 "codex-core",
 "codex-exec-server",
+ "codex-features",
 "codex-feedback",
 "codex-file-search",
 "codex-login",
@@ -1474,6 +1488,7 @@ dependencies = [
 "codex-app-server-protocol",
 "codex-arg0",
 "codex-core",
+ "codex-features",
 "codex-feedback",
 "codex-protocol",
 "futures",
@@ -1581,7 +1596,7 @@ dependencies = [
 "thiserror 2.0.18",
 "tokio",
 "url",
- "which",
+ "which 8.0.0",
 "wiremock",
 "zip",
 ]
@@ -1657,6 +1672,7 @@ dependencies = [
 "codex-core",
 "codex-exec",
 "codex-execpolicy",
+ "codex-features",
 "codex-login",
 "codex-mcp-server",
 "codex-protocol",
@@ -1784,6 +1800,20 @@ dependencies = [
 "thiserror 2.0.18",
 ]

+[[package]]
+name = "codex-code-mode"
+version = "0.0.0"
+dependencies = [
+ "async-trait",
+ "pretty_assertions",
+ "serde",
+ "serde_json",
+ "tokio",
+ "tokio-util",
+ "tracing",
+ "v8",
+]
+
 [[package]]
 name = "codex-config"
 version = "0.0.0"
@@ -1841,15 +1871,16 @@ dependencies = [
 "codex-arg0",
 "codex-artifacts",
 "codex-async-utils",
- "codex-client",
+ "codex-code-mode",
 "codex-config",
 "codex-connectors",
 "codex-exec-server",
 "codex-execpolicy",
+ "codex-features",
 "codex-file-search",
 "codex-git",
 "codex-hooks",
- "codex-keyring-store",
+ "codex-login",
 "codex-network-proxy",
 "codex-otel",
 "codex-protocol",
@@ -1886,7 +1917,6 @@ dependencies = [
 "image",
 "indexmap 2.13.0",
 "insta",
- "keyring",
 "landlock",
 "libc",
 "maplit",
@@ -1895,7 +1925,6 @@ dependencies = [
 "openssl-sys",
 "opentelemetry",
 "opentelemetry_sdk",
- "os_info",
 "predicates",
 "pretty_assertions",
 "rand 0.9.2",
@@ -1909,7 +1938,6 @@ dependencies = [
 "serde_yaml",
 "serial_test",
 "sha1",
- "sha2",
 "shlex",
 "similar",
 "tempfile",
@@ -1929,7 +1957,7 @@ dependencies = [
 "url",
 "uuid",
 "walkdir",
- "which",
+ "which 8.0.0",
 "wildmatch",
 "windows-sys 0.52.0",
 "wiremock",
@@ -2011,6 +2039,7 @@ dependencies = [
 "serde",
 "serde_json",
 "tempfile",
+ "test-case",
 "thiserror 2.0.18",
 "tokio",
 "tokio-tungstenite",
@@ -2063,6 +2092,20 @@ dependencies = [
 "syn 2.0.114",
 ]

+[[package]]
+name = "codex-features"
+version = "0.0.0"
+dependencies = [
+ "codex-login",
+ "codex-otel",
+ "codex-protocol",
+ "pretty_assertions",
+ "schemars 0.8.22",
+ "serde",
+ "toml 0.9.11+spec-1.1.0",
+ "tracing",
+]
+
 [[package]]
 name = "codex-feedback"
 version = "0.0.0"
@@ -2163,7 +2206,7 @@ dependencies = [
 "serde_json",
 "tokio",
 "tracing",
- "which",
+ "which 8.0.0",
 "wiremock",
 ]

@@ -2172,19 +2215,30 @@ name = "codex-login"
 version = "0.0.0"
 dependencies = [
 "anyhow",
+ "async-trait",
 "base64 0.22.1",
 "chrono",
 "codex-app-server-protocol",
 "codex-client",
- "codex-core",
+ "codex-config",
+ "codex-keyring-store",
+ "codex-protocol",
+ "codex-terminal-detection",
 "core_test_support",
+ "keyring",
+ "once_cell",
+ "os_info",
 "pretty_assertions",
 "rand 0.9.2",
+ "regex-lite",
 "reqwest",
+ "schemars 0.8.22",
 "serde",
 "serde_json",
+ "serial_test",
 "sha2",
 "tempfile",
+ "thiserror 2.0.18",
 "tiny_http",
 "tokio",
 "tracing",
@@ -2201,6 +2255,7 @@ dependencies = [
 "anyhow",
 "codex-arg0",
 "codex-core",
+ "codex-features",
 "codex-protocol",
 "codex-shell-command",
 "codex-utils-cli",
@@ -2276,6 +2331,7 @@ version = "0.0.0"
 dependencies = [
 "chrono",
 "codex-api",
+ "codex-app-server-protocol",
 "codex-protocol",
 "codex-utils-absolute-path",
 "codex-utils-string",
@@ -2403,7 +2459,7 @@ dependencies = [
 "tracing",
 "urlencoding",
 "webbrowser",
- "which",
+ "which 8.0.0",
 ]

 [[package]]
@@ -2443,7 +2499,7 @@ dependencies = [
 "tree-sitter",
 "tree-sitter-bash",
 "url",
- "which",
+ "which 8.0.0",
 ]

 [[package]]
@@ -2537,6 +2593,7 @@ dependencies = [
 "chrono",
 "clap",
 "codex-ansi-escape",
+ "codex-app-server-client",
 "codex-app-server-protocol",
 "codex-arg0",
 "codex-backend-client",
@@ -2545,6 +2602,7 @@ dependencies = [
 "codex-client",
 "codex-cloud-requirements",
 "codex-core",
+ "codex-features",
 "codex-feedback",
 "codex-file-search",
 "codex-login",
@@ -2613,7 +2671,7 @@ dependencies = [
 "uuid",
 "vt100",
 "webbrowser",
- "which",
+ "which 8.0.0",
 "windows-sys 0.52.0",
 "winsplit",
 ]
@@ -2637,6 +2695,7 @@ dependencies = [
 "codex-client",
 "codex-cloud-requirements",
 "codex-core",
+ "codex-features",
 "codex-feedback",
 "codex-file-search",
 "codex-login",
@@ -2704,7 +2763,7 @@ dependencies = [
 "uuid",
 "vt100",
 "webbrowser",
- "which",
+ "which 8.0.0",
 "windows-sys 0.52.0",
 "winsplit",
 ]
@@ -2875,6 +2934,14 @@ dependencies = [
 "regex-lite",
 ]

+[[package]]
+name = "codex-v8-poc"
+version = "0.0.0"
+dependencies = [
+ "pretty_assertions",
+ "v8",
+]
+
 [[package]]
 name = "codex-windows-sandbox"
 version = "0.0.0"
@@ -3080,6 +3147,15 @@ version = "0.8.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "773648b94d0e5d620f64f280777445740e61fe701025087ec8b57f45c791888b"

+[[package]]
+name = "core_maths"
+version = "0.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "77745e017f5edba1a9c1d854f6f3a52dac8a12dd5af5d2f54aecf61e43d80d30"
+dependencies = [
+ "libm",
+]
+
 [[package]]
 name = "core_test_support"
 version = "0.0.0"
@@ -3087,7 +3163,10 @@ dependencies = [
 "anyhow",
 "assert_cmd",
 "base64 0.22.1",
+ "codex-arg0",
 "codex-core",
+ "codex-exec-server",
+ "codex-features",
 "codex-protocol",
 "codex-utils-absolute-path",
 "codex-utils-cargo-bin",
@@ -3682,6 +3761,38 @@ dependencies = [
 "subtle",
 ]

+[[package]]
+name = "diplomat"
+version = "0.14.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9adb46b05e2f53dcf6a7dfc242e4ce9eb60c369b6b6eb10826a01e93167f59c6"
+dependencies = [
+ "diplomat_core",
+ "proc-macro2",
+ "quote",
+ "syn 2.0.114",
+]
+
+[[package]]
+name = "diplomat-runtime"
+version = "0.14.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0569bd3caaf13829da7ee4e83dbf9197a0e1ecd72772da6d08f0b4c9285c8d29"
+
+[[package]]
+name = "diplomat_core"
+version = "0.14.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "51731530ed7f2d4495019abc7df3744f53338e69e2863a6a64ae91821c763df1"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "serde",
+ "smallvec",
+ "strck",
+ "syn 2.0.114",
+]
+
 [[package]]
 name = "dirs"
 version = "6.0.0"
@@ -3710,7 +3821,7 @@ dependencies = [
 "libc",
 "option-ext",
 "redox_users 0.5.2",
- "windows-sys 0.61.2",
+ "windows-sys 0.59.0",
 ]

 [[package]]
@@ -3955,7 +4066,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "39cab71617ae0d63f51a36d69f866391735b51691dbda63cf6f96d042b63efeb"
 dependencies = [
 "libc",
- "windows-sys 0.61.2",
+ "windows-sys 0.52.0",
 ]

 [[package]]
@@ -4288,6 +4399,16 @@ dependencies = [
 "libc",
 ]

+[[package]]
+name = "fslock"
+version = "0.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "04412b8935272e3a9bae6f48c7bfff74c2911f60525404edfdd28e49884c3bfb"
+dependencies = [
+ "libc",
+ "winapi",
+]
+
 [[package]]
 name = "futures"
 version = "0.3.31"
@@ -4516,6 +4637,15 @@ dependencies = [
 "regex-syntax 0.8.8",
 ]

+[[package]]
+name = "gzip-header"
+version = "1.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "95cc527b92e6029a62960ad99aa8a6660faa4555fe5f731aab13aa6a921795a2"
+dependencies = [
+ "crc32fast",
+]
+
 [[package]]
 name = "h2"
 version = "0.4.13"
@@ -4973,6 +5103,28 @@ dependencies = [
 "cc",
 ]

+[[package]]
+name = "icu_calendar"
+version = "2.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d6f0e52e009b6b16ba9c0693578796f2dd4aaa59a7f8f920423706714a89ac4e"
+dependencies = [
+ "calendrical_calculations",
+ "displaydoc",
+ "icu_calendar_data",
+ "icu_locale",
+ "icu_locale_core",
+ "icu_provider",
+ "tinystr",
+ "zerovec",
+]
+
+[[package]]
+name = "icu_calendar_data"
+version = "2.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "527f04223b17edfe0bd43baf14a0cb1b017830db65f3950dc00224860a9a446d"
+
 [[package]]
 name = "icu_collections"
 version = "2.1.1"
@@ -5359,7 +5511,7 @@ checksum = "3640c1c38b8e4e43584d8df18be5fc6b0aa314ce6ebf51b53313d4306cca8e46"
 dependencies = [
 "hermit-abi",
 "libc",
- "windows-sys 0.61.2",
+ "windows-sys 0.52.0",
 ]

 [[package]]
@@ -5407,6 +5559,12 @@ version = "1.0.17"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "92ecc6618181def0457392ccd0ee51198e065e016d1d527a7ac1b6dc7c1f09d2"

+[[package]]
+name = "ixdtf"
+version = "0.6.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "84de9d95a6d2547d9b77ee3f25fa0ee32e3c3a6484d47a55adebc0439c077992"
+
 [[package]]
 name = "jiff"
 version = "0.2.18"
@@ -6116,7 +6274,7 @@ version = "0.50.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "7957b9740744892f114936ab4a57b3f487491bbeafaf8083688b16841a4240e5"
 dependencies = [
- "windows-sys 0.61.2",
+ "windows-sys 0.59.0",
 ]

 [[package]]
@@ -6760,7 +6918,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "7d8fae84b431384b68627d0f9b3b1245fcf9f46f6c0e3dc902e9dce64edd1967"
 dependencies = [
 "libc",
- "windows-sys 0.61.2",
+ "windows-sys 0.45.0",
 ]

 [[package]]
@@ -7132,6 +7290,16 @@ dependencies = [
 "yansi",
 ]

+[[package]]
+name = "prettyplease"
+version = "0.2.37"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "479ca8adacdd7ce8f1fb39ce9ecccbfe93a3f1344b3d0d97f20bc0196208f62b"
+dependencies = [
+ "proc-macro2",
+ "syn 2.0.114",
+]
+
 [[package]]
 name = "proc-macro-crate"
 version = "3.4.0"
@@ -7965,6 +8133,16 @@ dependencies = [
 "webpki-roots 1.0.5",
 ]

+[[package]]
+name = "resb"
+version = "0.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6a067ab3b5ca3b4dc307d0de9cf75f9f5e6ca9717b192b2f28a36c83e5de9e76"
+dependencies = [
+ "potential_utf",
+ "serde_core",
+]
+
 [[package]]
 name = "resolv-conf"
 version = "0.7.6"
@@ -8162,7 +8340,7 @@ dependencies = [
 "errno",
 "libc",
 "linux-raw-sys 0.11.0",
- "windows-sys 0.61.2",
+ "windows-sys 0.52.0",
 ]

 [[package]]
@@ -8205,9 +8383,9 @@ dependencies = [

 [[package]]
 name = "rustls-webpki"
-version = "0.103.9"
+version = "0.103.10"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d7df23109aa6c1567d1c575b9952556388da57401e4ace1d15f79eedad0d8f53"
+checksum = "df33b2b81ac578cabaf06b89b0631153a3f416b0a886e8a7a1707fb51abbd1ef"
 dependencies = [
 "aws-lc-rs",
 "ring",
@@ -9345,6 +9523,15 @@ dependencies = [
 "serde_json",
 ]

+[[package]]
+name = "strck"
+version = "1.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "42316e70da376f3d113a68d138a60d8a9883c604fe97942721ec2068dab13a9f"
+dependencies = [
+ "unicode-ident",
+]
+
 [[package]]
 name = "streaming-iterator"
 version = "0.1.9"
@@ -9567,9 +9754,9 @@ checksum = "7b2093cf4c8eb1e67749a6762251bc9cd836b6fc171623bd0a9d324d37af2417"

 [[package]]
 name = "tar"
-version = "0.4.44"
+version = "0.4.45"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1d863878d212c87a19c1a610eb53bb01fe12951c0501cf5a0d65f724914a667a"
+checksum = "22692a6476a21fa75fdfc11d452fda482af402c008cdbaf3476414e122040973"
 dependencies = [
 "filetime",
 "libc",
@@ -9586,7 +9773,40 @@ dependencies = [
 "getrandom 0.3.4",
 "once_cell",
 "rustix 1.1.3",
- "windows-sys 0.61.2",
+ "windows-sys 0.52.0",
+]
+
+[[package]]
+name = "temporal_capi"
+version = "0.1.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a151e402c2bdb6a3a2a2f3f225eddaead2e7ce7dd5d3fa2090deb11b17aa4ed8"
+dependencies = [
+ "diplomat",
+ "diplomat-runtime",
+ "icu_calendar",
+ "icu_locale",
+ "num-traits",
+ "temporal_rs",
+ "timezone_provider",
+ "writeable",
+ "zoneinfo64",
+]
+
+[[package]]
+name = "temporal_rs"
+version = "0.1.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "88afde3bd75d2fc68d77a914bece426aa08aa7649ffd0cdd4a11c3d4d33474d1"
+dependencies = [
+ "core_maths",
+ "icu_calendar",
+ "icu_locale",
+ "ixdtf",
+ "num-traits",
+ "timezone_provider",
+ "tinystr",
+ "writeable",
 ]

 [[package]]
@@ -9796,6 +10016,18 @@ dependencies = [
 "time-core",
 ]

+[[package]]
+name = "timezone_provider"
+version = "0.1.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "df9ba0000e9e73862f3e7ca1ff159e2ddf915c9d8bb11e38a7874760f445d993"
+dependencies = [
+ "tinystr",
+ "zerotrie",
+ "zerovec",
+ "zoneinfo64",
+]
+
 [[package]]
 name = "tiny-keccak"
 version = "2.0.2"
@@ -10595,6 +10827,23 @@ dependencies = [
 "wasm-bindgen",
 ]

+[[package]]
+name = "v8"
+version = "146.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d97bcac5cdc5a195a4813f1855a6bc658f240452aac36caa12fd6c6f16026ab1"
+dependencies = [
+ "bindgen",
+ "bitflags 2.10.0",
+ "fslock",
+ "gzip-header",
+ "home",
+ "miniz_oxide",
+ "paste",
+ "temporal_capi",
+ "which 6.0.3",
+]
+
 [[package]]
 name = "valuable"
 version = "0.1.1"
@@ -10894,6 +11143,18 @@ version = "0.1.12"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "a28ac98ddc8b9274cb41bb4d9d4d5c425b6020c50c46f25559911905610b4a88"

+[[package]]
+name = "which"
+version = "6.0.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b4ee928febd44d98f2f459a4a79bd4d928591333a494a10a868418ac1b39cf1f"
+dependencies = [
+ "either",
+ "home",
+ "rustix 0.38.44",
+ "winsafe",
+]
+
 [[package]]
 name = "which"
 version = "8.0.0"
@@ -10958,7 +11219,7 @@ version = "0.1.11"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "c2a7b1c03c876122aa43f3020e6c3c3ee5c05081c9a00739faf7503aeba10d22"
 dependencies = [
- "windows-sys 0.61.2",
+ "windows-sys 0.48.0",
 ]

 [[package]]
@@ -11897,6 +12158,19 @@ version = "1.0.19"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "3ff05f8caa9038894637571ae6b9e29466c1f4f829d26c9b28f869a29cbe3445"

+[[package]]
+name = "zoneinfo64"
+version = "0.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bb2e5597efbe7c421da8a7fd396b20b571704e787c21a272eecf35dfe9d386f0"
+dependencies = [
+ "calendrical_calculations",
+ "icu_locale_core",
+ "potential_utf",
+ "resb",
+ "serde",
+]
+
 [[package]]
 name = "zopfli"
 version = "0.8.3"
@@ -11,7 +11,9 @@ members = [
    "apply-patch",
    "arg0",
    "feedback",
+    "features",
    "codex-backend-openapi-models",
+    "code-mode",
    "cloud-requirements",
    "cloud-tasks",
    "cloud-tasks-client",
@@ -44,6 +46,7 @@ members = [
    "otel",
    "tui",
    "tui_app_server",
+    "v8-poc",
    "utils/absolute-path",
    "utils/cargo-bin",
    "utils/git",
@@ -89,6 +92,7 @@ app_test_support = { path = "app-server/tests/common" }
 codex-ansi-escape = { path = "ansi-escape" }
 codex-api = { path = "codex-api" }
 codex-artifacts = { path = "artifacts" }
+codex-code-mode = { path = "code-mode" }
 codex-package-manager = { path = "package-manager" }
 codex-app-server = { path = "app-server" }
 codex-app-server-client = { path = "app-server-client" }
@@ -110,6 +114,7 @@ codex-exec-server = { path = "exec-server" }
 codex-execpolicy = { path = "execpolicy" }
 codex-experimental-api-macros = { path = "codex-experimental-api-macros" }
 codex-feedback = { path = "feedback" }
+codex-features = { path = "features" }
 codex-file-search = { path = "file-search" }
 codex-git = { path = "utils/git" }
 codex-hooks = { path = "hooks" }
@@ -135,6 +140,7 @@ codex-test-macros = { path = "test-macros" }
 codex-terminal-detection = { path = "terminal-detection" }
 codex-tui = { path = "tui" }
 codex-tui-app-server = { path = "tui_app_server" }
+codex-v8-poc = { path = "v8-poc" }
 codex-utils-absolute-path = { path = "utils/absolute-path" }
 codex-utils-approval-presets = { path = "utils/approval-presets" }
 codex-utils-cache = { path = "utils/cache" }
@@ -243,6 +249,7 @@ regex-lite = "0.1.8"
 reqwest = "0.12"
 rmcp = { version = "0.15.0", default-features = false }
 runfiles = { git = "https://github.com/dzbarsky/rules_rust", rev = "b56cbaa8465e74127f1ea216f813cd377295ad81" }
+v8 = "=146.4.0"
 rustls = { version = "0.23", default-features = false, features = [
    "ring",
    "std",
@@ -368,7 +375,8 @@ ignored = [
    "icu_provider",
    "openssl-sys",
    "codex-utils-readiness",
-    "codex-secrets"
+    "codex-secrets",
+    "codex-v8-poc",
 ]

 [profile.release]
@@ -16,6 +16,7 @@ codex-app-server = { workspace = true }
 codex-app-server-protocol = { workspace = true }
 codex-arg0 = { workspace = true }
 codex-core = { workspace = true }
+codex-features = { workspace = true }
 codex-feedback = { workspace = true }
 codex-protocol = { workspace = true }
 futures = { workspace = true }
@@ -47,6 +47,7 @@ use codex_core::config::Config;
 use codex_core::config_loader::CloudRequirementsLoader;
 use codex_core::config_loader::LoaderOverrides;
 use codex_core::models_manager::collaboration_mode_presets::CollaborationModesConfig;
+use codex_features::Feature;
 use codex_feedback::CodexFeedback;
 use codex_protocol::protocol::SessionSource;
 use serde::de::DeserializeOwned;
@@ -215,7 +216,7 @@ impl InProcessClientStartArgs {
                default_mode_request_user_input: self
                    .config
                    .features
-                    .enabled(codex_core::features::Feature::DefaultModeRequestUserInput),
+                    .enabled(Feature::DefaultModeRequestUserInput),
            },
        ));

@@ -1484,7 +1485,7 @@ mod tests {
            CollaborationModesConfig {
                default_mode_request_user_input: config
                    .features
-                    .enabled(codex_core::features::Feature::DefaultModeRequestUserInput),
+                    .enabled(Feature::DefaultModeRequestUserInput),
            },
        ));
        event_tx
@@ -2343,13 +2343,27 @@
        "enabled": {
          "type": "boolean"
        },
+        "name": {
+          "description": "Name-based selector.",
+          "type": [
+            "string",
+            "null"
+          ]
+        },
        "path": {
-          "type": "string"
+          "anyOf": [
+            {
+              "$ref": "#/definitions/AbsolutePathBuf"
+            },
+            {
+              "type": "null"
+            }
+          ],
+          "description": "Path-based selector."
        }
      },
      "required": [
-        "enabled",
-        "path"
+        "enabled"
      ],
      "type": "object"
    },
@@ -83,6 +83,9 @@
      ],
      "type": "object"
    },
+    "AgentPath": {
+      "type": "string"
+    },
    "AppBranding": {
      "description": "EXPERIMENTAL - app metadata returned by app-list APIs.",
      "properties": {
@@ -511,6 +514,28 @@
          ],
          "title": "ResponseTooManyFailedAttemptsCodexErrorInfo",
          "type": "object"
+        },
+        {
+          "additionalProperties": false,
+          "description": "Returned when `turn/start` or `turn/steer` is submitted while the current active turn cannot accept same-turn steering, for example `/review` or manual `/compact`.",
+          "properties": {
+            "activeTurnNotSteerable": {
+              "properties": {
+                "turnKind": {
+                  "$ref": "#/definitions/NonSteerableTurnKind"
+                }
+              },
+              "required": [
+                "turnKind"
+              ],
+              "type": "object"
+            }
+          },
+          "required": [
+            "activeTurnNotSteerable"
+          ],
+          "title": "ActiveTurnNotSteerableCodexErrorInfo",
+          "type": "object"
        }
      ]
    },
@@ -1155,6 +1180,7 @@
    },
    "HookEventName": {
      "enum": [
+        "preToolUse",
        "sessionStart",
        "userPromptSubmit",
        "stop"
@@ -1620,6 +1646,13 @@
      ],
      "type": "object"
    },
+    "NonSteerableTurnKind": {
+      "enum": [
+        "review",
+        "compact"
+      ],
+      "type": "string"
+    },
    "PatchApplyStatus": {
      "enum": [
        "inProgress",
@@ -1999,6 +2032,17 @@
                    "null"
                  ]
                },
+                "agent_path": {
+                  "anyOf": [
+                    {
+                      "$ref": "#/definitions/AgentPath"
+                    },
+                    {
+                      "type": "null"
+                    }
+                  ],
+                  "default": null
+                },
                "agent_role": {
                  "default": null,
                  "type": [
@@ -2817,6 +2861,12 @@
                "null"
              ]
            },
+            "savedPath": {
+              "type": [
+                "string",
+                "null"
+              ]
+            },
            "status": {
              "type": "string"
            },
@@ -3048,6 +3098,26 @@
      ],
      "type": "object"
    },
+    "ThreadRealtimeTranscriptUpdatedNotification": {
+      "description": "EXPERIMENTAL - flat transcript delta emitted whenever realtime transcript text changes.",
+      "properties": {
+        "role": {
+          "type": "string"
+        },
+        "text": {
+          "type": "string"
+        },
+        "threadId": {
+          "type": "string"
+        }
+      },
+      "required": [
+        "role",
+        "text",
+        "threadId"
+      ],
+      "type": "object"
+    },
    "ThreadStartedNotification": {
      "properties": {
        "thread": {
@@ -4545,6 +4615,26 @@
      "title": "Thread/realtime/itemAddedNotification",
      "type": "object"
    },
+    {
+      "properties": {
+        "method": {
+          "enum": [
+            "thread/realtime/transcriptUpdated"
+          ],
+          "title": "Thread/realtime/transcriptUpdatedNotificationMethod",
+          "type": "string"
+        },
+        "params": {
+          "$ref": "#/definitions/ThreadRealtimeTranscriptUpdatedNotification"
+        }
+      },
+      "required": [
+        "method",
+        "params"
+      ],
+      "title": "Thread/realtime/transcriptUpdatedNotification",
+      "type": "object"
+    },
    {
      "properties": {
        "method": {
@@ -4274,6 +4274,26 @@
          "title": "Thread/realtime/itemAddedNotification",
          "type": "object"
        },
+        {
+          "properties": {
+            "method": {
+              "enum": [
+                "thread/realtime/transcriptUpdated"
+              ],
+              "title": "Thread/realtime/transcriptUpdatedNotificationMethod",
+              "type": "string"
+            },
+            "params": {
+              "$ref": "#/definitions/v2/ThreadRealtimeTranscriptUpdatedNotification"
+            }
+          },
+          "required": [
+            "method",
+            "params"
+          ],
+          "title": "Thread/realtime/transcriptUpdatedNotification",
+          "type": "object"
+        },
        {
          "properties": {
            "method": {
@@ -4899,6 +4919,9 @@
        "title": "AgentMessageDeltaNotification",
        "type": "object"
      },
+      "AgentPath": {
+        "type": "string"
+      },
      "AnalyticsConfig": {
        "additionalProperties": true,
        "properties": {
@@ -5635,6 +5658,28 @@
            ],
            "title": "ResponseTooManyFailedAttemptsCodexErrorInfo",
            "type": "object"
+          },
+          {
+            "additionalProperties": false,
+            "description": "Returned when `turn/start` or `turn/steer` is submitted while the current active turn cannot accept same-turn steering, for example `/review` or manual `/compact`.",
+            "properties": {
+              "activeTurnNotSteerable": {
+                "properties": {
+                  "turnKind": {
+                    "$ref": "#/definitions/v2/NonSteerableTurnKind"
+                  }
+                },
+                "required": [
+                  "turnKind"
+                ],
+                "type": "object"
+              }
+            },
+            "required": [
+              "activeTurnNotSteerable"
+            ],
+            "title": "ActiveTurnNotSteerableCodexErrorInfo",
+            "type": "object"
          }
        ]
      },
@@ -7949,6 +7994,7 @@
      },
      "HookEventName": {
        "enum": [
+          "preToolUse",
          "sessionStart",
          "userPromptSubmit",
          "stop"
@@ -9092,6 +9138,13 @@
        },
        "type": "object"
      },
+      "NonSteerableTurnKind": {
+        "enum": [
+          "review",
+          "compact"
+        ],
+        "type": "string"
+      },
      "OverriddenMetadata": {
        "properties": {
          "effectiveValue": true,
@@ -11300,6 +11353,9 @@
          "description": {
            "type": "string"
          },
+          "enabled": {
+            "type": "boolean"
+          },
          "interface": {
            "anyOf": [
              {
@@ -11325,6 +11381,7 @@
        },
        "required": [
          "description",
+          "enabled",
          "name",
          "path"
        ],
@@ -11381,13 +11438,27 @@
          "enabled": {
            "type": "boolean"
          },
+          "name": {
+            "description": "Name-based selector.",
+            "type": [
+              "string",
+              "null"
+            ]
+          },
          "path": {
-            "type": "string"
+            "anyOf": [
+              {
+                "$ref": "#/definitions/v2/AbsolutePathBuf"
+              },
+              {
+                "type": "null"
+              }
+            ],
+            "description": "Path-based selector."
          }
        },
        "required": [
-          "enabled",
-          "path"
+          "enabled"
        ],
        "title": "SkillsConfigWriteParams",
        "type": "object"
@@ -11515,6 +11586,17 @@
                      "null"
                    ]
                  },
+                  "agent_path": {
+                    "anyOf": [
+                      {
+                        "$ref": "#/definitions/v2/AgentPath"
+                      },
+                      {
+                        "type": "null"
+                      }
+                    ],
+                    "default": null
+                  },
                  "agent_role": {
                    "default": null,
                    "type": [
@@ -12540,6 +12622,12 @@
                  "null"
                ]
              },
+              "savedPath": {
+                "type": [
+                  "string",
+                  "null"
+                ]
+              },
              "status": {
                "type": "string"
              },
@@ -13022,6 +13110,28 @@
        "title": "ThreadRealtimeStartedNotification",
        "type": "object"
      },
+      "ThreadRealtimeTranscriptUpdatedNotification": {
+        "$schema": "http://json-schema.org/draft-07/schema#",
+        "description": "EXPERIMENTAL - flat transcript delta emitted whenever realtime transcript text changes.",
+        "properties": {
+          "role": {
+            "type": "string"
+          },
+          "text": {
+            "type": "string"
+          },
+          "threadId": {
+            "type": "string"
+          }
+        },
+        "required": [
+          "role",
+          "text",
+          "threadId"
+        ],
+        "title": "ThreadRealtimeTranscriptUpdatedNotification",
+        "type": "object"
+      },
      "ThreadResumeParams": {
        "$schema": "http://json-schema.org/draft-07/schema#",
        "description": "There are three ways to resume a thread: 1. By thread_id: load the thread from disk by thread_id and resume it. 2. By history: instantiate the thread from memory and resume it. 3. By path: load the thread from disk by path and resume it.\n\nThe precedence is: history > path > thread_id. If using history or path, the thread_id param will be ignored.\n\nPrefer using thread_id whenever possible.",
@@ -139,6 +139,9 @@
      "title": "AgentMessageDeltaNotification",
      "type": "object"
    },
+    "AgentPath": {
+      "type": "string"
+    },
    "AnalyticsConfig": {
      "additionalProperties": true,
      "properties": {
@@ -2248,6 +2251,28 @@
          ],
          "title": "ResponseTooManyFailedAttemptsCodexErrorInfo",
          "type": "object"
+        },
+        {
+          "additionalProperties": false,
+          "description": "Returned when `turn/start` or `turn/steer` is submitted while the current active turn cannot accept same-turn steering, for example `/review` or manual `/compact`.",
+          "properties": {
+            "activeTurnNotSteerable": {
+              "properties": {
+                "turnKind": {
+                  "$ref": "#/definitions/NonSteerableTurnKind"
+                }
+              },
+              "required": [
+                "turnKind"
+              ],
+              "type": "object"
+            }
+          },
+          "required": [
+            "activeTurnNotSteerable"
+          ],
+          "title": "ActiveTurnNotSteerableCodexErrorInfo",
+          "type": "object"
        }
      ]
    },
@@ -4673,6 +4698,7 @@
    },
    "HookEventName": {
      "enum": [
+        "preToolUse",
        "sessionStart",
        "userPromptSubmit",
        "stop"
@@ -5860,6 +5886,13 @@
      },
      "type": "object"
    },
+    "NonSteerableTurnKind": {
+      "enum": [
+        "review",
+        "compact"
+      ],
+      "type": "string"
+    },
    "OverriddenMetadata": {
      "properties": {
        "effectiveValue": true,
@@ -8706,6 +8739,26 @@
          "title": "Thread/realtime/itemAddedNotification",
          "type": "object"
        },
+        {
+          "properties": {
+            "method": {
+              "enum": [
+                "thread/realtime/transcriptUpdated"
+              ],
+              "title": "Thread/realtime/transcriptUpdatedNotificationMethod",
+              "type": "string"
+            },
+            "params": {
+              "$ref": "#/definitions/ThreadRealtimeTranscriptUpdatedNotification"
+            }
+          },
+          "required": [
+            "method",
+            "params"
+          ],
+          "title": "Thread/realtime/transcriptUpdatedNotification",
+          "type": "object"
+        },
        {
          "properties": {
            "method": {
@@ -9060,6 +9113,9 @@
        "description": {
          "type": "string"
        },
+        "enabled": {
+          "type": "boolean"
+        },
        "interface": {
          "anyOf": [
            {
@@ -9085,6 +9141,7 @@
      },
      "required": [
        "description",
+        "enabled",
        "name",
        "path"
      ],
@@ -9141,13 +9198,27 @@
        "enabled": {
          "type": "boolean"
        },
+        "name": {
+          "description": "Name-based selector.",
+          "type": [
+            "string",
+            "null"
+          ]
+        },
        "path": {
-          "type": "string"
+          "anyOf": [
+            {
+              "$ref": "#/definitions/AbsolutePathBuf"
+            },
+            {
+              "type": "null"
+            }
+          ],
+          "description": "Path-based selector."
        }
      },
      "required": [
-        "enabled",
-        "path"
+        "enabled"
      ],
      "title": "SkillsConfigWriteParams",
      "type": "object"
@@ -9275,6 +9346,17 @@
                    "null"
                  ]
                },
+                "agent_path": {
+                  "anyOf": [
+                    {
+                      "$ref": "#/definitions/AgentPath"
+                    },
+                    {
+                      "type": "null"
+                    }
+                  ],
+                  "default": null
+                },
                "agent_role": {
                  "default": null,
                  "type": [
@@ -10300,6 +10382,12 @@
                "null"
              ]
            },
+            "savedPath": {
+              "type": [
+                "string",
+                "null"
+              ]
+            },
            "status": {
              "type": "string"
            },
@@ -10782,6 +10870,28 @@
      "title": "ThreadRealtimeStartedNotification",
      "type": "object"
    },
+    "ThreadRealtimeTranscriptUpdatedNotification": {
+      "$schema": "http://json-schema.org/draft-07/schema#",
+      "description": "EXPERIMENTAL - flat transcript delta emitted whenever realtime transcript text changes.",
+      "properties": {
+        "role": {
+          "type": "string"
+        },
+        "text": {
+          "type": "string"
+        },
+        "threadId": {
+          "type": "string"
+        }
+      },
+      "required": [
+        "role",
+        "text",
+        "threadId"
+      ],
+      "title": "ThreadRealtimeTranscriptUpdatedNotification",
+      "type": "object"
+    },
    "ThreadResumeParams": {
      "$schema": "http://json-schema.org/draft-07/schema#",
      "description": "There are three ways to resume a thread: 1. By thread_id: load the thread from disk by thread_id and resume it. 2. By history: instantiate the thread from memory and resume it. 3. By path: load the thread from disk by path and resume it.\n\nThe precedence is: history > path > thread_id. If using history or path, the thread_id param will be ignored.\n\nPrefer using thread_id whenever possible.",
@@ -112,9 +112,38 @@
          ],
          "title": "ResponseTooManyFailedAttemptsCodexErrorInfo",
          "type": "object"
+        },
+        {
+          "additionalProperties": false,
+          "description": "Returned when `turn/start` or `turn/steer` is submitted while the current active turn cannot accept same-turn steering, for example `/review` or manual `/compact`.",
+          "properties": {
+            "activeTurnNotSteerable": {
+              "properties": {
+                "turnKind": {
+                  "$ref": "#/definitions/NonSteerableTurnKind"
+                }
+              },
+              "required": [
+                "turnKind"
+              ],
+              "type": "object"
+            }
+          },
+          "required": [
+            "activeTurnNotSteerable"
+          ],
+          "title": "ActiveTurnNotSteerableCodexErrorInfo",
+          "type": "object"
        }
      ]
    },
+    "NonSteerableTurnKind": {
+      "enum": [
+        "review",
+        "compact"
+      ],
+      "type": "string"
+    },
    "TurnError": {
      "properties": {
        "additionalDetails": {
@@ -3,6 +3,7 @@
  "definitions": {
    "HookEventName": {
      "enum": [
+        "preToolUse",
        "sessionStart",
        "userPromptSubmit",
        "stop"
@@ -3,6 +3,7 @@
  "definitions": {
    "HookEventName": {
      "enum": [
+        "preToolUse",
        "sessionStart",
        "userPromptSubmit",
        "stop"
@@ -1026,6 +1026,12 @@
                "null"
              ]
            },
+            "savedPath": {
+              "type": [
+                "string",
+                "null"
+              ]
+            },
            "status": {
              "type": "string"
            },
@@ -1026,6 +1026,12 @@
                "null"
              ]
            },
+            "savedPath": {
+              "type": [
+                "string",
+                "null"
+              ]
+            },
            "status": {
              "type": "string"
            },
@@ -318,6 +318,9 @@
        "description": {
          "type": "string"
        },
+        "enabled": {
+          "type": "boolean"
+        },
        "interface": {
          "anyOf": [
            {
@@ -343,6 +346,7 @@
      },
      "required": [
        "description",
+        "enabled",
        "name",
        "path"
      ],
@@ -131,6 +131,28 @@
          ],
          "title": "ResponseTooManyFailedAttemptsCodexErrorInfo",
          "type": "object"
+        },
+        {
+          "additionalProperties": false,
+          "description": "Returned when `turn/start` or `turn/steer` is submitted while the current active turn cannot accept same-turn steering, for example `/review` or manual `/compact`.",
+          "properties": {
+            "activeTurnNotSteerable": {
+              "properties": {
+                "turnKind": {
+                  "$ref": "#/definitions/NonSteerableTurnKind"
+                }
+              },
+              "required": [
+                "turnKind"
+              ],
+              "type": "object"
+            }
+          },
+          "required": [
+            "activeTurnNotSteerable"
+          ],
+          "title": "ActiveTurnNotSteerableCodexErrorInfo",
+          "type": "object"
        }
      ]
    },
@@ -494,6 +516,13 @@
        }
      ]
    },
+    "NonSteerableTurnKind": {
+      "enum": [
+        "review",
+        "compact"
+      ],
+      "type": "string"
+    },
    "PatchApplyStatus": {
      "enum": [
        "inProgress",
@@ -1140,6 +1169,12 @@
                "null"
              ]
            },
+            "savedPath": {
+              "type": [
+                "string",
+                "null"
+              ]
+            },
            "status": {
              "type": "string"
            },
@@ -1,16 +1,36 @@
 {
  "$schema": "http://json-schema.org/draft-07/schema#",
+  "definitions": {
+    "AbsolutePathBuf": {
+      "description": "A path that is guaranteed to be absolute and normalized (though it is not guaranteed to be canonicalized or exist on the filesystem).\n\nIMPORTANT: When deserializing an `AbsolutePathBuf`, a base path must be set using [AbsolutePathBufGuard::new]. If no base path is set, the deserialization will fail unless the path being deserialized is already absolute.",
+      "type": "string"
+    }
+  },
  "properties": {
    "enabled": {
      "type": "boolean"
    },
+    "name": {
+      "description": "Name-based selector.",
+      "type": [
+        "string",
+        "null"
+      ]
+    },
    "path": {
-      "type": "string"
+      "anyOf": [
+        {
+          "$ref": "#/definitions/AbsolutePathBuf"
+        },
+        {
+          "type": "null"
+        }
+      ],
+      "description": "Path-based selector."
    }
  },
  "required": [
-    "enabled",
-    "path"
+    "enabled"
  ],
  "title": "SkillsConfigWriteParams",
  "type": "object"
@@ -5,6 +5,9 @@
      "description": "A path that is guaranteed to be absolute and normalized (though it is not guaranteed to be canonicalized or exist on the filesystem).\n\nIMPORTANT: When deserializing an `AbsolutePathBuf`, a base path must be set using [AbsolutePathBufGuard::new]. If no base path is set, the deserialization will fail unless the path being deserialized is already absolute.",
      "type": "string"
    },
+    "AgentPath": {
+      "type": "string"
+    },
    "ApprovalsReviewer": {
      "description": "Configures who approval requests are routed to for review. Examples include sandbox escapes, blocked network access, MCP approval prompts, and ARC escalations. Defaults to `user`. `guardian_subagent` uses a carefully prompted subagent to gather relevant context and apply a risk-based decision framework before approving or denying the request.",
      "enum": [
@@ -193,6 +196,28 @@
          ],
          "title": "ResponseTooManyFailedAttemptsCodexErrorInfo",
          "type": "object"
+        },
+        {
+          "additionalProperties": false,
+          "description": "Returned when `turn/start` or `turn/steer` is submitted while the current active turn cannot accept same-turn steering, for example `/review` or manual `/compact`.",
+          "properties": {
+            "activeTurnNotSteerable": {
+              "properties": {
+                "turnKind": {
+                  "$ref": "#/definitions/NonSteerableTurnKind"
+                }
+              },
+              "required": [
+                "turnKind"
+              ],
+              "type": "object"
+            }
+          },
+          "required": [
+            "activeTurnNotSteerable"
+          ],
+          "title": "ActiveTurnNotSteerableCodexErrorInfo",
+          "type": "object"
        }
      ]
    },
@@ -586,6 +611,13 @@
      ],
      "type": "string"
    },
+    "NonSteerableTurnKind": {
+      "enum": [
+        "review",
+        "compact"
+      ],
+      "type": "string"
+    },
    "PatchApplyStatus": {
      "enum": [
        "inProgress",
@@ -900,6 +932,17 @@
                    "null"
                  ]
                },
+                "agent_path": {
+                  "anyOf": [
+                    {
+                      "$ref": "#/definitions/AgentPath"
+                    },
+                    {
+                      "type": "null"
+                    }
+                  ],
+                  "default": null
+                },
                "agent_role": {
                  "default": null,
                  "type": [
@@ -1633,6 +1676,12 @@
                "null"
              ]
            },
+            "savedPath": {
+              "type": [
+                "string",
+                "null"
+              ]
+            },
            "status": {
              "type": "string"
            },
@@ -1,6 +1,9 @@
 {
  "$schema": "http://json-schema.org/draft-07/schema#",
  "definitions": {
+    "AgentPath": {
+      "type": "string"
+    },
    "ByteRange": {
      "properties": {
        "end": {
@@ -131,6 +134,28 @@
          ],
          "title": "ResponseTooManyFailedAttemptsCodexErrorInfo",
          "type": "object"
+        },
+        {
+          "additionalProperties": false,
+          "description": "Returned when `turn/start` or `turn/steer` is submitted while the current active turn cannot accept same-turn steering, for example `/review` or manual `/compact`.",
+          "properties": {
+            "activeTurnNotSteerable": {
+              "properties": {
+                "turnKind": {
+                  "$ref": "#/definitions/NonSteerableTurnKind"
+                }
+              },
+              "required": [
+                "turnKind"
+              ],
+              "type": "object"
+            }
+          },
+          "required": [
+            "activeTurnNotSteerable"
+          ],
+          "title": "ActiveTurnNotSteerableCodexErrorInfo",
+          "type": "object"
        }
      ]
    },
@@ -517,6 +542,13 @@
        }
      ]
    },
+    "NonSteerableTurnKind": {
+      "enum": [
+        "review",
+        "compact"
+      ],
+      "type": "string"
+    },
    "PatchApplyStatus": {
      "enum": [
        "inProgress",
@@ -658,6 +690,17 @@
                    "null"
                  ]
                },
+                "agent_path": {
+                  "anyOf": [
+                    {
+                      "$ref": "#/definitions/AgentPath"
+                    },
+                    {
+                      "type": "null"
+                    }
+                  ],
+                  "default": null
+                },
                "agent_role": {
                  "default": null,
                  "type": [
@@ -1391,6 +1434,12 @@
                "null"
              ]
            },
+            "savedPath": {
+              "type": [
+                "string",
+                "null"
+              ]
+            },
            "status": {
              "type": "string"
            },
@@ -1,6 +1,9 @@
 {
  "$schema": "http://json-schema.org/draft-07/schema#",
  "definitions": {
+    "AgentPath": {
+      "type": "string"
+    },
    "ByteRange": {
      "properties": {
        "end": {
@@ -131,6 +134,28 @@
          ],
          "title": "ResponseTooManyFailedAttemptsCodexErrorInfo",
          "type": "object"
+        },
+        {
+          "additionalProperties": false,
+          "description": "Returned when `turn/start` or `turn/steer` is submitted while the current active turn cannot accept same-turn steering, for example `/review` or manual `/compact`.",
+          "properties": {
+            "activeTurnNotSteerable": {
+              "properties": {
+                "turnKind": {
+                  "$ref": "#/definitions/NonSteerableTurnKind"
+                }
+              },
+              "required": [
+                "turnKind"
+              ],
+              "type": "object"
+            }
+          },
+          "required": [
+            "activeTurnNotSteerable"
+          ],
+          "title": "ActiveTurnNotSteerableCodexErrorInfo",
+          "type": "object"
        }
      ]
    },
@@ -517,6 +542,13 @@
        }
      ]
    },
+    "NonSteerableTurnKind": {
+      "enum": [
+        "review",
+        "compact"
+      ],
+      "type": "string"
+    },
    "PatchApplyStatus": {
      "enum": [
        "inProgress",
@@ -658,6 +690,17 @@
                    "null"
                  ]
                },
+                "agent_path": {
+                  "anyOf": [
+                    {
+                      "$ref": "#/definitions/AgentPath"
+                    },
+                    {
+                      "type": "null"
+                    }
+                  ],
+                  "default": null
+                },
                "agent_role": {
                  "default": null,
                  "type": [
@@ -1391,6 +1434,12 @@
                "null"
              ]
            },
+            "savedPath": {
+              "type": [
+                "string",
+                "null"
+              ]
+            },
            "status": {
              "type": "string"
            },
@@ -1,6 +1,9 @@
 {
  "$schema": "http://json-schema.org/draft-07/schema#",
  "definitions": {
+    "AgentPath": {
+      "type": "string"
+    },
    "ByteRange": {
      "properties": {
        "end": {
@@ -131,6 +134,28 @@
          ],
          "title": "ResponseTooManyFailedAttemptsCodexErrorInfo",
          "type": "object"
+        },
+        {
+          "additionalProperties": false,
+          "description": "Returned when `turn/start` or `turn/steer` is submitted while the current active turn cannot accept same-turn steering, for example `/review` or manual `/compact`.",
+          "properties": {
+            "activeTurnNotSteerable": {
+              "properties": {
+                "turnKind": {
+                  "$ref": "#/definitions/NonSteerableTurnKind"
+                }
+              },
+              "required": [
+                "turnKind"
+              ],
+              "type": "object"
+            }
+          },
+          "required": [
+            "activeTurnNotSteerable"
+          ],
+          "title": "ActiveTurnNotSteerableCodexErrorInfo",
+          "type": "object"
        }
      ]
    },
@@ -517,6 +542,13 @@
        }
      ]
    },
+    "NonSteerableTurnKind": {
+      "enum": [
+        "review",
+        "compact"
+      ],
+      "type": "string"
+    },
    "PatchApplyStatus": {
      "enum": [
        "inProgress",
@@ -658,6 +690,17 @@
                    "null"
                  ]
                },
+                "agent_path": {
+                  "anyOf": [
+                    {
+                      "$ref": "#/definitions/AgentPath"
+                    },
+                    {
+                      "type": "null"
+                    }
+                  ],
+                  "default": null
+                },
                "agent_role": {
                  "default": null,
                  "type": [
@@ -1391,6 +1434,12 @@
                "null"
              ]
            },
+            "savedPath": {
+              "type": [
+                "string",
+                "null"
+              ]
+            },
            "status": {
              "type": "string"
            },
@@ -0,0 +1,22 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "description": "EXPERIMENTAL - flat transcript delta emitted whenever realtime transcript text changes.",
+  "properties": {
+    "role": {
+      "type": "string"
+    },
+    "text": {
+      "type": "string"
+    },
+    "threadId": {
+      "type": "string"
+    }
+  },
+  "required": [
+    "role",
+    "text",
+    "threadId"
+  ],
+  "title": "ThreadRealtimeTranscriptUpdatedNotification",
+  "type": "object"
+}
@@ -5,6 +5,9 @@
      "description": "A path that is guaranteed to be absolute and normalized (though it is not guaranteed to be canonicalized or exist on the filesystem).\n\nIMPORTANT: When deserializing an `AbsolutePathBuf`, a base path must be set using [AbsolutePathBufGuard::new]. If no base path is set, the deserialization will fail unless the path being deserialized is already absolute.",
      "type": "string"
    },
+    "AgentPath": {
+      "type": "string"
+    },
    "ApprovalsReviewer": {
      "description": "Configures who approval requests are routed to for review. Examples include sandbox escapes, blocked network access, MCP approval prompts, and ARC escalations. Defaults to `user`. `guardian_subagent` uses a carefully prompted subagent to gather relevant context and apply a risk-based decision framework before approving or denying the request.",
      "enum": [
@@ -193,6 +196,28 @@
          ],
          "title": "ResponseTooManyFailedAttemptsCodexErrorInfo",
          "type": "object"
+        },
+        {
+          "additionalProperties": false,
+          "description": "Returned when `turn/start` or `turn/steer` is submitted while the current active turn cannot accept same-turn steering, for example `/review` or manual `/compact`.",
+          "properties": {
+            "activeTurnNotSteerable": {
+              "properties": {
+                "turnKind": {
+                  "$ref": "#/definitions/NonSteerableTurnKind"
+                }
+              },
+              "required": [
+                "turnKind"
+              ],
+              "type": "object"
+            }
+          },
+          "required": [
+            "activeTurnNotSteerable"
+          ],
+          "title": "ActiveTurnNotSteerableCodexErrorInfo",
+          "type": "object"
        }
      ]
    },
@@ -586,6 +611,13 @@
      ],
      "type": "string"
    },
+    "NonSteerableTurnKind": {
+      "enum": [
+        "review",
+        "compact"
+      ],
+      "type": "string"
+    },
    "PatchApplyStatus": {
      "enum": [
        "inProgress",
@@ -900,6 +932,17 @@
                    "null"
                  ]
                },
+                "agent_path": {
+                  "anyOf": [
+                    {
+                      "$ref": "#/definitions/AgentPath"
+                    },
+                    {
+                      "type": "null"
+                    }
+                  ],
+                  "default": null
+                },
                "agent_role": {
                  "default": null,
                  "type": [
@@ -1633,6 +1676,12 @@
                "null"
              ]
            },
+            "savedPath": {
+              "type": [
+                "string",
+                "null"
+              ]
+            },
            "status": {
              "type": "string"
            },
@@ -1,6 +1,9 @@
 {
  "$schema": "http://json-schema.org/draft-07/schema#",
  "definitions": {
+    "AgentPath": {
+      "type": "string"
+    },
    "ByteRange": {
      "properties": {
        "end": {
@@ -131,6 +134,28 @@
          ],
          "title": "ResponseTooManyFailedAttemptsCodexErrorInfo",
          "type": "object"
+        },
+        {
+          "additionalProperties": false,
+          "description": "Returned when `turn/start` or `turn/steer` is submitted while the current active turn cannot accept same-turn steering, for example `/review` or manual `/compact`.",
+          "properties": {
+            "activeTurnNotSteerable": {
+              "properties": {
+                "turnKind": {
+                  "$ref": "#/definitions/NonSteerableTurnKind"
+                }
+              },
+              "required": [
+                "turnKind"
+              ],
+              "type": "object"
+            }
+          },
+          "required": [
+            "activeTurnNotSteerable"
+          ],
+          "title": "ActiveTurnNotSteerableCodexErrorInfo",
+          "type": "object"
        }
      ]
    },
@@ -517,6 +542,13 @@
        }
      ]
    },
+    "NonSteerableTurnKind": {
+      "enum": [
+        "review",
+        "compact"
+      ],
+      "type": "string"
+    },
    "PatchApplyStatus": {
      "enum": [
        "inProgress",
@@ -658,6 +690,17 @@
                    "null"
                  ]
                },
+                "agent_path": {
+                  "anyOf": [
+                    {
+                      "$ref": "#/definitions/AgentPath"
+                    },
+                    {
+                      "type": "null"
+                    }
+                  ],
+                  "default": null
+                },
                "agent_role": {
                  "default": null,
                  "type": [
@@ -1391,6 +1434,12 @@
                "null"
              ]
            },
+            "savedPath": {
+              "type": [
+                "string",
+                "null"
+              ]
+            },
            "status": {
              "type": "string"
            },
@@ -5,6 +5,9 @@
      "description": "A path that is guaranteed to be absolute and normalized (though it is not guaranteed to be canonicalized or exist on the filesystem).\n\nIMPORTANT: When deserializing an `AbsolutePathBuf`, a base path must be set using [AbsolutePathBufGuard::new]. If no base path is set, the deserialization will fail unless the path being deserialized is already absolute.",
      "type": "string"
    },
+    "AgentPath": {
+      "type": "string"
+    },
    "ApprovalsReviewer": {
      "description": "Configures who approval requests are routed to for review. Examples include sandbox escapes, blocked network access, MCP approval prompts, and ARC escalations. Defaults to `user`. `guardian_subagent` uses a carefully prompted subagent to gather relevant context and apply a risk-based decision framework before approving or denying the request.",
      "enum": [
@@ -193,6 +196,28 @@
          ],
          "title": "ResponseTooManyFailedAttemptsCodexErrorInfo",
          "type": "object"
+        },
+        {
+          "additionalProperties": false,
+          "description": "Returned when `turn/start` or `turn/steer` is submitted while the current active turn cannot accept same-turn steering, for example `/review` or manual `/compact`.",
+          "properties": {
+            "activeTurnNotSteerable": {
+              "properties": {
+                "turnKind": {
+                  "$ref": "#/definitions/NonSteerableTurnKind"
+                }
+              },
+              "required": [
+                "turnKind"
+              ],
+              "type": "object"
+            }
+          },
+          "required": [
+            "activeTurnNotSteerable"
+          ],
+          "title": "ActiveTurnNotSteerableCodexErrorInfo",
+          "type": "object"
        }
      ]
    },
@@ -586,6 +611,13 @@
      ],
      "type": "string"
    },
+    "NonSteerableTurnKind": {
+      "enum": [
+        "review",
+        "compact"
+      ],
+      "type": "string"
+    },
    "PatchApplyStatus": {
      "enum": [
        "inProgress",
@@ -900,6 +932,17 @@
                    "null"
                  ]
                },
+                "agent_path": {
+                  "anyOf": [
+                    {
+                      "$ref": "#/definitions/AgentPath"
+                    },
+                    {
+                      "type": "null"
+                    }
+                  ],
+                  "default": null
+                },
                "agent_role": {
                  "default": null,
                  "type": [
@@ -1633,6 +1676,12 @@
                "null"
              ]
            },
+            "savedPath": {
+              "type": [
+                "string",
+                "null"
+              ]
+            },
            "status": {
              "type": "string"
            },
@@ -1,6 +1,9 @@
 {
  "$schema": "http://json-schema.org/draft-07/schema#",
  "definitions": {
+    "AgentPath": {
+      "type": "string"
+    },
    "ByteRange": {
      "properties": {
        "end": {
@@ -131,6 +134,28 @@
          ],
          "title": "ResponseTooManyFailedAttemptsCodexErrorInfo",
          "type": "object"
+        },
+        {
+          "additionalProperties": false,
+          "description": "Returned when `turn/start` or `turn/steer` is submitted while the current active turn cannot accept same-turn steering, for example `/review` or manual `/compact`.",
+          "properties": {
+            "activeTurnNotSteerable": {
+              "properties": {
+                "turnKind": {
+                  "$ref": "#/definitions/NonSteerableTurnKind"
+                }
+              },
+              "required": [
+                "turnKind"
+              ],
+              "type": "object"
+            }
+          },
+          "required": [
+            "activeTurnNotSteerable"
+          ],
+          "title": "ActiveTurnNotSteerableCodexErrorInfo",
+          "type": "object"
        }
      ]
    },
@@ -517,6 +542,13 @@
        }
      ]
    },
+    "NonSteerableTurnKind": {
+      "enum": [
+        "review",
+        "compact"
+      ],
+      "type": "string"
+    },
    "PatchApplyStatus": {
      "enum": [
        "inProgress",
@@ -658,6 +690,17 @@
                    "null"
                  ]
                },
+                "agent_path": {
+                  "anyOf": [
+                    {
+                      "$ref": "#/definitions/AgentPath"
+                    },
+                    {
+                      "type": "null"
+                    }
+                  ],
+                  "default": null
+                },
                "agent_role": {
                  "default": null,
                  "type": [
@@ -1391,6 +1434,12 @@
                "null"
              ]
            },
+            "savedPath": {
+              "type": [
+                "string",
+                "null"
+              ]
+            },
            "status": {
              "type": "string"
            },
@@ -1,6 +1,9 @@
 {
  "$schema": "http://json-schema.org/draft-07/schema#",
  "definitions": {
+    "AgentPath": {
+      "type": "string"
+    },
    "ByteRange": {
      "properties": {
        "end": {
@@ -131,6 +134,28 @@
          ],
          "title": "ResponseTooManyFailedAttemptsCodexErrorInfo",
          "type": "object"
+        },
+        {
+          "additionalProperties": false,
+          "description": "Returned when `turn/start` or `turn/steer` is submitted while the current active turn cannot accept same-turn steering, for example `/review` or manual `/compact`.",
+          "properties": {
+            "activeTurnNotSteerable": {
+              "properties": {
+                "turnKind": {
+                  "$ref": "#/definitions/NonSteerableTurnKind"
+                }
+              },
+              "required": [
+                "turnKind"
+              ],
+              "type": "object"
+            }
+          },
+          "required": [
+            "activeTurnNotSteerable"
+          ],
+          "title": "ActiveTurnNotSteerableCodexErrorInfo",
+          "type": "object"
        }
      ]
    },
@@ -517,6 +542,13 @@
        }
      ]
    },
+    "NonSteerableTurnKind": {
+      "enum": [
+        "review",
+        "compact"
+      ],
+      "type": "string"
+    },
    "PatchApplyStatus": {
      "enum": [
        "inProgress",
@@ -658,6 +690,17 @@
                    "null"
                  ]
                },
+                "agent_path": {
+                  "anyOf": [
+                    {
+                      "$ref": "#/definitions/AgentPath"
+                    },
+                    {
+                      "type": "null"
+                    }
+                  ],
+                  "default": null
+                },
                "agent_role": {
                  "default": null,
                  "type": [
@@ -1391,6 +1434,12 @@
                "null"
              ]
            },
+            "savedPath": {
+              "type": [
+                "string",
+                "null"
+              ]
+            },
            "status": {
              "type": "string"
            },
@@ -131,6 +131,28 @@
          ],
          "title": "ResponseTooManyFailedAttemptsCodexErrorInfo",
          "type": "object"
+        },
+        {
+          "additionalProperties": false,
+          "description": "Returned when `turn/start` or `turn/steer` is submitted while the current active turn cannot accept same-turn steering, for example `/review` or manual `/compact`.",
+          "properties": {
+            "activeTurnNotSteerable": {
+              "properties": {
+                "turnKind": {
+                  "$ref": "#/definitions/NonSteerableTurnKind"
+                }
+              },
+              "required": [
+                "turnKind"
+              ],
+              "type": "object"
+            }
+          },
+          "required": [
+            "activeTurnNotSteerable"
+          ],
+          "title": "ActiveTurnNotSteerableCodexErrorInfo",
+          "type": "object"
        }
      ]
    },
@@ -494,6 +516,13 @@
        }
      ]
    },
+    "NonSteerableTurnKind": {
+      "enum": [
+        "review",
+        "compact"
+      ],
+      "type": "string"
+    },
    "PatchApplyStatus": {
      "enum": [
        "inProgress",
@@ -1140,6 +1169,12 @@
                "null"
              ]
            },
+            "savedPath": {
+              "type": [
+                "string",
+                "null"
+              ]
+            },
            "status": {
              "type": "string"
            },
@@ -131,6 +131,28 @@
          ],
          "title": "ResponseTooManyFailedAttemptsCodexErrorInfo",
          "type": "object"
+        },
+        {
+          "additionalProperties": false,
+          "description": "Returned when `turn/start` or `turn/steer` is submitted while the current active turn cannot accept same-turn steering, for example `/review` or manual `/compact`.",
+          "properties": {
+            "activeTurnNotSteerable": {
+              "properties": {
+                "turnKind": {
+                  "$ref": "#/definitions/NonSteerableTurnKind"
+                }
+              },
+              "required": [
+                "turnKind"
+              ],
+              "type": "object"
+            }
+          },
+          "required": [
+            "activeTurnNotSteerable"
+          ],
+          "title": "ActiveTurnNotSteerableCodexErrorInfo",
+          "type": "object"
        }
      ]
    },
@@ -494,6 +516,13 @@
        }
      ]
    },
+    "NonSteerableTurnKind": {
+      "enum": [
+        "review",
+        "compact"
+      ],
+      "type": "string"
+    },
    "PatchApplyStatus": {
      "enum": [
        "inProgress",
@@ -1140,6 +1169,12 @@
                "null"
              ]
            },
+            "savedPath": {
+              "type": [
+                "string",
+                "null"
+              ]
+            },
            "status": {
              "type": "string"
            },
@@ -131,6 +131,28 @@
          ],
          "title": "ResponseTooManyFailedAttemptsCodexErrorInfo",
          "type": "object"
+        },
+        {
+          "additionalProperties": false,
+          "description": "Returned when `turn/start` or `turn/steer` is submitted while the current active turn cannot accept same-turn steering, for example `/review` or manual `/compact`.",
+          "properties": {
+            "activeTurnNotSteerable": {
+              "properties": {
+                "turnKind": {
+                  "$ref": "#/definitions/NonSteerableTurnKind"
+                }
+              },
+              "required": [
+                "turnKind"
+              ],
+              "type": "object"
+            }
+          },
+          "required": [
+            "activeTurnNotSteerable"
+          ],
+          "title": "ActiveTurnNotSteerableCodexErrorInfo",
+          "type": "object"
        }
      ]
    },
@@ -494,6 +516,13 @@
        }
      ]
    },
+    "NonSteerableTurnKind": {
+      "enum": [
+        "review",
+        "compact"
+      ],
+      "type": "string"
+    },
    "PatchApplyStatus": {
      "enum": [
        "inProgress",
@@ -1140,6 +1169,12 @@
                "null"
              ]
            },
+            "savedPath": {
+              "type": [
+                "string",
+                "null"
+              ]
+            },
            "status": {
              "type": "string"
            },
@@ -0,0 +1,5 @@
+// GENERATED CODE! DO NOT MODIFY BY HAND!
+
+// This file was generated by [ts-rs](https://github.com/Aleph-Alpha/ts-rs). Do not edit this file manually.
+
+export type AgentPath = string;
@@ -41,6 +41,7 @@ import type { ThreadRealtimeErrorNotification } from "./v2/ThreadRealtimeErrorNo
 import type { ThreadRealtimeItemAddedNotification } from "./v2/ThreadRealtimeItemAddedNotification";
 import type { ThreadRealtimeOutputAudioDeltaNotification } from "./v2/ThreadRealtimeOutputAudioDeltaNotification";
 import type { ThreadRealtimeStartedNotification } from "./v2/ThreadRealtimeStartedNotification";
+import type { ThreadRealtimeTranscriptUpdatedNotification } from "./v2/ThreadRealtimeTranscriptUpdatedNotification";
 import type { ThreadStartedNotification } from "./v2/ThreadStartedNotification";
 import type { ThreadStatusChangedNotification } from "./v2/ThreadStatusChangedNotification";
 import type { ThreadTokenUsageUpdatedNotification } from "./v2/ThreadTokenUsageUpdatedNotification";
@@ -55,4 +56,4 @@ import type { WindowsWorldWritableWarningNotification } from "./v2/WindowsWorldW
 /**
 * Notification sent from the server to the client.
 */
-export type ServerNotification = { "method": "error", "params": ErrorNotification } | { "method": "thread/started", "params": ThreadStartedNotification } | { "method": "thread/status/changed", "params": ThreadStatusChangedNotification } | { "method": "thread/archived", "params": ThreadArchivedNotification } | { "method": "thread/unarchived", "params": ThreadUnarchivedNotification } | { "method": "thread/closed", "params": ThreadClosedNotification } | { "method": "skills/changed", "params": SkillsChangedNotification } | { "method": "thread/name/updated", "params": ThreadNameUpdatedNotification } | { "method": "thread/tokenUsage/updated", "params": ThreadTokenUsageUpdatedNotification } | { "method": "turn/started", "params": TurnStartedNotification } | { "method": "hook/started", "params": HookStartedNotification } | { "method": "turn/completed", "params": TurnCompletedNotification } | { "method": "hook/completed", "params": HookCompletedNotification } | { "method": "turn/diff/updated", "params": TurnDiffUpdatedNotification } | { "method": "turn/plan/updated", "params": TurnPlanUpdatedNotification } | { "method": "item/started", "params": ItemStartedNotification } | { "method": "item/autoApprovalReview/started", "params": ItemGuardianApprovalReviewStartedNotification } | { "method": "item/autoApprovalReview/completed", "params": ItemGuardianApprovalReviewCompletedNotification } | { "method": "item/completed", "params": ItemCompletedNotification } | { "method": "rawResponseItem/completed", "params": RawResponseItemCompletedNotification } | { "method": "item/agentMessage/delta", "params": AgentMessageDeltaNotification } | { "method": "item/plan/delta", "params": PlanDeltaNotification } | { "method": "command/exec/outputDelta", "params": CommandExecOutputDeltaNotification } | { "method": "item/commandExecution/outputDelta", "params": CommandExecutionOutputDeltaNotification } | { "method": "item/commandExecution/terminalInteraction", "params": TerminalInteractionNotification } | { "method": "item/fileChange/outputDelta", "params": FileChangeOutputDeltaNotification } | { "method": "serverRequest/resolved", "params": ServerRequestResolvedNotification } | { "method": "item/mcpToolCall/progress", "params": McpToolCallProgressNotification } | { "method": "mcpServer/oauthLogin/completed", "params": McpServerOauthLoginCompletedNotification } | { "method": "mcpServer/startupStatus/updated", "params": McpServerStatusUpdatedNotification } | { "method": "account/updated", "params": AccountUpdatedNotification } | { "method": "account/rateLimits/updated", "params": AccountRateLimitsUpdatedNotification } | { "method": "app/list/updated", "params": AppListUpdatedNotification } | { "method": "item/reasoning/summaryTextDelta", "params": ReasoningSummaryTextDeltaNotification } | { "method": "item/reasoning/summaryPartAdded", "params": ReasoningSummaryPartAddedNotification } | { "method": "item/reasoning/textDelta", "params": ReasoningTextDeltaNotification } | { "method": "thread/compacted", "params": ContextCompactedNotification } | { "method": "model/rerouted", "params": ModelReroutedNotification } | { "method": "deprecationNotice", "params": DeprecationNoticeNotification } | { "method": "configWarning", "params": ConfigWarningNotification } | { "method": "fuzzyFileSearch/sessionUpdated", "params": FuzzyFileSearchSessionUpdatedNotification } | { "method": "fuzzyFileSearch/sessionCompleted", "params": FuzzyFileSearchSessionCompletedNotification } | { "method": "thread/realtime/started", "params": ThreadRealtimeStartedNotification } | { "method": "thread/realtime/itemAdded", "params": ThreadRealtimeItemAddedNotification } | { "method": "thread/realtime/outputAudio/delta", "params": ThreadRealtimeOutputAudioDeltaNotification } | { "method": "thread/realtime/error", "params": ThreadRealtimeErrorNotification } | { "method": "thread/realtime/closed", "params": ThreadRealtimeClosedNotification } | { "method": "windows/worldWritableWarning", "params": WindowsWorldWritableWarningNotification } | { "method": "windowsSandbox/setupCompleted", "params": WindowsSandboxSetupCompletedNotification } | { "method": "account/login/completed", "params": AccountLoginCompletedNotification };
+export type ServerNotification = { "method": "error", "params": ErrorNotification } | { "method": "thread/started", "params": ThreadStartedNotification } | { "method": "thread/status/changed", "params": ThreadStatusChangedNotification } | { "method": "thread/archived", "params": ThreadArchivedNotification } | { "method": "thread/unarchived", "params": ThreadUnarchivedNotification } | { "method": "thread/closed", "params": ThreadClosedNotification } | { "method": "skills/changed", "params": SkillsChangedNotification } | { "method": "thread/name/updated", "params": ThreadNameUpdatedNotification } | { "method": "thread/tokenUsage/updated", "params": ThreadTokenUsageUpdatedNotification } | { "method": "turn/started", "params": TurnStartedNotification } | { "method": "hook/started", "params": HookStartedNotification } | { "method": "turn/completed", "params": TurnCompletedNotification } | { "method": "hook/completed", "params": HookCompletedNotification } | { "method": "turn/diff/updated", "params": TurnDiffUpdatedNotification } | { "method": "turn/plan/updated", "params": TurnPlanUpdatedNotification } | { "method": "item/started", "params": ItemStartedNotification } | { "method": "item/autoApprovalReview/started", "params": ItemGuardianApprovalReviewStartedNotification } | { "method": "item/autoApprovalReview/completed", "params": ItemGuardianApprovalReviewCompletedNotification } | { "method": "item/completed", "params": ItemCompletedNotification } | { "method": "rawResponseItem/completed", "params": RawResponseItemCompletedNotification } | { "method": "item/agentMessage/delta", "params": AgentMessageDeltaNotification } | { "method": "item/plan/delta", "params": PlanDeltaNotification } | { "method": "command/exec/outputDelta", "params": CommandExecOutputDeltaNotification } | { "method": "item/commandExecution/outputDelta", "params": CommandExecutionOutputDeltaNotification } | { "method": "item/commandExecution/terminalInteraction", "params": TerminalInteractionNotification } | { "method": "item/fileChange/outputDelta", "params": FileChangeOutputDeltaNotification } | { "method": "serverRequest/resolved", "params": ServerRequestResolvedNotification } | { "method": "item/mcpToolCall/progress", "params": McpToolCallProgressNotification } | { "method": "mcpServer/oauthLogin/completed", "params": McpServerOauthLoginCompletedNotification } | { "method": "mcpServer/startupStatus/updated", "params": McpServerStatusUpdatedNotification } | { "method": "account/updated", "params": AccountUpdatedNotification } | { "method": "account/rateLimits/updated", "params": AccountRateLimitsUpdatedNotification } | { "method": "app/list/updated", "params": AppListUpdatedNotification } | { "method": "item/reasoning/summaryTextDelta", "params": ReasoningSummaryTextDeltaNotification } | { "method": "item/reasoning/summaryPartAdded", "params": ReasoningSummaryPartAddedNotification } | { "method": "item/reasoning/textDelta", "params": ReasoningTextDeltaNotification } | { "method": "thread/compacted", "params": ContextCompactedNotification } | { "method": "model/rerouted", "params": ModelReroutedNotification } | { "method": "deprecationNotice", "params": DeprecationNoticeNotification } | { "method": "configWarning", "params": ConfigWarningNotification } | { "method": "fuzzyFileSearch/sessionUpdated", "params": FuzzyFileSearchSessionUpdatedNotification } | { "method": "fuzzyFileSearch/sessionCompleted", "params": FuzzyFileSearchSessionCompletedNotification } | { "method": "thread/realtime/started", "params": ThreadRealtimeStartedNotification } | { "method": "thread/realtime/itemAdded", "params": ThreadRealtimeItemAddedNotification } | { "method": "thread/realtime/transcriptUpdated", "params": ThreadRealtimeTranscriptUpdatedNotification } | { "method": "thread/realtime/outputAudio/delta", "params": ThreadRealtimeOutputAudioDeltaNotification } | { "method": "thread/realtime/error", "params": ThreadRealtimeErrorNotification } | { "method": "thread/realtime/closed", "params": ThreadRealtimeClosedNotification } | { "method": "windows/worldWritableWarning", "params": WindowsWorldWritableWarningNotification } | { "method": "windowsSandbox/setupCompleted", "params": WindowsSandboxSetupCompletedNotification } | { "method": "account/login/completed", "params": AccountLoginCompletedNotification };
@@ -1,6 +1,7 @@
 // GENERATED CODE! DO NOT MODIFY BY HAND!

 // This file was generated by [ts-rs](https://github.com/Aleph-Alpha/ts-rs). Do not edit this file manually.
+import type { AgentPath } from "./AgentPath";
 import type { ThreadId } from "./ThreadId";

-export type SubAgentSource = "review" | "compact" | { "thread_spawn": { parent_thread_id: ThreadId, depth: number, agent_nickname: string | null, agent_role: string | null, } } | "memory_consolidation" | { "other": string };
+export type SubAgentSource = "review" | "compact" | { "thread_spawn": { parent_thread_id: ThreadId, depth: number, agent_path: AgentPath | null, agent_nickname: string | null, agent_role: string | null, } } | "memory_consolidation" | { "other": string };
@@ -1,6 +1,7 @@
 // GENERATED CODE! DO NOT MODIFY BY HAND!

 export type { AbsolutePathBuf } from "./AbsolutePathBuf";
+export type { AgentPath } from "./AgentPath";
 export type { ApplyPatchApprovalParams } from "./ApplyPatchApprovalParams";
 export type { ApplyPatchApprovalResponse } from "./ApplyPatchApprovalResponse";
 export type { AuthMode } from "./AuthMode";
@@ -1,6 +1,7 @@
 // GENERATED CODE! DO NOT MODIFY BY HAND!

 // This file was generated by [ts-rs](https://github.com/Aleph-Alpha/ts-rs). Do not edit this file manually.
+import type { NonSteerableTurnKind } from "./NonSteerableTurnKind";

 /**
 * This translation layer make sure that we expose codex error code in camel case.
@@ -8,4 +9,4 @@
 * When an upstream HTTP status is available (for example, from the Responses API or a provider),
 * it is forwarded in `httpStatusCode` on the relevant `codexErrorInfo` variant.
 */
-export type CodexErrorInfo = "contextWindowExceeded" | "usageLimitExceeded" | "serverOverloaded" | { "httpConnectionFailed": { httpStatusCode: number | null, } } | { "responseStreamConnectionFailed": { httpStatusCode: number | null, } } | "internalServerError" | "unauthorized" | "badRequest" | "threadRollbackFailed" | "sandboxError" | { "responseStreamDisconnected": { httpStatusCode: number | null, } } | { "responseTooManyFailedAttempts": { httpStatusCode: number | null, } } | "other";
+export type CodexErrorInfo = "contextWindowExceeded" | "usageLimitExceeded" | "serverOverloaded" | { "httpConnectionFailed": { httpStatusCode: number | null, } } | { "responseStreamConnectionFailed": { httpStatusCode: number | null, } } | "internalServerError" | "unauthorized" | "badRequest" | "threadRollbackFailed" | "sandboxError" | { "responseStreamDisconnected": { httpStatusCode: number | null, } } | { "responseTooManyFailedAttempts": { httpStatusCode: number | null, } } | { "activeTurnNotSteerable": { turnKind: NonSteerableTurnKind, } } | "other";
@@ -2,4 +2,4 @@

 // This file was generated by [ts-rs](https://github.com/Aleph-Alpha/ts-rs). Do not edit this file manually.

-export type HookEventName = "sessionStart" | "userPromptSubmit" | "stop";
+export type HookEventName = "preToolUse" | "sessionStart" | "userPromptSubmit" | "stop";
@@ -0,0 +1,5 @@
+// GENERATED CODE! DO NOT MODIFY BY HAND!
+
+// This file was generated by [ts-rs](https://github.com/Aleph-Alpha/ts-rs). Do not edit this file manually.
+
+export type NonSteerableTurnKind = "review" | "compact";
@@ -3,4 +3,4 @@
 // This file was generated by [ts-rs](https://github.com/Aleph-Alpha/ts-rs). Do not edit this file manually.
 import type { SkillInterface } from "./SkillInterface";

-export type SkillSummary = { name: string, description: string, shortDescription: string | null, interface: SkillInterface | null, path: string, };
+export type SkillSummary = { name: string, description: string, shortDescription: string | null, interface: SkillInterface | null, path: string, enabled: boolean, };
@@ -1,5 +1,14 @@
 // GENERATED CODE! DO NOT MODIFY BY HAND!

 // This file was generated by [ts-rs](https://github.com/Aleph-Alpha/ts-rs). Do not edit this file manually.
+import type { AbsolutePathBuf } from "../AbsolutePathBuf";

-export type SkillsConfigWriteParams = { path: string, enabled: boolean, };
+export type SkillsConfigWriteParams = { 
+/**
+ * Path-based selector.
+ */
+path?: AbsolutePathBuf | null, 
+/**
+ * Name-based selector.
+ */
+name?: string | null, enabled: boolean, };
@@ -97,4 +97,4 @@ reasoningEffort: ReasoningEffort | null,
 /**
 * Last known status of the target agents, when available.
 */
-agentsStates: { [key in string]?: CollabAgentState }, } | { "type": "webSearch", id: string, query: string, action: WebSearchAction | null, } | { "type": "imageView", id: string, path: string, } | { "type": "imageGeneration", id: string, status: string, revisedPrompt: string | null, result: string, } | { "type": "enteredReviewMode", id: string, review: string, } | { "type": "exitedReviewMode", id: string, review: string, } | { "type": "contextCompaction", id: string, };
+agentsStates: { [key in string]?: CollabAgentState }, } | { "type": "webSearch", id: string, query: string, action: WebSearchAction | null, } | { "type": "imageView", id: string, path: string, } | { "type": "imageGeneration", id: string, status: string, revisedPrompt: string | null, result: string, savedPath?: string, } | { "type": "enteredReviewMode", id: string, review: string, } | { "type": "exitedReviewMode", id: string, review: string, } | { "type": "contextCompaction", id: string, };
@@ -0,0 +1,9 @@
+// GENERATED CODE! DO NOT MODIFY BY HAND!
+
+// This file was generated by [ts-rs](https://github.com/Aleph-Alpha/ts-rs). Do not edit this file manually.
+
+/**
+ * EXPERIMENTAL - flat transcript delta emitted whenever realtime
+ * transcript text changes.
+ */
+export type ThreadRealtimeTranscriptUpdatedNotification = { threadId: string, role: string, text: string, };
@@ -194,6 +194,7 @@ export type { NetworkApprovalProtocol } from "./NetworkApprovalProtocol";
 export type { NetworkPolicyAmendment } from "./NetworkPolicyAmendment";
 export type { NetworkPolicyRuleAction } from "./NetworkPolicyRuleAction";
 export type { NetworkRequirements } from "./NetworkRequirements";
+export type { NonSteerableTurnKind } from "./NonSteerableTurnKind";
 export type { OverriddenMetadata } from "./OverriddenMetadata";
 export type { PatchApplyStatus } from "./PatchApplyStatus";
 export type { PatchChangeKind } from "./PatchChangeKind";
@@ -281,6 +282,7 @@ export type { ThreadRealtimeErrorNotification } from "./ThreadRealtimeErrorNotif
 export type { ThreadRealtimeItemAddedNotification } from "./ThreadRealtimeItemAddedNotification";
 export type { ThreadRealtimeOutputAudioDeltaNotification } from "./ThreadRealtimeOutputAudioDeltaNotification";
 export type { ThreadRealtimeStartedNotification } from "./ThreadRealtimeStartedNotification";
+export type { ThreadRealtimeTranscriptUpdatedNotification } from "./ThreadRealtimeTranscriptUpdatedNotification";
 export type { ThreadResumeParams } from "./ThreadResumeParams";
 export type { ThreadResumeResponse } from "./ThreadResumeResponse";
 export type { ThreadRollbackParams } from "./ThreadRollbackParams";
@@ -923,6 +923,8 @@ server_notification_definitions! {
    ThreadRealtimeStarted => "thread/realtime/started" (v2::ThreadRealtimeStartedNotification),
    #[experimental("thread/realtime/itemAdded")]
    ThreadRealtimeItemAdded => "thread/realtime/itemAdded" (v2::ThreadRealtimeItemAddedNotification),
+    #[experimental("thread/realtime/transcriptUpdated")]
+    ThreadRealtimeTranscriptUpdated => "thread/realtime/transcriptUpdated" (v2::ThreadRealtimeTranscriptUpdatedNotification),
    #[experimental("thread/realtime/outputAudio/delta")]
    ThreadRealtimeOutputAudioDelta => "thread/realtime/outputAudio/delta" (v2::ThreadRealtimeOutputAudioDeltaNotification),
    #[experimental("thread/realtime/error")]
@@ -569,6 +569,7 @@ impl ThreadHistoryBuilder {
            status: String::new(),
            revised_prompt: None,
            result: String::new(),
+            saved_path: None,
        };
        self.upsert_item_in_current_turn(item);
    }
@@ -579,6 +580,7 @@ impl ThreadHistoryBuilder {
            status: payload.status.clone(),
            revised_prompt: payload.revised_prompt.clone(),
            result: payload.result.clone(),
+            saved_path: payload.saved_path.clone(),
        };
        self.upsert_item_in_current_turn(item);
    }
@@ -1385,6 +1387,61 @@ mod tests {
        );
    }

+    #[test]
+    fn replays_image_generation_end_events_into_turn_history() {
+        let items = vec![
+            RolloutItem::EventMsg(EventMsg::TurnStarted(TurnStartedEvent {
+                turn_id: "turn-image".into(),
+                model_context_window: None,
+                collaboration_mode_kind: Default::default(),
+            })),
+            RolloutItem::EventMsg(EventMsg::UserMessage(UserMessageEvent {
+                message: "generate an image".into(),
+                images: None,
+                text_elements: Vec::new(),
+                local_images: Vec::new(),
+            })),
+            RolloutItem::EventMsg(EventMsg::ImageGenerationEnd(ImageGenerationEndEvent {
+                call_id: "ig_123".into(),
+                status: "completed".into(),
+                revised_prompt: Some("final prompt".into()),
+                result: "Zm9v".into(),
+                saved_path: Some("/tmp/ig_123.png".into()),
+            })),
+            RolloutItem::EventMsg(EventMsg::TurnComplete(TurnCompleteEvent {
+                turn_id: "turn-image".into(),
+                last_agent_message: None,
+            })),
+        ];
+
+        let turns = build_turns_from_rollout_items(&items);
+        assert_eq!(turns.len(), 1);
+        assert_eq!(
+            turns[0],
+            Turn {
+                id: "turn-image".into(),
+                status: TurnStatus::Completed,
+                error: None,
+                items: vec![
+                    ThreadItem::UserMessage {
+                        id: "item-1".into(),
+                        content: vec![UserInput::Text {
+                            text: "generate an image".into(),
+                            text_elements: Vec::new(),
+                        }],
+                    },
+                    ThreadItem::ImageGeneration {
+                        id: "ig_123".into(),
+                        status: "completed".into(),
+                        revised_prompt: Some("final prompt".into()),
+                        result: "Zm9v".into(),
+                        saved_path: Some("/tmp/ig_123.png".into()),
+                    },
+                ],
+            }
+        );
+    }
+
    #[test]
    fn splits_reasoning_when_interleaved() {
        let events = vec![
@@ -66,6 +66,7 @@ use codex_protocol::protocol::HookRunSummary as CoreHookRunSummary;
 use codex_protocol::protocol::HookScope as CoreHookScope;
 use codex_protocol::protocol::ModelRerouteReason as CoreModelRerouteReason;
 use codex_protocol::protocol::NetworkAccess as CoreNetworkAccess;
+use codex_protocol::protocol::NonSteerableTurnKind as CoreNonSteerableTurnKind;
 use codex_protocol::protocol::PatchApplyStatus as CorePatchApplyStatus;
 use codex_protocol::protocol::RateLimitSnapshot as CoreRateLimitSnapshot;
 use codex_protocol::protocol::RateLimitWindow as CoreRateLimitWindow;
@@ -128,6 +129,14 @@ macro_rules! v2_enum_from_core {
    };
 }

+#[derive(Serialize, Deserialize, Debug, Clone, Copy, PartialEq, Eq, JsonSchema, TS)]
+#[serde(rename_all = "camelCase")]
+#[ts(export_to = "v2/")]
+pub enum NonSteerableTurnKind {
+    Review,
+    Compact,
+}
+
 /// This translation layer make sure that we expose codex error code in camel case.
 ///
 /// When an upstream HTTP status is available (for example, from the Responses API or a provider),
@@ -167,6 +176,13 @@ pub enum CodexErrorInfo {
        #[ts(rename = "httpStatusCode")]
        http_status_code: Option<u16>,
    },
+    /// Returned when `turn/start` or `turn/steer` is submitted while the current active turn
+    /// cannot accept same-turn steering, for example `/review` or manual `/compact`.
+    ActiveTurnNotSteerable {
+        #[serde(rename = "turnKind")]
+        #[ts(rename = "turnKind")]
+        turn_kind: NonSteerableTurnKind,
+    },
    Other,
 }

@@ -193,11 +209,25 @@ impl From<CoreCodexErrorInfo> for CodexErrorInfo {
            CoreCodexErrorInfo::ResponseTooManyFailedAttempts { http_status_code } => {
                CodexErrorInfo::ResponseTooManyFailedAttempts { http_status_code }
            }
+            CoreCodexErrorInfo::ActiveTurnNotSteerable { turn_kind } => {
+                CodexErrorInfo::ActiveTurnNotSteerable {
+                    turn_kind: turn_kind.into(),
+                }
+            }
            CoreCodexErrorInfo::Other => CodexErrorInfo::Other,
        }
    }
 }

+impl From<CoreNonSteerableTurnKind> for NonSteerableTurnKind {
+    fn from(value: CoreNonSteerableTurnKind) -> Self {
+        match value {
+            CoreNonSteerableTurnKind::Review => Self::Review,
+            CoreNonSteerableTurnKind::Compact => Self::Compact,
+        }
+    }
+}
+
 #[derive(
    Serialize, Deserialize, Debug, Clone, Copy, PartialEq, Eq, JsonSchema, TS, ExperimentalApi,
 )]
@@ -347,7 +377,7 @@ v2_enum_from_core!(

 v2_enum_from_core!(
    pub enum HookEventName from CoreHookEventName {
-        SessionStart, UserPromptSubmit, Stop
+        PreToolUse, SessionStart, UserPromptSubmit, Stop
    }
 );

@@ -3310,6 +3340,7 @@ pub struct SkillSummary {
    pub short_description: Option<String>,
    pub interface: Option<SkillInterface>,
    pub path: PathBuf,
+    pub enabled: bool,
 }

 #[derive(Serialize, Deserialize, Debug, Clone, PartialEq, JsonSchema, TS)]
@@ -3348,7 +3379,12 @@ pub enum PluginSource {
 #[serde(rename_all = "camelCase")]
 #[ts(export_to = "v2/")]
 pub struct SkillsConfigWriteParams {
-    pub path: PathBuf,
+    /// Path-based selector.
+    #[ts(optional = nullable)]
+    pub path: Option<AbsolutePathBuf>,
+    /// Name-based selector.
+    #[ts(optional = nullable)]
+    pub name: Option<String>,
    pub enabled: bool,
 }

@@ -3787,6 +3823,17 @@ pub struct ThreadRealtimeItemAddedNotification {
    pub item: JsonValue,
 }

+/// EXPERIMENTAL - flat transcript delta emitted whenever realtime
+/// transcript text changes.
+#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, JsonSchema, TS)]
+#[serde(rename_all = "camelCase")]
+#[ts(export_to = "v2/")]
+pub struct ThreadRealtimeTranscriptUpdatedNotification {
+    pub thread_id: String,
+    pub role: String,
+    pub text: String,
+}
+
 /// EXPERIMENTAL - streamed output audio emitted by thread realtime.
 #[derive(Serialize, Deserialize, Debug, Clone, PartialEq, JsonSchema, TS)]
 #[serde(rename_all = "camelCase")]
@@ -4256,6 +4303,9 @@ pub enum ThreadItem {
        status: String,
        revised_prompt: Option<String>,
        result: String,
+        #[serde(default, skip_serializing_if = "Option::is_none")]
+        #[ts(optional)]
+        saved_path: Option<String>,
    },
    #[serde(rename_all = "camelCase")]
    #[ts(rename_all = "camelCase")]
@@ -4432,6 +4482,7 @@ impl From<CoreTurnItem> for ThreadItem {
                status: image.status,
                revised_prompt: image.revised_prompt,
                result: image.result,
+                saved_path: image.saved_path,
            },
            CoreTurnItem::ContextCompaction(compaction) => {
                ThreadItem::ContextCompaction { id: compaction.id }
@@ -7817,6 +7868,22 @@ mod tests {
        );
    }

+    #[test]
+    fn codex_error_info_serializes_active_turn_not_steerable_turn_kind_in_camel_case() {
+        let value = CodexErrorInfo::ActiveTurnNotSteerable {
+            turn_kind: NonSteerableTurnKind::Review,
+        };
+
+        assert_eq!(
+            serde_json::to_value(value).unwrap(),
+            json!({
+                "activeTurnNotSteerable": {
+                    "turnKind": "review"
+                }
+            })
+        );
+    }
+
    #[test]
    fn dynamic_tool_response_serializes_content_items() {
        let value = serde_json::to_value(DynamicToolCallResponse {
@@ -33,6 +33,7 @@ codex-arg0 = { workspace = true }
 codex-cloud-requirements = { workspace = true }
 codex-core = { workspace = true }
 codex-exec-server = { workspace = true }
+codex-features = { workspace = true }
 codex-otel = { workspace = true }
 codex-shell-command = { workspace = true }
 codex-utils-cli = { workspace = true }
@@ -140,7 +140,7 @@ Example with notification opt-out:
 - `thread/backgroundTerminals/clean` — terminate all running background terminals for a thread (experimental; requires `capabilities.experimentalApi`); returns `{}` when the cleanup request is accepted.
 - `thread/rollback` — drop the last N turns from the agent’s in-memory context and persist a rollback marker in the rollout so future resumes see the pruned history; returns the updated `thread` (with `turns` populated) on success.
 - `turn/start` — add user input to a thread and begin Codex generation; responds with the initial `turn` object and streams `turn/started`, `item/*`, and `turn/completed` notifications. For `collaborationMode`, `settings.developer_instructions: null` means "use built-in instructions for the selected mode".
- `turn/steer` — add user input to an already in-flight turn without starting a new turn; returns the active `turnId` that accepted the input.
+- `turn/steer` — add user input to an already in-flight regular turn without starting a new turn; returns the active `turnId` that accepted the input. Review and manual compaction turns reject `turn/steer`.
 - `turn/interrupt` — request cancellation of an in-flight turn by `(thread_id, turn_id)`; success is an empty `{}` response and the turn finishes with `status: "interrupted"`.
 - `thread/realtime/start` — start a thread-scoped realtime session (experimental); returns `{}` and streams `thread/realtime/*` notifications.
 - `thread/realtime/appendAudio` — append an input audio chunk to the active realtime session (experimental); returns `{}`.
@@ -164,11 +164,11 @@ Example with notification opt-out:
 - `collaborationMode/list` — list available collaboration mode presets (experimental, no pagination). This response omits built-in developer instructions; clients should either pass `settings.developer_instructions: null` when setting a mode to use Codex's built-in instructions, or provide their own instructions explicitly.
 - `skills/list` — list skills for one or more `cwd` values (optional `forceReload`).
 - `plugin/list` — list discovered plugin marketplaces and plugin state, including effective marketplace install/auth policy metadata and best-effort `featuredPluginIds` for the official curated marketplace. `interface.category` uses the marketplace category when present; otherwise it falls back to the plugin manifest category. Pass `forceRemoteSync: true` to refresh curated plugin state before listing (**under development; do not call from production clients yet**).
- `plugin/read` — read one plugin by `marketplacePath` plus `pluginName`, returning marketplace info, a list-style `summary`, manifest descriptions/interface metadata, and bundled skills/apps/MCP server names. Plugin app summaries also include `needsAuth` when the server can determine connector accessibility (**under development; do not call from production clients yet**).
+- `plugin/read` — read one plugin by `marketplacePath` plus `pluginName`, returning marketplace info, a list-style `summary`, manifest descriptions/interface metadata, and bundled skills/apps/MCP server names. Returned plugin skills include their current `enabled` state after local config filtering. Plugin app summaries also include `needsAuth` when the server can determine connector accessibility (**under development; do not call from production clients yet**).
 - `skills/changed` — notification emitted when watched local skill files change.
 - `app/list` — list available apps.
- `skills/config/write` — write user-level skill config by path.
- `plugin/install` — install a plugin from a discovered marketplace entry, rejecting marketplace entries marked unavailable for install, and return the effective plugin auth policy plus any apps that still need auth (**under development; do not call from production clients yet**).
+- `skills/config/write` — write user-level skill config by name or absolute path.
+- `plugin/install` — install a plugin from a discovered marketplace entry, rejecting marketplace entries marked unavailable for install, install MCPs if any, and return the effective plugin auth policy plus any apps that still need auth (**under development; do not call from production clients yet**).
 - `plugin/uninstall` — uninstall a plugin by id by removing its cached files and clearing its user-level config entry (**under development; do not call from production clients yet**).
 - `mcpServer/oauth/login` — start an OAuth login for a configured MCP server; returns an `authorization_url` and later emits `mcpServer/oauthLogin/completed` once the browser flow finishes.
 - `tool/requestUserInput` — prompt the user with 1–3 short questions for a tool call and return their answers (experimental).
@@ -575,8 +575,8 @@ Use `thread/backgroundTerminals/clean` to terminate all running background termi

 ### Example: Steer an active turn

-Use `turn/steer` to append additional user input to the currently active turn. This does not emit
-`turn/started` and does not accept turn context overrides.
+Use `turn/steer` to append additional user input to the currently active regular turn. This does
+not emit `turn/started` and does not accept turn context overrides.

 ```json
 { "method": "turn/steer", "id": 32, "params": {
@@ -587,7 +587,9 @@ Use `turn/steer` to append additional user input to the currently active turn. T
 { "id": 32, "result": { "turnId": "turn_456" } }
 ```

-`expectedTurnId` is required. If there is no active turn (or `expectedTurnId` does not match the active turn), the request fails with an `invalid request` error.
+`expectedTurnId` is required. If there is no active turn, `expectedTurnId` does not match the
+active turn, or the active turn kind does not accept same-turn steering (for example review or
+manual compaction), the request fails with an `invalid request` error.

 ### Example: Request a code review

@@ -825,7 +827,8 @@ The fuzzy file search session API emits per-query notifications:
 The thread realtime API emits thread-scoped notifications for session lifecycle and streaming media:

 - `thread/realtime/started` — `{ threadId, sessionId }` once realtime starts for the thread (experimental).
- `thread/realtime/itemAdded` — `{ threadId, item }` for non-audio realtime items (experimental). `item` is forwarded as raw JSON while the upstream websocket item schema remains unstable.
+- `thread/realtime/itemAdded` — `{ threadId, item }` for raw non-audio realtime items that do not have a dedicated typed app-server notification, including `handoff_request` (experimental). `item` is forwarded as raw JSON while the upstream websocket item schema remains unstable.
+- `thread/realtime/transcriptUpdated` — `{ threadId, role, text }` whenever realtime transcript text changes (experimental). This forwards the live transcript delta from that realtime event, not the full accumulated transcript.
 - `thread/realtime/outputAudio/delta` — `{ threadId, audio }` for streamed output audio chunks (experimental). `audio` uses camelCase fields (`data`, `sampleRate`, `numChannels`, `samplesPerChannel`).
 - `thread/realtime/error` — `{ threadId, message }` when realtime encounters a transport or backend error (experimental).
 - `thread/realtime/closed` — `{ threadId, reason }` when the realtime transport closes (experimental).
@@ -917,6 +920,8 @@ There are additional item-specific events:
 - `ResponseStreamConnectionFailed { httpStatusCode? }`: failure to connect to the response SSE stream
 - `ResponseStreamDisconnected { httpStatusCode? }`: disconnect of the response SSE stream in the middle of a turn before completion
 - `ResponseTooManyFailedAttempts { httpStatusCode? }`
+- `ActiveTurnNotSteerable { turnKind }`: `turn/start` or `turn/steer` was submitted while the
+  current active turn was not steerable, for example `/review` or manual `/compact`
 - `BadRequest`
 - `Unauthorized`
 - `SandboxError`
@@ -1140,14 +1145,29 @@ The server also emits `skills/changed` notifications when watched local skill fi
 }
 ```

-To enable or disable a skill by path:
+To enable or disable a skill by absolute path:

 ```json
 {
  "method": "skills/config/write",
  "id": 26,
  "params": {
-    "path": "/Users/me/.codex/skills/skill-creator/SKILL.md",
+    "path": "/Users/alice/.codex/skills/skill-creator/SKILL.md",
+    "name": null,
+    "enabled": false
+  }
+}
+```
+
+To enable or disable a skill by name:
+
+```json
+{
+  "method": "skills/config/write",
+  "id": 27,
+  "params": {
+    "path": null,
+    "name": "github:yeet",
    "enabled": false
  }
 }
@@ -86,6 +86,7 @@ use codex_app_server_protocol::ThreadRealtimeErrorNotification;
 use codex_app_server_protocol::ThreadRealtimeItemAddedNotification;
 use codex_app_server_protocol::ThreadRealtimeOutputAudioDeltaNotification;
 use codex_app_server_protocol::ThreadRealtimeStartedNotification;
+use codex_app_server_protocol::ThreadRealtimeTranscriptUpdatedNotification;
 use codex_app_server_protocol::ThreadRollbackResponse;
 use codex_app_server_protocol::ThreadTokenUsage;
 use codex_app_server_protocol::ThreadTokenUsageUpdatedNotification;
@@ -397,8 +398,30 @@ pub(crate) async fn apply_bespoke_event_handling(
                            ))
                            .await;
                    }
-                    RealtimeEvent::InputTranscriptDelta(_) => {}
-                    RealtimeEvent::OutputTranscriptDelta(_) => {}
+                    RealtimeEvent::InputTranscriptDelta(event) => {
+                        let notification = ThreadRealtimeTranscriptUpdatedNotification {
+                            thread_id: conversation_id.to_string(),
+                            role: "user".to_string(),
+                            text: event.delta,
+                        };
+                        outgoing
+                            .send_server_notification(
+                                ServerNotification::ThreadRealtimeTranscriptUpdated(notification),
+                            )
+                            .await;
+                    }
+                    RealtimeEvent::OutputTranscriptDelta(event) => {
+                        let notification = ThreadRealtimeTranscriptUpdatedNotification {
+                            thread_id: conversation_id.to_string(),
+                            role: "assistant".to_string(),
+                            text: event.delta,
+                        };
+                        outgoing
+                            .send_server_notification(
+                                ServerNotification::ThreadRealtimeTranscriptUpdated(notification),
+                            )
+                            .await;
+                    }
                    RealtimeEvent::AudioOut(audio) => {
                        let notification = ThreadRealtimeOutputAudioDeltaNotification {
                            thread_id: conversation_id.to_string(),
@@ -32,6 +32,7 @@ use codex_app_server_protocol::CancelLoginAccountParams;
 use codex_app_server_protocol::CancelLoginAccountResponse;
 use codex_app_server_protocol::CancelLoginAccountStatus;
 use codex_app_server_protocol::ClientRequest;
+use codex_app_server_protocol::CodexErrorInfo as AppServerCodexErrorInfo;
 use codex_app_server_protocol::CollaborationModeListParams;
 use codex_app_server_protocol::CollaborationModeListResponse;
 use codex_app_server_protocol::CommandExecParams;
@@ -161,6 +162,7 @@ use codex_app_server_protocol::ThreadUnsubscribeParams;
 use codex_app_server_protocol::ThreadUnsubscribeResponse;
 use codex_app_server_protocol::ThreadUnsubscribeStatus;
 use codex_app_server_protocol::Turn;
+use codex_app_server_protocol::TurnError;
 use codex_app_server_protocol::TurnInterruptParams;
 use codex_app_server_protocol::TurnStartParams;
 use codex_app_server_protocol::TurnStartResponse;
@@ -191,7 +193,6 @@ use codex_core::ThreadSortKey as CoreThreadSortKey;
 use codex_core::auth::AuthMode as CoreAuthMode;
 use codex_core::auth::CLIENT_ID;
 use codex_core::auth::login_with_api_key;
-use codex_core::auth::login_with_chatgpt_auth_tokens;
 use codex_core::config::Config;
 use codex_core::config::ConfigOverrides;
 use codex_core::config::NetworkProxyAuditMetadata;
@@ -204,12 +205,10 @@ use codex_core::config_loader::CloudRequirementsLoader;
 use codex_core::default_client::set_default_client_residency_requirement;
 use codex_core::error::CodexErr;
 use codex_core::error::Result as CodexResult;
+use codex_core::exec::ExecCapturePolicy;
 use codex_core::exec::ExecExpiration;
 use codex_core::exec::ExecParams;
 use codex_core::exec_env::create_env;
-use codex_core::features::FEATURES;
-use codex_core::features::Feature;
-use codex_core::features::Stage;
 use codex_core::find_archived_thread_path_by_id_str;
 use codex_core::find_thread_name_by_id;
 use codex_core::find_thread_names_by_ids;
@@ -229,6 +228,7 @@ use codex_core::plugins::PluginInstallRequest;
 use codex_core::plugins::PluginReadRequest;
 use codex_core::plugins::PluginUninstallError as CorePluginUninstallError;
 use codex_core::plugins::load_plugin_apps;
+use codex_core::plugins::load_plugin_mcp_servers;
 use codex_core::read_head_for_summary;
 use codex_core::read_session_meta_line;
 use codex_core::rollout_date_parts;
@@ -239,9 +239,13 @@ use codex_core::state_db::reconcile_rollout;
 use codex_core::windows_sandbox::WindowsSandboxLevelExt;
 use codex_core::windows_sandbox::WindowsSandboxSetupMode as CoreWindowsSandboxSetupMode;
 use codex_core::windows_sandbox::WindowsSandboxSetupRequest;
+use codex_features::FEATURES;
+use codex_features::Feature;
+use codex_features::Stage;
 use codex_feedback::CodexFeedback;
 use codex_login::ServerOptions as LoginServerOptions;
 use codex_login::ShutdownHandle;
+use codex_login::auth::login_with_chatgpt_auth_tokens;
 use codex_login::run_login_server;
 use codex_protocol::ThreadId;
 use codex_protocol::config_types::CollaborationMode;
@@ -311,6 +315,7 @@ use codex_app_server_protocol::ServerRequest;

 mod apps_list_helpers;
 mod plugin_app_helpers;
+mod plugin_mcp_oauth;

 use crate::filters::compute_source_filters;
 use crate::filters::source_kind_matches;
@@ -422,16 +427,16 @@ impl CodexMessageProcessor {
        self.thread_manager.skills_manager().clear_cache();
    }

-    pub(crate) async fn maybe_start_curated_repo_sync_for_latest_config(&self) {
+    pub(crate) async fn maybe_start_plugin_startup_tasks_for_latest_config(&self) {
        match self.load_latest_config(/*fallback_cwd*/ None).await {
            Ok(config) => self
                .thread_manager
                .plugins_manager()
-                .maybe_start_curated_repo_sync_for_config(
+                .maybe_start_plugin_startup_tasks_for_config(
                    &config,
                    self.thread_manager.auth_manager(),
                ),
-            Err(err) => warn!("failed to load latest config for curated plugin sync: {err:?}"),
+            Err(err) => warn!("failed to load latest config for plugin startup tasks: {err:?}"),
        }
    }

@@ -1411,7 +1416,7 @@ impl CodexMessageProcessor {
        let account = match self.auth_manager.auth_cached() {
            Some(auth) => match auth.auth_mode() {
                CoreAuthMode::ApiKey => Some(Account::ApiKey {}),
-                CoreAuthMode::Chatgpt => {
+                CoreAuthMode::Chatgpt | CoreAuthMode::ChatgptAuthTokens => {
                    let email = auth.get_account_email();
                    let plan_type = auth.account_plan_type();

@@ -1672,11 +1677,17 @@ impl CodexMessageProcessor {
                None => ExecExpiration::DefaultTimeout,
            }
        };
+        let capture_policy = if disable_output_cap {
+            ExecCapturePolicy::FullBuffer
+        } else {
+            ExecCapturePolicy::ShellTool
+        };
        let sandbox_cwd = self.config.cwd.clone();
        let exec_params = ExecParams {
            command,
            cwd: cwd.clone(),
            expiration,
+            capture_policy,
            env,
            network: started_network_proxy
                .as_ref()
@@ -4587,20 +4598,28 @@ impl CodexMessageProcessor {
            }
        };

-        let configured_servers = self
-            .thread_manager
-            .mcp_manager()
-            .configured_servers(&config);
+        if let Err(error) = self.queue_mcp_server_refresh_for_config(&config).await {
+            self.outgoing.send_error(request_id, error).await;
+            return;
+        }
+
+        let response = McpServerRefreshResponse {};
+        self.outgoing.send_response(request_id, response).await;
+    }
+
+    async fn queue_mcp_server_refresh_for_config(
+        &self,
+        config: &Config,
+    ) -> Result<(), JSONRPCErrorError> {
+        let configured_servers = self.thread_manager.mcp_manager().configured_servers(config);
        let mcp_servers = match serde_json::to_value(configured_servers) {
            Ok(value) => value,
            Err(err) => {
-                let error = JSONRPCErrorError {
+                return Err(JSONRPCErrorError {
                    code: INTERNAL_ERROR_CODE,
                    message: format!("failed to serialize MCP servers: {err}"),
                    data: None,
-                };
-                self.outgoing.send_error(request_id, error).await;
-                return;
+                });
            }
        };

@@ -4608,15 +4627,13 @@ impl CodexMessageProcessor {
            match serde_json::to_value(config.mcp_oauth_credentials_store_mode) {
                Ok(value) => value,
                Err(err) => {
-                    let error = JSONRPCErrorError {
+                    return Err(JSONRPCErrorError {
                        code: INTERNAL_ERROR_CODE,
                        message: format!(
                            "failed to serialize MCP OAuth credentials store mode: {err}"
                        ),
                        data: None,
-                    };
-                    self.outgoing.send_error(request_id, error).await;
-                    return;
+                    });
                }
            };

@@ -4629,8 +4646,7 @@ impl CodexMessageProcessor {
        // active turn to avoid work for threads that never resume.
        let thread_manager = Arc::clone(&self.thread_manager);
        thread_manager.refresh_mcp_servers(refresh_config).await;
-        let response = McpServerRefreshResponse {};
-        self.outgoing.send_response(request_id, response).await;
+        Ok(())
    }

    async fn mcp_server_oauth_login(
@@ -5475,7 +5491,7 @@ impl CodexMessageProcessor {

        if force_remote_sync {
            match plugins_manager
-                .sync_plugins_from_remote(&config, auth.as_ref())
+                .sync_plugins_from_remote(&config, auth.as_ref(), /*additive_only*/ false)
                .await
            {
                Ok(sync_result) => {
@@ -5656,7 +5672,7 @@ impl CodexMessageProcessor {
                interface: outcome.plugin.interface.map(plugin_interface_to_info),
            },
            description: outcome.plugin.description,
-            skills: plugin_skills_to_info(&visible_skills),
+            skills: plugin_skills_to_info(&visible_skills, &outcome.plugin.disabled_skill_paths),
            apps: app_summaries,
            mcp_servers: outcome.plugin.mcp_server_names,
        };
@@ -5671,8 +5687,30 @@ impl CodexMessageProcessor {
        request_id: ConnectionRequestId,
        params: SkillsConfigWriteParams,
    ) {
-        let SkillsConfigWriteParams { path, enabled } = params;
-        let edits = vec![ConfigEdit::SetSkillConfig { path, enabled }];
+        let SkillsConfigWriteParams {
+            path,
+            name,
+            enabled,
+        } = params;
+        let edit = match (path, name) {
+            (Some(path), None) => ConfigEdit::SetSkillConfig {
+                path: path.into_path_buf(),
+                enabled,
+            },
+            (None, Some(name)) if !name.trim().is_empty() => {
+                ConfigEdit::SetSkillConfigByName { name, enabled }
+            }
+            _ => {
+                let error = JSONRPCErrorError {
+                    code: INVALID_PARAMS_ERROR_CODE,
+                    message: "skills/config/write requires exactly one of path or name".to_string(),
+                    data: None,
+                };
+                self.outgoing.send_error(request_id, error).await;
+                return;
+            }
+        };
+        let edits = vec![edit];
        let result = ConfigEditsBuilder::new(&self.config.codex_home)
            .with_edits(edits)
            .apply()
@@ -5680,6 +5718,7 @@ impl CodexMessageProcessor {

        match result {
            Ok(()) => {
+                self.thread_manager.plugins_manager().clear_cache();
                self.thread_manager.skills_manager().clear_cache();
                self.outgoing
                    .send_response(
@@ -5742,6 +5781,22 @@ impl CodexMessageProcessor {
                        self.config.as_ref().clone()
                    }
                };
+
+                self.clear_plugin_related_caches();
+
+                let plugin_mcp_servers = load_plugin_mcp_servers(result.installed_path.as_path());
+
+                if !plugin_mcp_servers.is_empty() {
+                    if let Err(err) = self.queue_mcp_server_refresh_for_config(&config).await {
+                        warn!(
+                            plugin = result.plugin_id.as_key(),
+                            "failed to queue MCP refresh after plugin install: {err:?}"
+                        );
+                    }
+                    self.start_plugin_mcp_oauth_logins(&config, plugin_mcp_servers)
+                        .await;
+                }
+
                let plugin_apps = load_plugin_apps(result.installed_path.as_path());
                let apps_needing_auth = if plugin_apps.is_empty()
                    || !config.features.apps_enabled(Some(&self.auth_manager)).await
@@ -5802,7 +5857,6 @@ impl CodexMessageProcessor {
                    )
                };

-                self.clear_plugin_related_caches();
                self.outgoing
                    .send_response(
                        request_id,
@@ -6102,24 +6156,57 @@ impl CodexMessageProcessor {
                self.outgoing.send_response(request_id, response).await;
            }
            Err(err) => {
-                let (code, message) = match err {
+                let (code, message, data) = match err {
                    SteerInputError::NoActiveTurn(_) => (
                        INVALID_REQUEST_ERROR_CODE,
                        "no active turn to steer".to_string(),
+                        None,
                    ),
                    SteerInputError::ExpectedTurnMismatch { expected, actual } => (
                        INVALID_REQUEST_ERROR_CODE,
                        format!("expected active turn id `{expected}` but found `{actual}`"),
+                        None,
                    ),
+                    SteerInputError::ActiveTurnNotSteerable { turn_kind } => {
+                        let message = match turn_kind {
+                            codex_protocol::protocol::NonSteerableTurnKind::Review => {
+                                "cannot steer a review turn".to_string()
+                            }
+                            codex_protocol::protocol::NonSteerableTurnKind::Compact => {
+                                "cannot steer a compact turn".to_string()
+                            }
+                        };
+                        let error = TurnError {
+                            message: message.clone(),
+                            codex_error_info: Some(
+                                AppServerCodexErrorInfo::ActiveTurnNotSteerable {
+                                    turn_kind: turn_kind.into(),
+                                },
+                            ),
+                            additional_details: None,
+                        };
+                        let data = match serde_json::to_value(error) {
+                            Ok(data) => Some(data),
+                            Err(error) => {
+                                tracing::error!(
+                                    ?error,
+                                    "failed to serialize active-turn-not-steerable turn error"
+                                );
+                                None
+                            }
+                        };
+                        (INVALID_REQUEST_ERROR_CODE, message, data)
+                    }
                    SteerInputError::EmptyInput => (
                        INVALID_REQUEST_ERROR_CODE,
                        "input must not be empty".to_string(),
+                        None,
                    ),
                };
                let error = JSONRPCErrorError {
                    code,
                    message,
-                    data: None,
+                    data,
                };
                self.outgoing.send_error(request_id, error).await;
            }
@@ -7605,7 +7692,10 @@ fn skills_to_info(
        .collect()
 }

-fn plugin_skills_to_info(skills: &[codex_core::skills::SkillMetadata]) -> Vec<SkillSummary> {
+fn plugin_skills_to_info(
+    skills: &[codex_core::skills::SkillMetadata],
+    disabled_skill_paths: &std::collections::HashSet<PathBuf>,
+) -> Vec<SkillSummary> {
    skills
        .iter()
        .map(|skill| SkillSummary {
@@ -7623,6 +7713,7 @@ fn plugin_skills_to_info(skills: &[codex_core::skills::SkillMetadata]) -> Vec<Sk
                }
            }),
            path: skill.path_to_skills_md.clone(),
+            enabled: !disabled_skill_paths.contains(&skill.path_to_skills_md),
        })
        .collect()
 }
@@ -8211,6 +8302,7 @@ fn with_thread_spawn_agent_metadata(
            codex_protocol::protocol::SubAgentSource::ThreadSpawn {
                parent_thread_id,
                depth,
+                agent_path,
                agent_nickname: existing_agent_nickname,
                agent_role: existing_agent_role,
            },
@@ -8218,6 +8310,7 @@ fn with_thread_spawn_agent_metadata(
            codex_protocol::protocol::SubAgentSource::ThreadSpawn {
                parent_thread_id,
                depth,
+                agent_path,
                agent_nickname: agent_nickname.or(existing_agent_nickname),
                agent_role: agent_role.or(existing_agent_role),
            },
@@ -8764,6 +8857,7 @@ mod tests {
            source: SessionSource::SubAgent(SubAgentSource::ThreadSpawn {
                parent_thread_id,
                depth: 1,
+                agent_path: None,
                agent_nickname: None,
                agent_role: None,
            }),
@@ -8856,6 +8950,7 @@ mod tests {
            serde_json::to_string(&SessionSource::SubAgent(SubAgentSource::ThreadSpawn {
                parent_thread_id: ThreadId::from_string("ad7f0408-99b8-4f6e-a46f-bd0eec433370")?,
                depth: 1,
+                agent_path: None,
                agent_nickname: None,
                agent_role: None,
            }))?;
@@ -0,0 +1,95 @@
+use std::collections::HashMap;
+use std::sync::Arc;
+
+use codex_app_server_protocol::McpServerOauthLoginCompletedNotification;
+use codex_app_server_protocol::ServerNotification;
+use codex_core::config::Config;
+use codex_core::config::types::McpServerConfig;
+use codex_core::mcp::auth::McpOAuthLoginSupport;
+use codex_core::mcp::auth::oauth_login_support;
+use codex_core::mcp::auth::resolve_oauth_scopes;
+use codex_core::mcp::auth::should_retry_without_scopes;
+use codex_rmcp_client::perform_oauth_login;
+use tracing::warn;
+
+use super::CodexMessageProcessor;
+
+impl CodexMessageProcessor {
+    pub(super) async fn start_plugin_mcp_oauth_logins(
+        &self,
+        config: &Config,
+        plugin_mcp_servers: HashMap<String, McpServerConfig>,
+    ) {
+        for (name, server) in plugin_mcp_servers {
+            let oauth_config = match oauth_login_support(&server.transport).await {
+                McpOAuthLoginSupport::Supported(config) => config,
+                McpOAuthLoginSupport::Unsupported => continue,
+                McpOAuthLoginSupport::Unknown(err) => {
+                    warn!(
+                        "MCP server may or may not require login for plugin install {name}: {err}"
+                    );
+                    continue;
+                }
+            };
+
+            let resolved_scopes = resolve_oauth_scopes(
+                /*explicit_scopes*/ None,
+                server.scopes.clone(),
+                oauth_config.discovered_scopes.clone(),
+            );
+
+            let store_mode = config.mcp_oauth_credentials_store_mode;
+            let callback_port = config.mcp_oauth_callback_port;
+            let callback_url = config.mcp_oauth_callback_url.clone();
+            let outgoing = Arc::clone(&self.outgoing);
+            let notification_name = name.clone();
+
+            tokio::spawn(async move {
+                let first_attempt = perform_oauth_login(
+                    &name,
+                    &oauth_config.url,
+                    store_mode,
+                    oauth_config.http_headers.clone(),
+                    oauth_config.env_http_headers.clone(),
+                    &resolved_scopes.scopes,
+                    server.oauth_resource.as_deref(),
+                    callback_port,
+                    callback_url.as_deref(),
+                )
+                .await;
+
+                let final_result = match first_attempt {
+                    Err(err) if should_retry_without_scopes(&resolved_scopes, &err) => {
+                        perform_oauth_login(
+                            &name,
+                            &oauth_config.url,
+                            store_mode,
+                            oauth_config.http_headers,
+                            oauth_config.env_http_headers,
+                            &[],
+                            server.oauth_resource.as_deref(),
+                            callback_port,
+                            callback_url.as_deref(),
+                        )
+                        .await
+                    }
+                    result => result,
+                };
+
+                let (success, error) = match final_result {
+                    Ok(()) => (true, None),
+                    Err(err) => (false, Some(err.to_string())),
+                };
+
+                let notification = ServerNotification::McpServerOauthLoginCompleted(
+                    McpServerOauthLoginCompletedNotification {
+                        name: notification_name,
+                        success,
+                        error,
+                    },
+                );
+                outgoing.send_server_notification(notification).await;
+            });
+        }
+    }
+}
@@ -733,6 +733,7 @@ mod tests {
            env: HashMap::new(),
            network: None,
            expiration: ExecExpiration::DefaultTimeout,
+            capture_policy: codex_core::exec::ExecCapturePolicy::ShellTool,
            sandbox: SandboxType::WindowsRestrictedToken,
            windows_sandbox_level: WindowsSandboxLevel::Disabled,
            windows_sandbox_private_desktop: false,
@@ -845,6 +846,7 @@ mod tests {
                    env: HashMap::new(),
                    network: None,
                    expiration: ExecExpiration::Cancellation(CancellationToken::new()),
+                    capture_policy: codex_core::exec::ExecCapturePolicy::ShellTool,
                    sandbox: SandboxType::None,
                    windows_sandbox_level: WindowsSandboxLevel::Disabled,
                    windows_sandbox_private_desktop: false,
@@ -133,6 +133,7 @@ mod tests {
        let spawn = CoreSessionSource::SubAgent(CoreSubAgentSource::ThreadSpawn {
            parent_thread_id,
            depth: 1,
+            agent_path: None,
            agent_nickname: None,
            agent_role: None,
        });
@@ -34,7 +34,7 @@ pub(crate) struct FsApi {
 impl Default for FsApi {
    fn default() -> Self {
        Self {
-            file_system: Arc::new(Environment::default().get_filesystem()),
+            file_system: Environment::default().get_filesystem(),
        }
    }
 }
@@ -479,7 +479,7 @@ pub async fn run_main_with_transport(
            range: None,
        });
    }
-    if let Some(warning) = codex_core::config::missing_system_bwrap_warning() {
+    if let Some(warning) = codex_core::config::system_bwrap_warning() {
        config_warnings.push(ConfigWarningNotification {
            summary: warning,
            details: None,
@@ -50,20 +50,22 @@ use codex_arg0::Arg0DispatchPaths;
 use codex_core::AnalyticsEventsClient;
 use codex_core::AuthManager;
 use codex_core::ThreadManager;
-use codex_core::auth::ExternalAuthRefreshContext;
-use codex_core::auth::ExternalAuthRefreshReason;
-use codex_core::auth::ExternalAuthRefresher;
-use codex_core::auth::ExternalAuthTokens;
 use codex_core::config::Config;
 use codex_core::config_loader::CloudRequirementsLoader;
 use codex_core::config_loader::LoaderOverrides;
+use codex_core::default_client::DEFAULT_ORIGINATOR;
 use codex_core::default_client::SetOriginatorError;
 use codex_core::default_client::USER_AGENT_SUFFIX;
 use codex_core::default_client::get_codex_user_agent;
 use codex_core::default_client::set_default_client_residency_requirement;
 use codex_core::default_client::set_default_originator;
 use codex_core::models_manager::collaboration_mode_presets::CollaborationModesConfig;
+use codex_features::Feature;
 use codex_feedback::CodexFeedback;
+use codex_login::auth::ExternalAuthRefreshContext;
+use codex_login::auth::ExternalAuthRefreshReason;
+use codex_login::auth::ExternalAuthRefresher;
+use codex_login::auth::ExternalAuthTokens;
 use codex_protocol::ThreadId;
 use codex_protocol::protocol::SessionSource;
 use codex_protocol::protocol::W3cTraceContext;
@@ -77,6 +79,7 @@ use toml::Value as TomlValue;
 use tracing::Instrument;

 const EXTERNAL_AUTH_REFRESH_TIMEOUT: Duration = Duration::from_secs(10);
+const TUI_APP_SERVER_CLIENT_NAME: &str = "codex-tui";

 #[derive(Clone)]
 struct ExternalAuthRefreshBridge {
@@ -212,7 +215,7 @@ impl MessageProcessor {
                    CollaborationModesConfig {
                        default_mode_request_user_input: config
                            .features
-                            .enabled(codex_core::features::Feature::DefaultModeRequestUserInput),
+                            .enabled(Feature::DefaultModeRequestUserInput),
                    },
                ));
                (auth_manager, thread_manager)
@@ -245,7 +248,7 @@ impl MessageProcessor {
        // TODO(xl): Move into PluginManager once this no longer depends on config feature gating.
        thread_manager
            .plugins_manager()
-            .maybe_start_curated_repo_sync_for_config(&config, auth_manager.clone());
+            .maybe_start_plugin_startup_tasks_for_config(&config, auth_manager.clone());
        let config_api = ConfigApi::new(
            config.codex_home.clone(),
            cli_overrides,
@@ -550,7 +553,14 @@ impl MessageProcessor {
                } = params.client_info;
                session.app_server_client_name = Some(name.clone());
                session.client_version = Some(version.clone());
-                if let Err(error) = set_default_originator(name.clone()) {
+                let originator = if name == TUI_APP_SERVER_CLIENT_NAME {
+                    // TODO: Remove this temporary workaround once app-server clients no longer
+                    // need to retain the legacy TUI `codex_cli_rs` originator behavior.
+                    DEFAULT_ORIGINATOR.to_string()
+                } else {
+                    name.clone()
+                };
+                if let Err(error) = set_default_originator(originator) {
                    match error {
                        SetOriginatorError::InvalidHeaderValue => {
                            let error = JSONRPCErrorError {
@@ -789,7 +799,7 @@ impl MessageProcessor {
            Ok(response) => {
                self.codex_message_processor.clear_plugin_related_caches();
                self.codex_message_processor
-                    .maybe_start_curated_repo_sync_for_latest_config()
+                    .maybe_start_plugin_startup_tasks_for_latest_config()
                    .await;
                self.outgoing.send_response(request_id, response).await;
            }
@@ -806,7 +816,7 @@ impl MessageProcessor {
            Ok(response) => {
                self.codex_message_processor.clear_plugin_related_caches();
                self.codex_message_processor
-                    .maybe_start_curated_repo_sync_for_latest_config()
+                    .maybe_start_plugin_startup_tasks_for_latest_config()
                    .await;
                self.outgoing.send_response(request_id, response).await;
            }
@@ -13,6 +13,7 @@ base64 = { workspace = true }
 chrono = { workspace = true }
 codex-app-server-protocol = { workspace = true }
 codex-core = { workspace = true }
+codex-features = { workspace = true }
 codex-protocol = { workspace = true }
 codex-utils-cargo-bin = { workspace = true }
 serde = { workspace = true }
@@ -1,5 +1,5 @@
-use codex_core::features::FEATURES;
-use codex_core::features::Feature;
+use codex_features::FEATURES;
+use codex_features::Feature;
 use std::collections::BTreeMap;
 use std::path::Path;

@@ -79,6 +79,7 @@ pub fn create_fake_rollout_with_source(
        originator: "codex".to_string(),
        cli_version: "0.0.0".to_string(),
        source,
+        agent_path: None,
        agent_nickname: None,
        agent_role: None,
        model_provider: model_provider.map(str::to_string),
@@ -161,6 +162,7 @@ pub fn create_fake_rollout_with_text_elements(
        originator: "codex".to_string(),
        cli_version: "0.0.0".to_string(),
        source: SessionSource::Cli,
+        agent_path: None,
        agent_nickname: None,
        agent_role: None,
        model_provider: model_provider.map(str::to_string),
@@ -10,8 +10,8 @@ use codex_app_server_protocol::ExperimentalFeatureStage;
 use codex_app_server_protocol::JSONRPCResponse;
 use codex_app_server_protocol::RequestId;
 use codex_core::config::ConfigBuilder;
-use codex_core::features::FEATURES;
-use codex_core::features::Stage;
+use codex_features::FEATURES;
+use codex_features::Stage;
 use pretty_assertions::assert_eq;
 use tempfile::TempDir;
 use tokio::time::timeout;
@@ -18,8 +18,8 @@ use codex_app_server_protocol::TurnStartParams;
 use codex_app_server_protocol::TurnStartResponse;
 use codex_app_server_protocol::TurnStatus;
 use codex_app_server_protocol::UserInput as V2UserInput;
-use codex_core::features::FEATURES;
-use codex_core::features::Feature;
+use codex_features::FEATURES;
+use codex_features::Feature;
 use codex_protocol::config_types::CollaborationMode;
 use codex_protocol::config_types::ModeKind;
 use codex_protocol::config_types::Settings;
@@ -529,6 +529,79 @@ async fn plugin_install_filters_disallowed_apps_needing_auth() -> Result<()> {
    Ok(())
 }

+#[tokio::test]
+async fn plugin_install_makes_bundled_mcp_servers_available_to_followup_requests() -> Result<()> {
+    let codex_home = TempDir::new()?;
+    std::fs::write(
+        codex_home.path().join("config.toml"),
+        "[features]\nplugins = true\n",
+    )?;
+    let repo_root = TempDir::new()?;
+    write_plugin_marketplace(
+        repo_root.path(),
+        "debug",
+        "sample-plugin",
+        "./sample-plugin",
+        None,
+        None,
+    )?;
+    write_plugin_source(repo_root.path(), "sample-plugin", &[])?;
+    std::fs::write(
+        repo_root.path().join("sample-plugin/.mcp.json"),
+        r#"{
+  "mcpServers": {
+    "sample-mcp": {
+      "command": "echo"
+    }
+  }
+}"#,
+    )?;
+    let marketplace_path =
+        AbsolutePathBuf::try_from(repo_root.path().join(".agents/plugins/marketplace.json"))?;
+
+    let mut mcp = McpProcess::new(codex_home.path()).await?;
+    timeout(DEFAULT_TIMEOUT, mcp.initialize()).await??;
+
+    let request_id = mcp
+        .send_plugin_install_request(PluginInstallParams {
+            marketplace_path,
+            plugin_name: "sample-plugin".to_string(),
+            force_remote_sync: false,
+        })
+        .await?;
+    let response: JSONRPCResponse = timeout(
+        DEFAULT_TIMEOUT,
+        mcp.read_stream_until_response_message(RequestId::Integer(request_id)),
+    )
+    .await??;
+    let response: PluginInstallResponse = to_response(response)?;
+    assert_eq!(response.apps_needing_auth, Vec::<AppSummary>::new());
+    let config = std::fs::read_to_string(codex_home.path().join("config.toml"))?;
+    assert!(!config.contains("[mcp_servers.sample-mcp]"));
+    assert!(!config.contains("command = \"echo\""));
+
+    let request_id = mcp
+        .send_raw_request(
+            "mcpServer/oauth/login",
+            Some(json!({
+                "name": "sample-mcp",
+            })),
+        )
+        .await?;
+    let err = timeout(
+        DEFAULT_TIMEOUT,
+        mcp.read_stream_until_error_message(RequestId::Integer(request_id)),
+    )
+    .await??;
+
+    assert_eq!(err.error.code, -32600);
+    assert_eq!(
+        err.error.message,
+        "OAuth login is only supported for streamable HTTP servers."
+    );
+    Ok(())
+}
+
 #[derive(Clone)]
 struct AppsServerState {
    response: Arc<StdMutex<serde_json::Value>>,
@@ -25,9 +25,11 @@ use wiremock::ResponseTemplate;
 use wiremock::matchers::header;
 use wiremock::matchers::method;
 use wiremock::matchers::path;
+use wiremock::matchers::query_param;

 const DEFAULT_TIMEOUT: Duration = Duration::from_secs(10);
 const TEST_CURATED_PLUGIN_SHA: &str = "0123456789abcdef0123456789abcdef01234567";
+const STARTUP_REMOTE_PLUGIN_SYNC_MARKER_FILE: &str = ".tmp/app-server-remote-plugin-sync-v1";

 fn write_plugins_enabled_config(codex_home: &std::path::Path) -> std::io::Result<()> {
    std::fs::write(
@@ -677,6 +679,7 @@ async fn plugin_list_force_remote_sync_reconciles_curated_plugin_state() -> Resu
        .await;
    Mock::given(method("GET"))
        .and(path("/backend-api/plugins/featured"))
+        .and(query_param("platform", "codex"))
        .and(header("authorization", "Bearer chatgpt-token"))
        .and(header("chatgpt-account-id", "account-123"))
        .respond_with(
@@ -755,6 +758,92 @@ async fn plugin_list_force_remote_sync_reconciles_curated_plugin_state() -> Resu
    Ok(())
 }

+#[tokio::test]
+async fn app_server_startup_remote_plugin_sync_runs_once() -> Result<()> {
+    let codex_home = TempDir::new()?;
+    let server = MockServer::start().await;
+    write_plugin_sync_config(codex_home.path(), &format!("{}/backend-api/", server.uri()))?;
+    write_chatgpt_auth(
+        codex_home.path(),
+        ChatGptAuthFixture::new("chatgpt-token")
+            .account_id("account-123")
+            .chatgpt_user_id("user-123")
+            .chatgpt_account_id("account-123"),
+        AuthCredentialsStoreMode::File,
+    )?;
+    write_openai_curated_marketplace(codex_home.path(), &["linear"])?;
+
+    Mock::given(method("GET"))
+        .and(path("/backend-api/plugins/list"))
+        .and(header("authorization", "Bearer chatgpt-token"))
+        .and(header("chatgpt-account-id", "account-123"))
+        .respond_with(ResponseTemplate::new(200).set_body_string(
+            r#"[
+  {"id":"1","name":"linear","marketplace_name":"openai-curated","version":"1.0.0","enabled":true}
+]"#,
+        ))
+        .mount(&server)
+        .await;
+    Mock::given(method("GET"))
+        .and(path("/backend-api/plugins/featured"))
+        .and(query_param("platform", "codex"))
+        .and(header("authorization", "Bearer chatgpt-token"))
+        .and(header("chatgpt-account-id", "account-123"))
+        .respond_with(ResponseTemplate::new(200).set_body_string(r#"["linear@openai-curated"]"#))
+        .mount(&server)
+        .await;
+
+    let marker_path = codex_home
+        .path()
+        .join(STARTUP_REMOTE_PLUGIN_SYNC_MARKER_FILE);
+
+    {
+        let mut mcp = McpProcess::new(codex_home.path()).await?;
+        timeout(DEFAULT_TIMEOUT, mcp.initialize()).await??;
+
+        wait_for_path_exists(&marker_path).await?;
+        wait_for_remote_plugin_request_count(&server, "/plugins/list", 1).await?;
+        let request_id = mcp
+            .send_plugin_list_request(PluginListParams {
+                cwds: None,
+                force_remote_sync: false,
+            })
+            .await?;
+        let response: JSONRPCResponse = timeout(
+            DEFAULT_TIMEOUT,
+            mcp.read_stream_until_response_message(RequestId::Integer(request_id)),
+        )
+        .await??;
+        let response: PluginListResponse = to_response(response)?;
+        let curated_marketplace = response
+            .marketplaces
+            .into_iter()
+            .find(|marketplace| marketplace.name == "openai-curated")
+            .expect("expected openai-curated marketplace entry");
+        assert_eq!(
+            curated_marketplace
+                .plugins
+                .into_iter()
+                .map(|plugin| (plugin.id, plugin.installed, plugin.enabled))
+                .collect::<Vec<_>>(),
+            vec![("linear@openai-curated".to_string(), true, true)]
+        );
+        wait_for_remote_plugin_request_count(&server, "/plugins/list", 1).await?;
+    }
+
+    let config = std::fs::read_to_string(codex_home.path().join("config.toml"))?;
+    assert!(config.contains(r#"[plugins."linear@openai-curated"]"#));
+
+    {
+        let mut mcp = McpProcess::new(codex_home.path()).await?;
+        timeout(DEFAULT_TIMEOUT, mcp.initialize()).await??;
+    }
+
+    tokio::time::sleep(Duration::from_millis(250)).await;
+    wait_for_remote_plugin_request_count(&server, "/plugins/list", 1).await?;
+    Ok(())
+}
+
 #[tokio::test]
 async fn plugin_list_fetches_featured_plugin_ids_without_chatgpt_auth() -> Result<()> {
    let codex_home = TempDir::new()?;
@@ -764,6 +853,7 @@ async fn plugin_list_fetches_featured_plugin_ids_without_chatgpt_auth() -> Resul

    Mock::given(method("GET"))
        .and(path("/backend-api/plugins/featured"))
+        .and(query_param("platform", "codex"))
        .respond_with(ResponseTemplate::new(200).set_body_string(r#"["linear@openai-curated"]"#))
        .mount(&server)
        .await;
@@ -802,6 +892,7 @@ async fn plugin_list_uses_warmed_featured_plugin_ids_cache_on_first_request() ->

    Mock::given(method("GET"))
        .and(path("/backend-api/plugins/featured"))
+        .and(query_param("platform", "codex"))
        .respond_with(ResponseTemplate::new(200).set_body_string(r#"["linear@openai-curated"]"#))
        .expect(1)
        .mount(&server)
@@ -836,24 +927,32 @@ async fn plugin_list_uses_warmed_featured_plugin_ids_cache_on_first_request() ->
 async fn wait_for_featured_plugin_request_count(
    server: &MockServer,
    expected_count: usize,
+) -> Result<()> {
+    wait_for_remote_plugin_request_count(server, "/plugins/featured", expected_count).await
+}
+
+async fn wait_for_remote_plugin_request_count(
+    server: &MockServer,
+    path_suffix: &str,
+    expected_count: usize,
 ) -> Result<()> {
    timeout(DEFAULT_TIMEOUT, async {
        loop {
            let Some(requests) = server.received_requests().await else {
                bail!("wiremock did not record requests");
            };
-            let featured_request_count = requests
+            let request_count = requests
                .iter()
                .filter(|request| {
-                    request.method == "GET" && request.url.path().ends_with("/plugins/featured")
+                    request.method == "GET" && request.url.path().ends_with(path_suffix)
                })
                .count();
-            if featured_request_count == expected_count {
+            if request_count == expected_count {
                return Ok::<(), anyhow::Error>(());
            }
-            if featured_request_count > expected_count {
+            if request_count > expected_count {
                bail!(
-                    "expected exactly {expected_count} /plugins/featured requests, got {featured_request_count}"
+                    "expected exactly {expected_count} {path_suffix} requests, got {request_count}"
                );
            }
            tokio::time::sleep(Duration::from_millis(10)).await;
@@ -863,6 +962,19 @@ async fn wait_for_featured_plugin_request_count(
    Ok(())
 }

+async fn wait_for_path_exists(path: &std::path::Path) -> Result<()> {
+    timeout(DEFAULT_TIMEOUT, async {
+        loop {
+            if path.exists() {
+                return Ok::<(), anyhow::Error>(());
+            }
+            tokio::time::sleep(Duration::from_millis(10)).await;
+        }
+    })
+    .await??;
+    Ok(())
+}
+
 fn write_installed_plugin(
    codex_home: &TempDir,
    marketplace_name: &str,
@@ -162,6 +162,10 @@ description: Visible only for ChatGPT
        r#"[features]
 plugins = true

+[[skills.config]]
+name = "demo-plugin:thread-summarizer"
+enabled = false
+
 [plugins."demo-plugin@codex-curated"]
 enabled = true
 "#,
@@ -244,6 +248,7 @@ enabled = true
        response.plugin.skills[0].description,
        "Summarize email threads"
    );
+    assert!(!response.plugin.skills[0].enabled);
    assert_eq!(response.plugin.apps.len(), 1);
    assert_eq!(response.plugin.apps[0].id, "gmail");
    assert_eq!(response.plugin.apps[0].name, "gmail");
@@ -21,10 +21,11 @@ use codex_app_server_protocol::ThreadRealtimeStartResponse;
 use codex_app_server_protocol::ThreadRealtimeStartedNotification;
 use codex_app_server_protocol::ThreadRealtimeStopParams;
 use codex_app_server_protocol::ThreadRealtimeStopResponse;
+use codex_app_server_protocol::ThreadRealtimeTranscriptUpdatedNotification;
 use codex_app_server_protocol::ThreadStartParams;
 use codex_app_server_protocol::ThreadStartResponse;
-use codex_core::features::FEATURES;
-use codex_core::features::Feature;
+use codex_features::FEATURES;
+use codex_features::Feature;
 use codex_protocol::protocol::RealtimeConversationVersion;
 use core_test_support::responses::start_websocket_server;
 use core_test_support::skip_if_no_network;
@@ -66,6 +67,24 @@ async fn realtime_conversation_streams_v2_notifications() -> Result<()> {
                    "content": [{ "type": "text", "text": "hi" }]
                }
            }),
+            json!({
+                "type": "conversation.item.input_audio_transcription.delta",
+                "delta": "delegate now"
+            }),
+            json!({
+                "type": "response.output_text.delta",
+                "delta": "working"
+            }),
+            json!({
+                "type": "conversation.item.done",
+                "item": {
+                    "id": "item_2",
+                    "type": "function_call",
+                    "name": "codex",
+                    "call_id": "handoff_1",
+                    "arguments": "{\"input_transcript\":\"delegate now\"}"
+                }
+            }),
            json!({
                "type": "error",
                "message": "upstream boom"
@@ -180,6 +199,40 @@ async fn realtime_conversation_streams_v2_notifications() -> Result<()> {
    assert_eq!(item_added.thread_id, output_audio.thread_id);
    assert_eq!(item_added.item["type"], json!("message"));

+    let first_transcript_update = read_notification::<ThreadRealtimeTranscriptUpdatedNotification>(
+        &mut mcp,
+        "thread/realtime/transcriptUpdated",
+    )
+    .await?;
+    assert_eq!(first_transcript_update.thread_id, output_audio.thread_id);
+    assert_eq!(first_transcript_update.role, "user");
+    assert_eq!(first_transcript_update.text, "delegate now");
+
+    let second_transcript_update =
+        read_notification::<ThreadRealtimeTranscriptUpdatedNotification>(
+            &mut mcp,
+            "thread/realtime/transcriptUpdated",
+        )
+        .await?;
+    assert_eq!(second_transcript_update.thread_id, output_audio.thread_id);
+    assert_eq!(second_transcript_update.role, "assistant");
+    assert_eq!(second_transcript_update.text, "working");
+
+    let handoff_item_added = read_notification::<ThreadRealtimeItemAddedNotification>(
+        &mut mcp,
+        "thread/realtime/itemAdded",
+    )
+    .await?;
+    assert_eq!(handoff_item_added.thread_id, output_audio.thread_id);
+    assert_eq!(handoff_item_added.item["type"], json!("handoff_request"));
+    assert_eq!(handoff_item_added.item["handoff_id"], json!("handoff_1"));
+    assert_eq!(handoff_item_added.item["item_id"], json!("item_2"));
+    assert_eq!(
+        handoff_item_added.item["input_transcript"],
+        json!("delegate now")
+    );
+    assert_eq!(handoff_item_added.item["active_transcript"], json!([]));
+
    let realtime_error =
        read_notification::<ThreadRealtimeErrorNotification>(&mut mcp, "thread/realtime/error")
            .await?;
@@ -661,6 +661,7 @@ async fn thread_list_filters_by_source_kind_subagent_thread_spawn() -> Result<()
        CoreSessionSource::SubAgent(SubAgentSource::ThreadSpawn {
            parent_thread_id,
            depth: 1,
+            agent_path: None,
            agent_nickname: None,
            agent_role: None,
        }),
@@ -724,6 +725,7 @@ async fn thread_list_filters_by_subagent_variant() -> Result<()> {
        CoreSessionSource::SubAgent(SubAgentSource::ThreadSpawn {
            parent_thread_id,
            depth: 1,
+            agent_path: None,
            agent_nickname: None,
            agent_role: None,
        }),
@@ -322,6 +322,7 @@ stream_max_retries = 0
        originator: "codex".to_string(),
        cli_version: "0.0.0".to_string(),
        source: RolloutSessionSource::Cli,
+        agent_path: None,
        agent_nickname: None,
        agent_role: None,
        model_provider: Some("mock_provider".to_string()),
@@ -26,8 +26,8 @@ use codex_app_server_protocol::TurnCompletedNotification;
 use codex_app_server_protocol::TurnStartParams;
 use codex_app_server_protocol::TurnStartResponse;
 use codex_app_server_protocol::UserInput as V2UserInput;
-use codex_core::features::FEATURES;
-use codex_core::features::Feature;
+use codex_features::FEATURES;
+use codex_features::Feature;
 use pretty_assertions::assert_eq;
 use std::collections::BTreeMap;
 use std::path::Path;
@@ -44,9 +44,9 @@ use codex_app_server_protocol::TurnStartedNotification;
 use codex_app_server_protocol::TurnStatus;
 use codex_app_server_protocol::UserInput as V2UserInput;
 use codex_core::config::ConfigToml;
-use codex_core::features::FEATURES;
-use codex_core::features::Feature;
 use codex_core::personality_migration::PERSONALITY_MIGRATION_FILENAME;
+use codex_features::FEATURES;
+use codex_features::Feature;
 use codex_protocol::config_types::CollaborationMode;
 use codex_protocol::config_types::ModeKind;
 use codex_protocol::config_types::Personality;
@@ -30,8 +30,8 @@ use codex_app_server_protocol::TurnStartParams;
 use codex_app_server_protocol::TurnStartResponse;
 use codex_app_server_protocol::TurnStatus;
 use codex_app_server_protocol::UserInput as V2UserInput;
-use codex_core::features::FEATURES;
-use codex_core::features::Feature;
+use codex_features::FEATURES;
+use codex_features::Feature;
 use core_test_support::responses;
 use core_test_support::skip_if_no_network;
 use pretty_assertions::assert_eq;
@@ -30,6 +30,7 @@ codex-config = { workspace = true }
 codex-core = { workspace = true }
 codex-exec = { workspace = true }
 codex-execpolicy = { workspace = true }
+codex-features = { workspace = true }
 codex-login = { workspace = true }
 codex-mcp-server = { workspace = true }
 codex-protocol = { workspace = true }
@@ -170,7 +170,7 @@ async fn run_command_under_sandbox(
                        command_vec,
                        &cwd_clone,
                        env_map,
-                        None,
+                        /*timeout_ms*/ None,
                        config.permissions.windows_sandbox_private_desktop,
                    )
                } else {
@@ -181,7 +181,7 @@ async fn run_command_under_sandbox(
                        command_vec,
                        &cwd_clone,
                        env_map,
-                        None,
+                        /*timeout_ms*/ None,
                        config.permissions.windows_sandbox_private_desktop,
                    )
                }
@@ -251,15 +251,15 @@ async fn run_command_under_sandbox(
                &config.permissions.file_system_sandbox_policy,
                config.permissions.network_sandbox_policy,
                sandbox_policy_cwd.as_path(),
-                false,
+                /*enforce_managed_network*/ false,
                network.as_ref(),
-                None,
+                /*extensions*/ None,
            );
            let network_policy = config.permissions.network_sandbox_policy;
            spawn_debug_sandbox_child(
                PathBuf::from("/usr/bin/sandbox-exec"),
                args,
-                None,
+                /*arg0*/ None,
                cwd,
                network_policy,
                env,
@@ -328,7 +328,7 @@ pub async fn run_login_status(cli_config_overrides: CliConfigOverrides) -> ! {
                    std::process::exit(1);
                }
            },
-            AuthMode::Chatgpt => {
+            AuthMode::Chatgpt | AuthMode::ChatgptAuthTokens => {
                eprintln!("Logged in using ChatGPT");
                std::process::exit(0);
            }
@@ -48,8 +48,9 @@ use codex_core::config::Config;
 use codex_core::config::ConfigOverrides;
 use codex_core::config::edit::ConfigEditsBuilder;
 use codex_core::config::find_codex_home;
-use codex_core::features::Stage;
-use codex_core::features::is_known_feature_key;
+use codex_features::FEATURES;
+use codex_features::Stage;
+use codex_features::is_known_feature_key;
 use codex_terminal_detection::TerminalName;

 /// Codex CLI
@@ -569,8 +570,7 @@ struct FeatureSetArgs {
    feature: String,
 }

-fn stage_str(stage: codex_core::features::Stage) -> &'static str {
-    use codex_core::features::Stage;
+fn stage_str(stage: Stage) -> &'static str {
    match stage {
        Stage::UnderDevelopment => "under development",
        Stage::Experimental { .. } => "experimental",
@@ -886,10 +886,10 @@ async fn cli_main(arg0_paths: Arg0DispatchPaths) -> anyhow::Result<()> {
                    overrides,
                )
                .await?;
-                let mut rows = Vec::with_capacity(codex_core::features::FEATURES.len());
+                let mut rows = Vec::with_capacity(FEATURES.len());
                let mut name_width = 0;
                let mut stage_width = 0;
-                for def in codex_core::features::FEATURES.iter() {
+                for def in FEATURES {
                    let name = def.key;
                    let stage = stage_str(def.stage);
                    let enabled = config.features.enabled(def.id);
@@ -951,10 +951,7 @@ fn maybe_print_under_development_feature_warning(
        return;
    }

-    let Some(spec) = codex_core::features::FEATURES
-        .iter()
-        .find(|spec| spec.key == feature)
-    else {
+    let Some(spec) = FEATURES.iter().find(|spec| spec.key == feature) else {
        return;
    };
    if !matches!(spec.stage, Stage::UnderDevelopment) {
@@ -883,6 +883,24 @@ mod tests {
        account_id: Option<&str>,
        access_token: &str,
        refresh_token: &str,
+    ) -> serde_json::Value {
+        chatgpt_auth_json_with_last_refresh(
+            plan_type,
+            chatgpt_user_id,
+            account_id,
+            access_token,
+            refresh_token,
+            "2025-01-01T00:00:00Z",
+        )
+    }
+
+    fn chatgpt_auth_json_with_last_refresh(
+        plan_type: &str,
+        chatgpt_user_id: Option<&str>,
+        account_id: Option<&str>,
+        access_token: &str,
+        refresh_token: &str,
+        last_refresh: &str,
    ) -> serde_json::Value {
        chatgpt_auth_json_with_mode(
            plan_type,
@@ -890,6 +908,7 @@ mod tests {
            account_id,
            access_token,
            refresh_token,
+            last_refresh,
            None,
        )
    }
@@ -900,6 +919,7 @@ mod tests {
        account_id: Option<&str>,
        access_token: &str,
        refresh_token: &str,
+        last_refresh: &str,
        auth_mode: Option<&str>,
    ) -> serde_json::Value {
        let header = json!({ "alg": "none", "typ": "JWT" });
@@ -925,7 +945,7 @@ mod tests {
                "refresh_token": refresh_token,
                "account_id": account_id,
            },
-            "last_refresh": "2025-01-01T00:00:00Z",
+            "last_refresh": last_refresh,
        });
        if let Some(auth_mode) = auth_mode {
            auth_json["auth_mode"] = serde_json::Value::String(auth_mode.to_string());
@@ -1262,24 +1282,43 @@ enabled = false

    #[tokio::test]
    async fn fetch_cloud_requirements_recovers_after_unauthorized_reload() {
-        let auth = managed_auth_context(
-            "business",
-            Some("user-12345"),
-            Some("account-12345"),
-            "stale-access-token",
-            "test-refresh-token",
-        );
+        let auth_home = tempdir().expect("tempdir");
        write_auth_json(
-            auth._home.path(),
-            chatgpt_auth_json(
+            auth_home.path(),
+            chatgpt_auth_json_with_last_refresh(
+                "business",
+                Some("user-12345"),
+                Some("account-12345"),
+                "stale-access-token",
+                "test-refresh-token",
+                // Keep auth "fresh" so the first request hits unauthorized recovery
+                // instead of AuthManager::auth() proactively reloading from disk.
+                "3025-01-01T00:00:00Z",
+            ),
+        )
+        .expect("write initial auth");
+        let auth_manager = Arc::new(AuthManager::new(
+            auth_home.path().to_path_buf(),
+            false,
+            AuthCredentialsStoreMode::File,
+        ));
+
+        write_auth_json(
+            auth_home.path(),
+            chatgpt_auth_json_with_last_refresh(
                "business",
                Some("user-12345"),
                Some("account-12345"),
                "fresh-access-token",
                "test-refresh-token",
+                "3025-01-01T00:00:00Z",
            ),
        )
        .expect("write refreshed auth");
+        let auth = ManagedAuthContext {
+            _home: auth_home,
+            manager: auth_manager,
+        };

        let fetcher = Arc::new(TokenFetcher {
            expected_token: "fresh-access-token".to_string(),
@@ -1314,24 +1353,41 @@ enabled = false

    #[tokio::test]
    async fn fetch_cloud_requirements_recovers_after_unauthorized_reload_updates_cache_identity() {
-        let auth = managed_auth_context(
-            "business",
-            Some("user-12345"),
-            Some("account-12345"),
-            "stale-access-token",
-            "test-refresh-token",
-        );
+        let auth_home = tempdir().expect("tempdir");
        write_auth_json(
-            auth._home.path(),
-            chatgpt_auth_json(
+            auth_home.path(),
+            chatgpt_auth_json_with_last_refresh(
+                "business",
+                Some("user-12345"),
+                Some("account-12345"),
+                "stale-access-token",
+                "test-refresh-token",
+                "3025-01-01T00:00:00Z",
+            ),
+        )
+        .expect("write initial auth");
+        let auth_manager = Arc::new(AuthManager::new(
+            auth_home.path().to_path_buf(),
+            false,
+            AuthCredentialsStoreMode::File,
+        ));
+
+        write_auth_json(
+            auth_home.path(),
+            chatgpt_auth_json_with_last_refresh(
                "business",
                Some("user-99999"),
                Some("account-12345"),
                "fresh-access-token",
                "test-refresh-token",
+                "3025-01-01T00:00:00Z",
            ),
        )
        .expect("write refreshed auth");
+        let auth = ManagedAuthContext {
+            _home: auth_home,
+            manager: auth_manager,
+        };

        let fetcher = Arc::new(TokenFetcher {
            expected_token: "fresh-access-token".to_string(),
@@ -1432,6 +1488,7 @@ enabled = false
                Some("account-12345"),
                "test-access-token",
                "test-refresh-token",
+                "2025-01-01T00:00:00Z",
                Some("chatgptAuthTokens"),
            ),
        )
@@ -0,0 +1,6 @@
+load("//:defs.bzl", "codex_rust_crate")
+
+codex_rust_crate(
+    name = "code-mode",
+    crate_name = "codex_code_mode",
+)
@@ -0,0 +1,25 @@
+[package]
+edition.workspace = true
+license.workspace = true
+name = "codex-code-mode"
+version.workspace = true
+
+[lib]
+doctest = false
+name = "codex_code_mode"
+path = "src/lib.rs"
+
+[lints]
+workspace = true
+
+[dependencies]
+async-trait = { workspace = true }
+serde = { workspace = true, features = ["derive"] }
+serde_json = { workspace = true }
+tokio = { workspace = true, features = ["macros", "rt", "sync", "time"] }
+tokio-util = { workspace = true, features = ["rt"] }
+tracing = { workspace = true }
+v8 = { workspace = true }
+
+[dev-dependencies]
+pretty_assertions = { workspace = true }
@@ -0,0 +1,555 @@
+use serde::Deserialize;
+use serde::Serialize;
+use serde_json::Value as JsonValue;
+
+use crate::PUBLIC_TOOL_NAME;
+
+const MAX_JS_SAFE_INTEGER: u64 = (1_u64 << 53) - 1;
+const CODE_MODE_ONLY_PREFACE: &str =
+    "Use `exec/wait` tool to run all other tools, do not attempt to use any other tools directly";
+const EXEC_DESCRIPTION_TEMPLATE: &str = r#"## exec
+- Runs raw JavaScript in an isolated context (no Node, no file system, or network access, no console).
+- Send raw JavaScript source text, not JSON, quoted strings, or markdown code fences.
+- You may optionally start the tool input with a first-line pragma like `// @exec: {"yield_time_ms": 10000, "max_output_tokens": 1000}`.
+- `yield_time_ms` asks `exec` to yield early after that many milliseconds if the script is still running.
+- `max_output_tokens` sets the token budget for direct `exec` results. By default the result is truncated to 10000 tokens.
+- All nested tools are available on the global `tools` object, for example `await tools.exec_command(...)`. Tool names are exposed as normalized JavaScript identifiers, for example `await tools.mcp__ologs__get_profile(...)`.
+- Tool methods take either string or object as parameter.
+- They return either a structured value or a string based on the description above.
+
+- Global helpers:
+- `exit()`: Immediately ends the current script successfully (like an early return from the top level).
+- `text(value: string | number | boolean | undefined | null)`: Appends a text item. Non-string values are stringified with `JSON.stringify(...)` when possible.
+- `image(imageUrlOrItem: string | { image_url: string; detail?: "auto" | "low" | "high" | "original" | null })`: Appends an image item. `image_url` can be an HTTPS URL or a base64-encoded `data:` URL.
+- `store(key: string, value: any)`: stores a serializable value under a string key for later `exec` calls in the same session.
+- `load(key: string)`: returns the stored value for a string key, or `undefined` if it is missing.
+- `notify(value: string | number | boolean | undefined | null)`: immediately injects an extra `custom_tool_call_output` for the current `exec` call. Values are stringified like `text(...)`.
+- `ALL_TOOLS`: metadata for the enabled nested tools as `{ name, description }` entries.
+- `yield_control()`: yields the accumulated output to the model immediately while the script keeps running."#;
+const WAIT_DESCRIPTION_TEMPLATE: &str = r#"- Use `wait` only after `exec` returns `Script running with cell ID ...`.
+- `cell_id` identifies the running `exec` cell to resume.
+- `yield_time_ms` controls how long to wait for more output before yielding again. If omitted, `wait` uses its default wait timeout.
+- `max_tokens` limits how much new output this wait call returns.
+- `terminate: true` stops the running cell instead of waiting for more output.
+- `wait` returns only the new output since the last yield, or the final completion or termination result for that cell.
+- If the cell is still running, `wait` may yield again with the same `cell_id`.
+- If the cell has already finished, `wait` returns the completed result and closes the cell."#;
+
+pub const CODE_MODE_PRAGMA_PREFIX: &str = "// @exec:";
+
+#[derive(Clone, Copy, Debug, Deserialize, Eq, PartialEq, Serialize)]
+#[serde(rename_all = "snake_case")]
+pub enum CodeModeToolKind {
+    Function,
+    Freeform,
+}
+
+#[derive(Clone, Debug, PartialEq)]
+pub struct ToolDefinition {
+    pub name: String,
+    pub description: String,
+    pub kind: CodeModeToolKind,
+    pub input_schema: Option<JsonValue>,
+    pub output_schema: Option<JsonValue>,
+}
+
+#[derive(Debug, Default, Deserialize, PartialEq, Eq)]
+#[serde(deny_unknown_fields)]
+struct CodeModeExecPragma {
+    #[serde(default)]
+    yield_time_ms: Option<u64>,
+    #[serde(default)]
+    max_output_tokens: Option<usize>,
+}
+
+#[derive(Debug, PartialEq, Eq)]
+pub struct ParsedExecSource {
+    pub code: String,
+    pub yield_time_ms: Option<u64>,
+    pub max_output_tokens: Option<usize>,
+}
+
+pub fn parse_exec_source(input: &str) -> Result<ParsedExecSource, String> {
+    if input.trim().is_empty() {
+        return Err(
+            "exec expects raw JavaScript source text (non-empty). Provide JS only, optionally with first-line `// @exec: {\"yield_time_ms\": 10000, \"max_output_tokens\": 1000}`.".to_string(),
+        );
+    }
+
+    let mut args = ParsedExecSource {
+        code: input.to_string(),
+        yield_time_ms: None,
+        max_output_tokens: None,
+    };
+
+    let mut lines = input.splitn(2, '\n');
+    let first_line = lines.next().unwrap_or_default();
+    let rest = lines.next().unwrap_or_default();
+    let trimmed = first_line.trim_start();
+    let Some(pragma) = trimmed.strip_prefix(CODE_MODE_PRAGMA_PREFIX) else {
+        return Ok(args);
+    };
+
+    if rest.trim().is_empty() {
+        return Err(
+            "exec pragma must be followed by JavaScript source on subsequent lines".to_string(),
+        );
+    }
+
+    let directive = pragma.trim();
+    if directive.is_empty() {
+        return Err(
+            "exec pragma must be a JSON object with supported fields `yield_time_ms` and `max_output_tokens`"
+                .to_string(),
+        );
+    }
+
+    let value: serde_json::Value = serde_json::from_str(directive).map_err(|err| {
+        format!(
+            "exec pragma must be valid JSON with supported fields `yield_time_ms` and `max_output_tokens`: {err}"
+        )
+    })?;
+    let object = value.as_object().ok_or_else(|| {
+        "exec pragma must be a JSON object with supported fields `yield_time_ms` and `max_output_tokens`"
+            .to_string()
+    })?;
+    for key in object.keys() {
+        match key.as_str() {
+            "yield_time_ms" | "max_output_tokens" => {}
+            _ => {
+                return Err(format!(
+                    "exec pragma only supports `yield_time_ms` and `max_output_tokens`; got `{key}`"
+                ));
+            }
+        }
+    }
+
+    let pragma: CodeModeExecPragma = serde_json::from_value(value).map_err(|err| {
+        format!(
+            "exec pragma fields `yield_time_ms` and `max_output_tokens` must be non-negative safe integers: {err}"
+        )
+    })?;
+    if pragma
+        .yield_time_ms
+        .is_some_and(|yield_time_ms| yield_time_ms > MAX_JS_SAFE_INTEGER)
+    {
+        return Err(
+            "exec pragma field `yield_time_ms` must be a non-negative safe integer".to_string(),
+        );
+    }
+    if pragma.max_output_tokens.is_some_and(|max_output_tokens| {
+        u64::try_from(max_output_tokens)
+            .map(|max_output_tokens| max_output_tokens > MAX_JS_SAFE_INTEGER)
+            .unwrap_or(true)
+    }) {
+        return Err(
+            "exec pragma field `max_output_tokens` must be a non-negative safe integer".to_string(),
+        );
+    }
+
+    args.code = rest.to_string();
+    args.yield_time_ms = pragma.yield_time_ms;
+    args.max_output_tokens = pragma.max_output_tokens;
+    Ok(args)
+}
+
+pub fn is_code_mode_nested_tool(tool_name: &str) -> bool {
+    tool_name != crate::PUBLIC_TOOL_NAME && tool_name != crate::WAIT_TOOL_NAME
+}
+
+pub fn build_exec_tool_description(
+    enabled_tools: &[(String, String)],
+    code_mode_only: bool,
+) -> String {
+    if !code_mode_only {
+        return EXEC_DESCRIPTION_TEMPLATE.to_string();
+    }
+
+    let mut sections = vec![
+        CODE_MODE_ONLY_PREFACE.to_string(),
+        EXEC_DESCRIPTION_TEMPLATE.to_string(),
+    ];
+
+    if !enabled_tools.is_empty() {
+        let nested_tool_reference = enabled_tools
+            .iter()
+            .map(|(name, nested_description)| {
+                let global_name = normalize_code_mode_identifier(name);
+                format!(
+                    "### `{global_name}` (`{name}`)\n{}",
+                    nested_description.trim()
+                )
+            })
+            .collect::<Vec<_>>()
+            .join("\n\n");
+        sections.push(nested_tool_reference);
+    }
+
+    sections.join("\n\n")
+}
+
+pub fn build_wait_tool_description() -> &'static str {
+    WAIT_DESCRIPTION_TEMPLATE
+}
+
+pub fn normalize_code_mode_identifier(tool_key: &str) -> String {
+    let mut identifier = String::new();
+
+    for (index, ch) in tool_key.chars().enumerate() {
+        let is_valid = if index == 0 {
+            ch == '_' || ch == '$' || ch.is_ascii_alphabetic()
+        } else {
+            ch == '_' || ch == '$' || ch.is_ascii_alphanumeric()
+        };
+
+        if is_valid {
+            identifier.push(ch);
+        } else {
+            identifier.push('_');
+        }
+    }
+
+    if identifier.is_empty() {
+        "_".to_string()
+    } else {
+        identifier
+    }
+}
+
+pub fn augment_tool_definition(mut definition: ToolDefinition) -> ToolDefinition {
+    if definition.name != PUBLIC_TOOL_NAME {
+        definition.description = append_code_mode_sample_for_definition(&definition);
+    }
+    definition
+}
+
+pub fn enabled_tool_metadata(definition: &ToolDefinition) -> EnabledToolMetadata {
+    EnabledToolMetadata {
+        tool_name: definition.name.clone(),
+        global_name: normalize_code_mode_identifier(&definition.name),
+        description: definition.description.clone(),
+        kind: definition.kind,
+    }
+}
+
+#[derive(Clone, Debug, Eq, PartialEq, Serialize)]
+pub struct EnabledToolMetadata {
+    pub tool_name: String,
+    pub global_name: String,
+    pub description: String,
+    pub kind: CodeModeToolKind,
+}
+
+pub fn append_code_mode_sample(
+    description: &str,
+    tool_name: &str,
+    input_name: &str,
+    input_type: String,
+    output_type: String,
+) -> String {
+    let declaration = format!(
+        "declare const tools: {{ {} }};",
+        render_code_mode_tool_declaration(tool_name, input_name, input_type, output_type)
+    );
+    format!("{description}\n\nexec tool declaration:\n```ts\n{declaration}\n```")
+}
+
+fn append_code_mode_sample_for_definition(definition: &ToolDefinition) -> String {
+    let input_name = match definition.kind {
+        CodeModeToolKind::Function => "args",
+        CodeModeToolKind::Freeform => "input",
+    };
+    let input_type = match definition.kind {
+        CodeModeToolKind::Function => definition
+            .input_schema
+            .as_ref()
+            .map(render_json_schema_to_typescript)
+            .unwrap_or_else(|| "unknown".to_string()),
+        CodeModeToolKind::Freeform => "string".to_string(),
+    };
+    let output_type = definition
+        .output_schema
+        .as_ref()
+        .map(render_json_schema_to_typescript)
+        .unwrap_or_else(|| "unknown".to_string());
+    append_code_mode_sample(
+        &definition.description,
+        &definition.name,
+        input_name,
+        input_type,
+        output_type,
+    )
+}
+
+fn render_code_mode_tool_declaration(
+    tool_name: &str,
+    input_name: &str,
+    input_type: String,
+    output_type: String,
+) -> String {
+    let tool_name = normalize_code_mode_identifier(tool_name);
+    format!("{tool_name}({input_name}: {input_type}): Promise<{output_type}>;")
+}
+
+pub fn render_json_schema_to_typescript(schema: &JsonValue) -> String {
+    render_json_schema_to_typescript_inner(schema)
+}
+
+fn render_json_schema_to_typescript_inner(schema: &JsonValue) -> String {
+    match schema {
+        JsonValue::Bool(true) => "unknown".to_string(),
+        JsonValue::Bool(false) => "never".to_string(),
+        JsonValue::Object(map) => {
+            if let Some(value) = map.get("const") {
+                return render_json_schema_literal(value);
+            }
+
+            if let Some(values) = map.get("enum").and_then(JsonValue::as_array) {
+                let rendered = values
+                    .iter()
+                    .map(render_json_schema_literal)
+                    .collect::<Vec<_>>();
+                if !rendered.is_empty() {
+                    return rendered.join(" | ");
+                }
+            }
+
+            for key in ["anyOf", "oneOf"] {
+                if let Some(variants) = map.get(key).and_then(JsonValue::as_array) {
+                    let rendered = variants
+                        .iter()
+                        .map(render_json_schema_to_typescript_inner)
+                        .collect::<Vec<_>>();
+                    if !rendered.is_empty() {
+                        return rendered.join(" | ");
+                    }
+                }
+            }
+
+            if let Some(variants) = map.get("allOf").and_then(JsonValue::as_array) {
+                let rendered = variants
+                    .iter()
+                    .map(render_json_schema_to_typescript_inner)
+                    .collect::<Vec<_>>();
+                if !rendered.is_empty() {
+                    return rendered.join(" & ");
+                }
+            }
+
+            if let Some(schema_type) = map.get("type") {
+                if let Some(types) = schema_type.as_array() {
+                    let rendered = types
+                        .iter()
+                        .filter_map(JsonValue::as_str)
+                        .map(|schema_type| render_json_schema_type_keyword(map, schema_type))
+                        .collect::<Vec<_>>();
+                    if !rendered.is_empty() {
+                        return rendered.join(" | ");
+                    }
+                }
+
+                if let Some(schema_type) = schema_type.as_str() {
+                    return render_json_schema_type_keyword(map, schema_type);
+                }
+            }
+
+            if map.contains_key("properties")
+                || map.contains_key("additionalProperties")
+                || map.contains_key("required")
+            {
+                return render_json_schema_object(map);
+            }
+
+            if map.contains_key("items") || map.contains_key("prefixItems") {
+                return render_json_schema_array(map);
+            }
+
+            "unknown".to_string()
+        }
+        _ => "unknown".to_string(),
+    }
+}
+
+fn render_json_schema_type_keyword(
+    map: &serde_json::Map<String, JsonValue>,
+    schema_type: &str,
+) -> String {
+    match schema_type {
+        "string" => "string".to_string(),
+        "number" | "integer" => "number".to_string(),
+        "boolean" => "boolean".to_string(),
+        "null" => "null".to_string(),
+        "array" => render_json_schema_array(map),
+        "object" => render_json_schema_object(map),
+        _ => "unknown".to_string(),
+    }
+}
+
+fn render_json_schema_array(map: &serde_json::Map<String, JsonValue>) -> String {
+    if let Some(items) = map.get("items") {
+        let item_type = render_json_schema_to_typescript_inner(items);
+        return format!("Array<{item_type}>");
+    }
+
+    if let Some(items) = map.get("prefixItems").and_then(JsonValue::as_array) {
+        let item_types = items
+            .iter()
+            .map(render_json_schema_to_typescript_inner)
+            .collect::<Vec<_>>();
+        if !item_types.is_empty() {
+            return format!("[{}]", item_types.join(", "));
+        }
+    }
+
+    "unknown[]".to_string()
+}
+
+fn render_json_schema_object(map: &serde_json::Map<String, JsonValue>) -> String {
+    let required = map
+        .get("required")
+        .and_then(JsonValue::as_array)
+        .map(|items| {
+            items
+                .iter()
+                .filter_map(JsonValue::as_str)
+                .collect::<Vec<_>>()
+        })
+        .unwrap_or_default();
+    let properties = map
+        .get("properties")
+        .and_then(JsonValue::as_object)
+        .cloned()
+        .unwrap_or_default();
+
+    let mut sorted_properties = properties.iter().collect::<Vec<_>>();
+    sorted_properties.sort_unstable_by(|(name_a, _), (name_b, _)| name_a.cmp(name_b));
+    let mut lines = sorted_properties
+        .into_iter()
+        .map(|(name, value)| {
+            let optional = if required.iter().any(|required_name| required_name == name) {
+                ""
+            } else {
+                "?"
+            };
+            let property_name = render_json_schema_property_name(name);
+            let property_type = render_json_schema_to_typescript_inner(value);
+            format!("{property_name}{optional}: {property_type};")
+        })
+        .collect::<Vec<_>>();
+
+    if let Some(additional_properties) = map.get("additionalProperties") {
+        let property_type = match additional_properties {
+            JsonValue::Bool(true) => Some("unknown".to_string()),
+            JsonValue::Bool(false) => None,
+            value => Some(render_json_schema_to_typescript_inner(value)),
+        };
+
+        if let Some(property_type) = property_type {
+            lines.push(format!("[key: string]: {property_type};"));
+        }
+    } else if properties.is_empty() {
+        lines.push("[key: string]: unknown;".to_string());
+    }
+
+    if lines.is_empty() {
+        return "{}".to_string();
+    }
+
+    format!("{{ {} }}", lines.join(" "))
+}
+
+fn render_json_schema_property_name(name: &str) -> String {
+    if normalize_code_mode_identifier(name) == name {
+        name.to_string()
+    } else {
+        serde_json::to_string(name).unwrap_or_else(|_| format!("\"{}\"", name.replace('"', "\\\"")))
+    }
+}
+
+fn render_json_schema_literal(value: &JsonValue) -> String {
+    serde_json::to_string(value).unwrap_or_else(|_| "unknown".to_string())
+}
+
+#[cfg(test)]
+mod tests {
+    use super::CodeModeToolKind;
+    use super::ParsedExecSource;
+    use super::ToolDefinition;
+    use super::augment_tool_definition;
+    use super::build_exec_tool_description;
+    use super::normalize_code_mode_identifier;
+    use super::parse_exec_source;
+    use pretty_assertions::assert_eq;
+    use serde_json::json;
+
+    #[test]
+    fn parse_exec_source_without_pragma() {
+        assert_eq!(
+            parse_exec_source("text('hi')").unwrap(),
+            ParsedExecSource {
+                code: "text('hi')".to_string(),
+                yield_time_ms: None,
+                max_output_tokens: None,
+            }
+        );
+    }
+
+    #[test]
+    fn parse_exec_source_with_pragma() {
+        assert_eq!(
+            parse_exec_source("// @exec: {\"yield_time_ms\": 10}\ntext('hi')").unwrap(),
+            ParsedExecSource {
+                code: "text('hi')".to_string(),
+                yield_time_ms: Some(10),
+                max_output_tokens: None,
+            }
+        );
+    }
+
+    #[test]
+    fn normalize_identifier_rewrites_invalid_characters() {
+        assert_eq!(
+            "mcp__ologs__get_profile",
+            normalize_code_mode_identifier("mcp__ologs__get_profile")
+        );
+        assert_eq!(
+            "hidden_dynamic_tool",
+            normalize_code_mode_identifier("hidden-dynamic-tool")
+        );
+    }
+
+    #[test]
+    fn augment_tool_definition_appends_typed_declaration() {
+        let definition = ToolDefinition {
+            name: "hidden_dynamic_tool".to_string(),
+            description: "Test tool".to_string(),
+            kind: CodeModeToolKind::Function,
+            input_schema: Some(json!({
+                "type": "object",
+                "properties": { "city": { "type": "string" } },
+                "required": ["city"],
+                "additionalProperties": false
+            })),
+            output_schema: Some(json!({
+                "type": "object",
+                "properties": { "ok": { "type": "boolean" } },
+                "required": ["ok"]
+            })),
+        };
+
+        let description = augment_tool_definition(definition).description;
+        assert!(description.contains("declare const tools"));
+        assert!(
+            description.contains(
+                "hidden_dynamic_tool(args: { city: string; }): Promise<{ ok: boolean; }>;"
+            )
+        );
+    }
+
+    #[test]
+    fn code_mode_only_description_includes_nested_tools() {
+        let description =
+            build_exec_tool_description(&[("foo".to_string(), "bar".to_string())], true);
+        assert!(description.contains("### `foo` (`foo`)"));
+    }
+}
@@ -0,0 +1,30 @@
+mod description;
+mod response;
+mod runtime;
+mod service;
+
+pub use description::CODE_MODE_PRAGMA_PREFIX;
+pub use description::CodeModeToolKind;
+pub use description::ToolDefinition;
+pub use description::append_code_mode_sample;
+pub use description::augment_tool_definition;
+pub use description::build_exec_tool_description;
+pub use description::build_wait_tool_description;
+pub use description::is_code_mode_nested_tool;
+pub use description::normalize_code_mode_identifier;
+pub use description::parse_exec_source;
+pub use description::render_json_schema_to_typescript;
+pub use response::FunctionCallOutputContentItem;
+pub use response::ImageDetail;
+pub use runtime::DEFAULT_EXEC_YIELD_TIME_MS;
+pub use runtime::DEFAULT_MAX_OUTPUT_TOKENS_PER_EXEC_CALL;
+pub use runtime::DEFAULT_WAIT_YIELD_TIME_MS;
+pub use runtime::ExecuteRequest;
+pub use runtime::RuntimeResponse;
+pub use runtime::WaitRequest;
+pub use service::CodeModeService;
+pub use service::CodeModeTurnHost;
+pub use service::CodeModeTurnWorker;
+
+pub const PUBLIC_TOOL_NAME: &str = "exec";
+pub const WAIT_TOOL_NAME: &str = "wait";
@@ -0,0 +1,24 @@
+use serde::Deserialize;
+use serde::Serialize;
+
+#[derive(Debug, Clone, Copy, Serialize, Deserialize, PartialEq, Eq)]
+#[serde(rename_all = "lowercase")]
+pub enum ImageDetail {
+    Auto,
+    Low,
+    High,
+    Original,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
+#[serde(tag = "type", rename_all = "snake_case")]
+pub enum FunctionCallOutputContentItem {
+    InputText {
+        text: String,
+    },
+    InputImage {
+        image_url: String,
+        #[serde(default, skip_serializing_if = "Option::is_none")]
+        detail: Option<ImageDetail>,
+    },
+}
@@ -0,0 +1,209 @@
+use crate::response::FunctionCallOutputContentItem;
+
+use super::EXIT_SENTINEL;
+use super::RuntimeEvent;
+use super::RuntimeState;
+use super::value::json_to_v8;
+use super::value::normalize_output_image;
+use super::value::serialize_output_text;
+use super::value::throw_type_error;
+use super::value::v8_value_to_json;
+
+pub(super) fn tool_callback(
+    scope: &mut v8::PinScope<'_, '_>,
+    args: v8::FunctionCallbackArguments,
+    mut retval: v8::ReturnValue<v8::Value>,
+) {
+    let tool_name = args.data().to_rust_string_lossy(scope);
+    let input = if args.length() == 0 {
+        Ok(None)
+    } else {
+        v8_value_to_json(scope, args.get(0))
+    };
+    let input = match input {
+        Ok(input) => input,
+        Err(error_text) => {
+            throw_type_error(scope, &error_text);
+            return;
+        }
+    };
+
+    let Some(resolver) = v8::PromiseResolver::new(scope) else {
+        throw_type_error(scope, "failed to create tool promise");
+        return;
+    };
+    let promise = resolver.get_promise(scope);
+
+    let resolver = v8::Global::new(scope, resolver);
+    let Some(state) = scope.get_slot_mut::<RuntimeState>() else {
+        throw_type_error(scope, "runtime state unavailable");
+        return;
+    };
+    let id = format!("tool-{}", state.next_tool_call_id);
+    state.next_tool_call_id = state.next_tool_call_id.saturating_add(1);
+    let event_tx = state.event_tx.clone();
+    state.pending_tool_calls.insert(id.clone(), resolver);
+    let _ = event_tx.send(RuntimeEvent::ToolCall {
+        id,
+        name: tool_name,
+        input,
+    });
+    retval.set(promise.into());
+}
+
+pub(super) fn text_callback(
+    scope: &mut v8::PinScope<'_, '_>,
+    args: v8::FunctionCallbackArguments,
+    mut retval: v8::ReturnValue<v8::Value>,
+) {
+    let value = if args.length() == 0 {
+        v8::undefined(scope).into()
+    } else {
+        args.get(0)
+    };
+    let text = match serialize_output_text(scope, value) {
+        Ok(text) => text,
+        Err(error_text) => {
+            throw_type_error(scope, &error_text);
+            return;
+        }
+    };
+    if let Some(state) = scope.get_slot::<RuntimeState>() {
+        let _ = state.event_tx.send(RuntimeEvent::ContentItem(
+            FunctionCallOutputContentItem::InputText { text },
+        ));
+    }
+    retval.set(v8::undefined(scope).into());
+}
+
+pub(super) fn image_callback(
+    scope: &mut v8::PinScope<'_, '_>,
+    args: v8::FunctionCallbackArguments,
+    mut retval: v8::ReturnValue<v8::Value>,
+) {
+    let value = if args.length() == 0 {
+        v8::undefined(scope).into()
+    } else {
+        args.get(0)
+    };
+    let image_item = match normalize_output_image(scope, value) {
+        Ok(image_item) => image_item,
+        Err(()) => return,
+    };
+    if let Some(state) = scope.get_slot::<RuntimeState>() {
+        let _ = state.event_tx.send(RuntimeEvent::ContentItem(image_item));
+    }
+    retval.set(v8::undefined(scope).into());
+}
+
+pub(super) fn store_callback(
+    scope: &mut v8::PinScope<'_, '_>,
+    args: v8::FunctionCallbackArguments,
+    _retval: v8::ReturnValue<v8::Value>,
+) {
+    let key = match args.get(0).to_string(scope) {
+        Some(key) => key.to_rust_string_lossy(scope),
+        None => {
+            throw_type_error(scope, "store key must be a string");
+            return;
+        }
+    };
+    let value = args.get(1);
+    let serialized = match v8_value_to_json(scope, value) {
+        Ok(Some(value)) => value,
+        Ok(None) => {
+            throw_type_error(
+                scope,
+                &format!("Unable to store {key:?}. Only plain serializable objects can be stored."),
+            );
+            return;
+        }
+        Err(error_text) => {
+            throw_type_error(scope, &error_text);
+            return;
+        }
+    };
+    if let Some(state) = scope.get_slot_mut::<RuntimeState>() {
+        state.stored_values.insert(key, serialized);
+    }
+}
+
+pub(super) fn load_callback(
+    scope: &mut v8::PinScope<'_, '_>,
+    args: v8::FunctionCallbackArguments,
+    mut retval: v8::ReturnValue<v8::Value>,
+) {
+    let key = match args.get(0).to_string(scope) {
+        Some(key) => key.to_rust_string_lossy(scope),
+        None => {
+            throw_type_error(scope, "load key must be a string");
+            return;
+        }
+    };
+    let value = scope
+        .get_slot::<RuntimeState>()
+        .and_then(|state| state.stored_values.get(&key))
+        .cloned();
+    let Some(value) = value else {
+        retval.set(v8::undefined(scope).into());
+        return;
+    };
+    let Some(value) = json_to_v8(scope, &value) else {
+        throw_type_error(scope, "failed to load stored value");
+        return;
+    };
+    retval.set(value);
+}
+
+pub(super) fn notify_callback(
+    scope: &mut v8::PinScope<'_, '_>,
+    args: v8::FunctionCallbackArguments,
+    mut retval: v8::ReturnValue<v8::Value>,
+) {
+    let value = if args.length() == 0 {
+        v8::undefined(scope).into()
+    } else {
+        args.get(0)
+    };
+    let text = match serialize_output_text(scope, value) {
+        Ok(text) => text,
+        Err(error_text) => {
+            throw_type_error(scope, &error_text);
+            return;
+        }
+    };
+    if text.trim().is_empty() {
+        throw_type_error(scope, "notify expects non-empty text");
+        return;
+    }
+    if let Some(state) = scope.get_slot::<RuntimeState>() {
+        let _ = state.event_tx.send(RuntimeEvent::Notify {
+            call_id: state.tool_call_id.clone(),
+            text,
+        });
+    }
+    retval.set(v8::undefined(scope).into());
+}
+
+pub(super) fn yield_control_callback(
+    scope: &mut v8::PinScope<'_, '_>,
+    _args: v8::FunctionCallbackArguments,
+    _retval: v8::ReturnValue<v8::Value>,
+) {
+    if let Some(state) = scope.get_slot::<RuntimeState>() {
+        let _ = state.event_tx.send(RuntimeEvent::YieldRequested);
+    }
+}
+
+pub(super) fn exit_callback(
+    scope: &mut v8::PinScope<'_, '_>,
+    _args: v8::FunctionCallbackArguments,
+    _retval: v8::ReturnValue<v8::Value>,
+) {
+    if let Some(state) = scope.get_slot_mut::<RuntimeState>() {
+        state.exit_requested = true;
+    }
+    if let Some(error) = v8::String::new(scope, EXIT_SENTINEL) {
+        scope.throw_exception(error.into());
+    }
+}
@@ -0,0 +1,138 @@
+use super::RuntimeState;
+use super::callbacks::exit_callback;
+use super::callbacks::image_callback;
+use super::callbacks::load_callback;
+use super::callbacks::notify_callback;
+use super::callbacks::store_callback;
+use super::callbacks::text_callback;
+use super::callbacks::tool_callback;
+use super::callbacks::yield_control_callback;
+
+pub(super) fn install_globals(scope: &mut v8::PinScope<'_, '_>) -> Result<(), String> {
+    let global = scope.get_current_context().global(scope);
+    let console = v8::String::new(scope, "console")
+        .ok_or_else(|| "failed to allocate global `console`".to_string())?;
+    if global.delete(scope, console.into()) != Some(true) {
+        return Err("failed to remove global `console`".to_string());
+    }
+
+    let tools = build_tools_object(scope)?;
+    let all_tools = build_all_tools_value(scope)?;
+    let text = helper_function(scope, "text", text_callback)?;
+    let image = helper_function(scope, "image", image_callback)?;
+    let store = helper_function(scope, "store", store_callback)?;
+    let load = helper_function(scope, "load", load_callback)?;
+    let notify = helper_function(scope, "notify", notify_callback)?;
+    let yield_control = helper_function(scope, "yield_control", yield_control_callback)?;
+    let exit = helper_function(scope, "exit", exit_callback)?;
+
+    set_global(scope, global, "tools", tools.into())?;
+    set_global(scope, global, "ALL_TOOLS", all_tools)?;
+    set_global(scope, global, "text", text.into())?;
+    set_global(scope, global, "image", image.into())?;
+    set_global(scope, global, "store", store.into())?;
+    set_global(scope, global, "load", load.into())?;
+    set_global(scope, global, "notify", notify.into())?;
+    set_global(scope, global, "yield_control", yield_control.into())?;
+    set_global(scope, global, "exit", exit.into())?;
+    Ok(())
+}
+
+fn build_tools_object<'s>(
+    scope: &mut v8::PinScope<'s, '_>,
+) -> Result<v8::Local<'s, v8::Object>, String> {
+    let tools = v8::Object::new(scope);
+    let enabled_tools = scope
+        .get_slot::<RuntimeState>()
+        .map(|state| state.enabled_tools.clone())
+        .unwrap_or_default();
+
+    for tool in enabled_tools {
+        let name = v8::String::new(scope, &tool.global_name)
+            .ok_or_else(|| "failed to allocate tool name".to_string())?;
+        let function = tool_function(scope, &tool.tool_name)?;
+        tools.set(scope, name.into(), function.into());
+    }
+    Ok(tools)
+}
+
+fn build_all_tools_value<'s>(
+    scope: &mut v8::PinScope<'s, '_>,
+) -> Result<v8::Local<'s, v8::Value>, String> {
+    let enabled_tools = scope
+        .get_slot::<RuntimeState>()
+        .map(|state| state.enabled_tools.clone())
+        .unwrap_or_default();
+    let array = v8::Array::new(scope, enabled_tools.len() as i32);
+    let name_key = v8::String::new(scope, "name")
+        .ok_or_else(|| "failed to allocate ALL_TOOLS name key".to_string())?;
+    let description_key = v8::String::new(scope, "description")
+        .ok_or_else(|| "failed to allocate ALL_TOOLS description key".to_string())?;
+
+    for (index, tool) in enabled_tools.iter().enumerate() {
+        let item = v8::Object::new(scope);
+        let name = v8::String::new(scope, &tool.global_name)
+            .ok_or_else(|| "failed to allocate ALL_TOOLS name".to_string())?;
+        let description = v8::String::new(scope, &tool.description)
+            .ok_or_else(|| "failed to allocate ALL_TOOLS description".to_string())?;
+
+        if item.set(scope, name_key.into(), name.into()) != Some(true) {
+            return Err("failed to set ALL_TOOLS name".to_string());
+        }
+        if item.set(scope, description_key.into(), description.into()) != Some(true) {
+            return Err("failed to set ALL_TOOLS description".to_string());
+        }
+        if array.set_index(scope, index as u32, item.into()) != Some(true) {
+            return Err("failed to append ALL_TOOLS metadata".to_string());
+        }
+    }
+
+    Ok(array.into())
+}
+
+fn helper_function<'s, F>(
+    scope: &mut v8::PinScope<'s, '_>,
+    name: &str,
+    callback: F,
+) -> Result<v8::Local<'s, v8::Function>, String>
+where
+    F: v8::MapFnTo<v8::FunctionCallback>,
+{
+    let name =
+        v8::String::new(scope, name).ok_or_else(|| "failed to allocate helper name".to_string())?;
+    let template = v8::FunctionTemplate::builder(callback)
+        .data(name.into())
+        .build(scope);
+    template
+        .get_function(scope)
+        .ok_or_else(|| "failed to create helper function".to_string())
+}
+
+fn tool_function<'s>(
+    scope: &mut v8::PinScope<'s, '_>,
+    tool_name: &str,
+) -> Result<v8::Local<'s, v8::Function>, String> {
+    let data = v8::String::new(scope, tool_name)
+        .ok_or_else(|| "failed to allocate tool callback data".to_string())?;
+    let template = v8::FunctionTemplate::builder(tool_callback)
+        .data(data.into())
+        .build(scope);
+    template
+        .get_function(scope)
+        .ok_or_else(|| "failed to create tool function".to_string())
+}
+
+fn set_global<'s>(
+    scope: &mut v8::PinScope<'s, '_>,
+    global: v8::Local<'s, v8::Object>,
+    name: &str,
+    value: v8::Local<'s, v8::Value>,
+) -> Result<(), String> {
+    let key = v8::String::new(scope, name)
+        .ok_or_else(|| format!("failed to allocate global `{name}`"))?;
+    if global.set(scope, key.into(), value) == Some(true) {
+        Ok(())
+    } else {
+        Err(format!("failed to set global `{name}`"))
+    }
+}
@@ -0,0 +1,349 @@
+mod callbacks;
+mod globals;
+mod module_loader;
+mod value;
+
+use std::collections::HashMap;
+use std::sync::OnceLock;
+use std::sync::mpsc as std_mpsc;
+use std::thread;
+
+use serde_json::Value as JsonValue;
+use tokio::sync::mpsc;
+
+use crate::description::EnabledToolMetadata;
+use crate::description::ToolDefinition;
+use crate::description::enabled_tool_metadata;
+use crate::response::FunctionCallOutputContentItem;
+
+pub const DEFAULT_EXEC_YIELD_TIME_MS: u64 = 10_000;
+pub const DEFAULT_WAIT_YIELD_TIME_MS: u64 = 10_000;
+pub const DEFAULT_MAX_OUTPUT_TOKENS_PER_EXEC_CALL: usize = 10_000;
+const EXIT_SENTINEL: &str = "__codex_code_mode_exit__";
+
+#[derive(Clone, Debug)]
+pub struct ExecuteRequest {
+    pub tool_call_id: String,
+    pub enabled_tools: Vec<ToolDefinition>,
+    pub source: String,
+    pub stored_values: HashMap<String, JsonValue>,
+    pub yield_time_ms: Option<u64>,
+    pub max_output_tokens: Option<usize>,
+}
+
+#[derive(Clone, Debug)]
+pub struct WaitRequest {
+    pub cell_id: String,
+    pub yield_time_ms: u64,
+    pub terminate: bool,
+}
+
+#[derive(Debug, PartialEq)]
+pub enum RuntimeResponse {
+    Yielded {
+        cell_id: String,
+        content_items: Vec<FunctionCallOutputContentItem>,
+    },
+    Terminated {
+        cell_id: String,
+        content_items: Vec<FunctionCallOutputContentItem>,
+    },
+    Result {
+        cell_id: String,
+        content_items: Vec<FunctionCallOutputContentItem>,
+        stored_values: HashMap<String, JsonValue>,
+        error_text: Option<String>,
+    },
+}
+
+#[derive(Debug)]
+pub(crate) enum TurnMessage {
+    ToolCall {
+        cell_id: String,
+        id: String,
+        name: String,
+        input: Option<JsonValue>,
+    },
+    Notify {
+        cell_id: String,
+        call_id: String,
+        text: String,
+    },
+}
+
+#[derive(Debug)]
+pub(crate) enum RuntimeCommand {
+    ToolResponse { id: String, result: JsonValue },
+    ToolError { id: String, error_text: String },
+    Terminate,
+}
+
+#[derive(Debug)]
+pub(crate) enum RuntimeEvent {
+    Started,
+    ContentItem(FunctionCallOutputContentItem),
+    YieldRequested,
+    ToolCall {
+        id: String,
+        name: String,
+        input: Option<JsonValue>,
+    },
+    Notify {
+        call_id: String,
+        text: String,
+    },
+    Result {
+        stored_values: HashMap<String, JsonValue>,
+        error_text: Option<String>,
+    },
+}
+
+pub(crate) fn spawn_runtime(
+    request: ExecuteRequest,
+    event_tx: mpsc::UnboundedSender<RuntimeEvent>,
+) -> Result<(std_mpsc::Sender<RuntimeCommand>, v8::IsolateHandle), String> {
+    let (command_tx, command_rx) = std_mpsc::channel();
+    let (isolate_handle_tx, isolate_handle_rx) = std_mpsc::sync_channel(1);
+    let enabled_tools = request
+        .enabled_tools
+        .iter()
+        .map(enabled_tool_metadata)
+        .collect::<Vec<_>>();
+    let config = RuntimeConfig {
+        tool_call_id: request.tool_call_id,
+        enabled_tools,
+        source: request.source,
+        stored_values: request.stored_values,
+    };
+
+    thread::spawn(move || {
+        run_runtime(config, event_tx, command_rx, isolate_handle_tx);
+    });
+
+    let isolate_handle = isolate_handle_rx
+        .recv()
+        .map_err(|_| "failed to initialize code mode runtime".to_string())?;
+    Ok((command_tx, isolate_handle))
+}
+
+#[derive(Clone)]
+struct RuntimeConfig {
+    tool_call_id: String,
+    enabled_tools: Vec<EnabledToolMetadata>,
+    source: String,
+    stored_values: HashMap<String, JsonValue>,
+}
+
+pub(super) struct RuntimeState {
+    event_tx: mpsc::UnboundedSender<RuntimeEvent>,
+    pending_tool_calls: HashMap<String, v8::Global<v8::PromiseResolver>>,
+    stored_values: HashMap<String, JsonValue>,
+    enabled_tools: Vec<EnabledToolMetadata>,
+    next_tool_call_id: u64,
+    tool_call_id: String,
+    exit_requested: bool,
+}
+
+pub(super) enum CompletionState {
+    Pending,
+    Completed {
+        stored_values: HashMap<String, JsonValue>,
+        error_text: Option<String>,
+    },
+}
+
+fn initialize_v8() {
+    static PLATFORM: OnceLock<v8::SharedRef<v8::Platform>> = OnceLock::new();
+
+    let _ = PLATFORM.get_or_init(|| {
+        let platform = v8::new_default_platform(0, false).make_shared();
+        v8::V8::initialize_platform(platform.clone());
+        v8::V8::initialize();
+        platform
+    });
+}
+
+fn run_runtime(
+    config: RuntimeConfig,
+    event_tx: mpsc::UnboundedSender<RuntimeEvent>,
+    command_rx: std_mpsc::Receiver<RuntimeCommand>,
+    isolate_handle_tx: std_mpsc::SyncSender<v8::IsolateHandle>,
+) {
+    initialize_v8();
+
+    let isolate = &mut v8::Isolate::new(v8::CreateParams::default());
+    let isolate_handle = isolate.thread_safe_handle();
+    if isolate_handle_tx.send(isolate_handle).is_err() {
+        return;
+    }
+    isolate.set_host_import_module_dynamically_callback(module_loader::dynamic_import_callback);
+
+    v8::scope!(let scope, isolate);
+    let context = v8::Context::new(scope, Default::default());
+    let scope = &mut v8::ContextScope::new(scope, context);
+
+    scope.set_slot(RuntimeState {
+        event_tx: event_tx.clone(),
+        pending_tool_calls: HashMap::new(),
+        stored_values: config.stored_values,
+        enabled_tools: config.enabled_tools,
+        next_tool_call_id: 1,
+        tool_call_id: config.tool_call_id,
+        exit_requested: false,
+    });
+
+    if let Err(error_text) = globals::install_globals(scope) {
+        send_result(&event_tx, HashMap::new(), Some(error_text));
+        return;
+    }
+
+    let _ = event_tx.send(RuntimeEvent::Started);
+
+    let pending_promise = match module_loader::evaluate_main_module(scope, &config.source) {
+        Ok(pending_promise) => pending_promise,
+        Err(error_text) => {
+            capture_scope_send_error(scope, &event_tx, Some(error_text));
+            return;
+        }
+    };
+
+    match module_loader::completion_state(scope, pending_promise.as_ref()) {
+        CompletionState::Completed {
+            stored_values,
+            error_text,
+        } => {
+            send_result(&event_tx, stored_values, error_text);
+            return;
+        }
+        CompletionState::Pending => {}
+    }
+
+    let mut pending_promise = pending_promise;
+    loop {
+        let Ok(command) = command_rx.recv() else {
+            break;
+        };
+        match command {
+            RuntimeCommand::Terminate => break,
+            RuntimeCommand::ToolResponse { id, result } => {
+                if let Err(error_text) =
+                    module_loader::resolve_tool_response(scope, &id, Ok(result))
+                {
+                    capture_scope_send_error(scope, &event_tx, Some(error_text));
+                    return;
+                }
+            }
+            RuntimeCommand::ToolError { id, error_text } => {
+                if let Err(runtime_error) =
+                    module_loader::resolve_tool_response(scope, &id, Err(error_text))
+                {
+                    capture_scope_send_error(scope, &event_tx, Some(runtime_error));
+                    return;
+                }
+            }
+        }
+
+        scope.perform_microtask_checkpoint();
+        match module_loader::completion_state(scope, pending_promise.as_ref()) {
+            CompletionState::Completed {
+                stored_values,
+                error_text,
+            } => {
+                send_result(&event_tx, stored_values, error_text);
+                return;
+            }
+            CompletionState::Pending => {}
+        }
+
+        if let Some(promise) = pending_promise.as_ref() {
+            let promise = v8::Local::new(scope, promise);
+            if promise.state() != v8::PromiseState::Pending {
+                pending_promise = None;
+            }
+        }
+    }
+}
+
+fn capture_scope_send_error(
+    scope: &mut v8::PinScope<'_, '_>,
+    event_tx: &mpsc::UnboundedSender<RuntimeEvent>,
+    error_text: Option<String>,
+) {
+    let stored_values = scope
+        .get_slot::<RuntimeState>()
+        .map(|state| state.stored_values.clone())
+        .unwrap_or_default();
+
+    send_result(event_tx, stored_values, error_text);
+}
+
+fn send_result(
+    event_tx: &mpsc::UnboundedSender<RuntimeEvent>,
+    stored_values: HashMap<String, JsonValue>,
+    error_text: Option<String>,
+) {
+    let _ = event_tx.send(RuntimeEvent::Result {
+        stored_values,
+        error_text,
+    });
+}
+
+#[cfg(test)]
+mod tests {
+    use std::collections::HashMap;
+    use std::time::Duration;
+
+    use pretty_assertions::assert_eq;
+    use tokio::sync::mpsc;
+
+    use super::ExecuteRequest;
+    use super::RuntimeEvent;
+    use super::spawn_runtime;
+
+    fn execute_request(source: &str) -> ExecuteRequest {
+        ExecuteRequest {
+            tool_call_id: "call_1".to_string(),
+            enabled_tools: Vec::new(),
+            source: source.to_string(),
+            stored_values: HashMap::new(),
+            yield_time_ms: Some(1),
+            max_output_tokens: None,
+        }
+    }
+
+    #[tokio::test]
+    async fn terminate_execution_stops_cpu_bound_module() {
+        let (event_tx, mut event_rx) = mpsc::unbounded_channel();
+        let (_runtime_tx, runtime_terminate_handle) =
+            spawn_runtime(execute_request("while (true) {}"), event_tx).unwrap();
+
+        let started_event = tokio::time::timeout(Duration::from_secs(1), event_rx.recv())
+            .await
+            .unwrap()
+            .unwrap();
+        assert!(matches!(started_event, RuntimeEvent::Started));
+
+        assert!(runtime_terminate_handle.terminate_execution());
+
+        let result_event = tokio::time::timeout(Duration::from_secs(1), event_rx.recv())
+            .await
+            .unwrap()
+            .unwrap();
+        let RuntimeEvent::Result {
+            stored_values,
+            error_text,
+        } = result_event
+        else {
+            panic!("expected runtime result after termination");
+        };
+        assert_eq!(stored_values, HashMap::new());
+        assert!(error_text.is_some());
+
+        assert!(
+            tokio::time::timeout(Duration::from_secs(1), event_rx.recv())
+                .await
+                .unwrap()
+                .is_none()
+        );
+    }
+}
@@ -0,0 +1,235 @@
+use serde_json::Value as JsonValue;
+
+use super::CompletionState;
+use super::EXIT_SENTINEL;
+use super::RuntimeState;
+use super::value::json_to_v8;
+use super::value::value_to_error_text;
+
+pub(super) fn evaluate_main_module(
+    scope: &mut v8::PinScope<'_, '_>,
+    source_text: &str,
+) -> Result<Option<v8::Global<v8::Promise>>, String> {
+    let tc = std::pin::pin!(v8::TryCatch::new(scope));
+    let mut tc = tc.init();
+    let source = v8::String::new(&tc, source_text)
+        .ok_or_else(|| "failed to allocate exec source".to_string())?;
+    let origin = script_origin(&mut tc, "exec_main.mjs")?;
+    let mut source = v8::script_compiler::Source::new(source, Some(&origin));
+    let module = v8::script_compiler::compile_module(&tc, &mut source).ok_or_else(|| {
+        tc.exception()
+            .map(|exception| value_to_error_text(&mut tc, exception))
+            .unwrap_or_else(|| "unknown code mode exception".to_string())
+    })?;
+    module
+        .instantiate_module(&tc, resolve_module_callback)
+        .ok_or_else(|| {
+            tc.exception()
+                .map(|exception| value_to_error_text(&mut tc, exception))
+                .unwrap_or_else(|| "unknown code mode exception".to_string())
+        })?;
+    let result = match module.evaluate(&tc) {
+        Some(result) => result,
+        None => {
+            if let Some(exception) = tc.exception() {
+                if is_exit_exception(&mut tc, exception) {
+                    return Ok(None);
+                }
+                return Err(value_to_error_text(&mut tc, exception));
+            }
+            return Err("unknown code mode exception".to_string());
+        }
+    };
+    tc.perform_microtask_checkpoint();
+
+    if result.is_promise() {
+        let promise = v8::Local::<v8::Promise>::try_from(result)
+            .map_err(|_| "failed to read exec promise".to_string())?;
+        return Ok(Some(v8::Global::new(&tc, promise)));
+    }
+
+    Ok(None)
+}
+
+fn is_exit_exception(
+    scope: &mut v8::PinScope<'_, '_>,
+    exception: v8::Local<'_, v8::Value>,
+) -> bool {
+    scope
+        .get_slot::<RuntimeState>()
+        .map(|state| state.exit_requested)
+        .unwrap_or(false)
+        && exception.is_string()
+        && exception.to_rust_string_lossy(scope) == EXIT_SENTINEL
+}
+
+pub(super) fn resolve_tool_response(
+    scope: &mut v8::PinScope<'_, '_>,
+    id: &str,
+    response: Result<JsonValue, String>,
+) -> Result<(), String> {
+    let resolver = {
+        let state = scope
+            .get_slot_mut::<RuntimeState>()
+            .ok_or_else(|| "runtime state unavailable".to_string())?;
+        state.pending_tool_calls.remove(id)
+    }
+    .ok_or_else(|| format!("unknown tool call `{id}`"))?;
+
+    let tc = std::pin::pin!(v8::TryCatch::new(scope));
+    let mut tc = tc.init();
+    let resolver = v8::Local::new(&tc, &resolver);
+    match response {
+        Ok(result) => {
+            let value = json_to_v8(&mut tc, &result)
+                .ok_or_else(|| "failed to serialize tool response".to_string())?;
+            resolver.resolve(&tc, value);
+        }
+        Err(error_text) => {
+            let value = v8::String::new(&tc, &error_text)
+                .ok_or_else(|| "failed to allocate tool error".to_string())?;
+            resolver.reject(&tc, value.into());
+        }
+    }
+    if tc.has_caught() {
+        return Err(tc
+            .exception()
+            .map(|exception| value_to_error_text(&mut tc, exception))
+            .unwrap_or_else(|| "unknown code mode exception".to_string()));
+    }
+    Ok(())
+}
+
+pub(super) fn completion_state(
+    scope: &mut v8::PinScope<'_, '_>,
+    pending_promise: Option<&v8::Global<v8::Promise>>,
+) -> CompletionState {
+    let stored_values = scope
+        .get_slot::<RuntimeState>()
+        .map(|state| state.stored_values.clone())
+        .unwrap_or_default();
+
+    let Some(pending_promise) = pending_promise else {
+        return CompletionState::Completed {
+            stored_values,
+            error_text: None,
+        };
+    };
+
+    let promise = v8::Local::new(scope, pending_promise);
+    match promise.state() {
+        v8::PromiseState::Pending => CompletionState::Pending,
+        v8::PromiseState::Fulfilled => CompletionState::Completed {
+            stored_values,
+            error_text: None,
+        },
+        v8::PromiseState::Rejected => {
+            let result = promise.result(scope);
+            let error_text = if is_exit_exception(scope, result) {
+                None
+            } else {
+                Some(value_to_error_text(scope, result))
+            };
+            CompletionState::Completed {
+                stored_values,
+                error_text,
+            }
+        }
+    }
+}
+
+fn script_origin<'s>(
+    scope: &mut v8::PinScope<'s, '_>,
+    resource_name_: &str,
+) -> Result<v8::ScriptOrigin<'s>, String> {
+    let resource_name = v8::String::new(scope, resource_name_)
+        .ok_or_else(|| "failed to allocate script origin".to_string())?;
+    let source_map_url = v8::String::new(scope, resource_name_)
+        .ok_or_else(|| "failed to allocate source map url".to_string())?;
+    Ok(v8::ScriptOrigin::new(
+        scope,
+        resource_name.into(),
+        0,
+        0,
+        true,
+        0,
+        Some(source_map_url.into()),
+        true,
+        false,
+        true,
+        None,
+    ))
+}
+
+fn resolve_module_callback<'s>(
+    context: v8::Local<'s, v8::Context>,
+    specifier: v8::Local<'s, v8::String>,
+    _import_attributes: v8::Local<'s, v8::FixedArray>,
+    _referrer: v8::Local<'s, v8::Module>,
+) -> Option<v8::Local<'s, v8::Module>> {
+    v8::callback_scope!(unsafe scope, context);
+    let specifier = specifier.to_rust_string_lossy(scope);
+    resolve_module(scope, &specifier)
+}
+
+pub(super) fn dynamic_import_callback<'s>(
+    scope: &mut v8::PinScope<'s, '_>,
+    _host_defined_options: v8::Local<'s, v8::Data>,
+    _resource_name: v8::Local<'s, v8::Value>,
+    specifier: v8::Local<'s, v8::String>,
+    _import_attributes: v8::Local<'s, v8::FixedArray>,
+) -> Option<v8::Local<'s, v8::Promise>> {
+    let specifier = specifier.to_rust_string_lossy(scope);
+    let resolver = v8::PromiseResolver::new(scope)?;
+
+    match resolve_module(scope, &specifier) {
+        Some(module) => {
+            if module.get_status() == v8::ModuleStatus::Uninstantiated
+                && module
+                    .instantiate_module(scope, resolve_module_callback)
+                    .is_none()
+            {
+                let error = v8::String::new(scope, "failed to instantiate module")
+                    .map(Into::into)
+                    .unwrap_or_else(|| v8::undefined(scope).into());
+                resolver.reject(scope, error);
+                return Some(resolver.get_promise(scope));
+            }
+            if matches!(
+                module.get_status(),
+                v8::ModuleStatus::Instantiated | v8::ModuleStatus::Evaluated
+            ) && module.evaluate(scope).is_none()
+            {
+                let error = v8::String::new(scope, "failed to evaluate module")
+                    .map(Into::into)
+                    .unwrap_or_else(|| v8::undefined(scope).into());
+                resolver.reject(scope, error);
+                return Some(resolver.get_promise(scope));
+            }
+            let namespace = module.get_module_namespace();
+            resolver.resolve(scope, namespace);
+            Some(resolver.get_promise(scope))
+        }
+        None => {
+            let error = v8::String::new(scope, "unsupported import in exec")
+                .map(Into::into)
+                .unwrap_or_else(|| v8::undefined(scope).into());
+            resolver.reject(scope, error);
+            Some(resolver.get_promise(scope))
+        }
+    }
+}
+
+fn resolve_module<'s>(
+    scope: &mut v8::PinScope<'s, '_>,
+    specifier: &str,
+) -> Option<v8::Local<'s, v8::Module>> {
+    if let Some(message) =
+        v8::String::new(scope, &format!("Unsupported import in exec: {specifier}"))
+    {
+        scope.throw_exception(message.into());
+    } else {
+        scope.throw_exception(v8::undefined(scope).into());
+    }
+    None
+}
@@ -0,0 +1,163 @@
+use serde_json::Value as JsonValue;
+
+use crate::response::FunctionCallOutputContentItem;
+use crate::response::ImageDetail;
+
+pub(super) fn serialize_output_text(
+    scope: &mut v8::PinScope<'_, '_>,
+    value: v8::Local<'_, v8::Value>,
+) -> Result<String, String> {
+    if value.is_undefined()
+        || value.is_null()
+        || value.is_boolean()
+        || value.is_number()
+        || value.is_big_int()
+        || value.is_string()
+    {
+        return Ok(value.to_rust_string_lossy(scope));
+    }
+
+    let tc = std::pin::pin!(v8::TryCatch::new(scope));
+    let mut tc = tc.init();
+    if let Some(stringified) = v8::json::stringify(&tc, value) {
+        return Ok(stringified.to_rust_string_lossy(&tc));
+    }
+    if tc.has_caught() {
+        return Err(tc
+            .exception()
+            .map(|exception| value_to_error_text(&mut tc, exception))
+            .unwrap_or_else(|| "unknown code mode exception".to_string()));
+    }
+    Ok(value.to_rust_string_lossy(&tc))
+}
+
+pub(super) fn normalize_output_image(
+    scope: &mut v8::PinScope<'_, '_>,
+    value: v8::Local<'_, v8::Value>,
+) -> Result<FunctionCallOutputContentItem, ()> {
+    let result = (|| -> Result<FunctionCallOutputContentItem, String> {
+        let (image_url, detail) = if value.is_string() {
+            (value.to_rust_string_lossy(scope), None)
+        } else if value.is_object() && !value.is_array() {
+            let object = v8::Local::<v8::Object>::try_from(value).map_err(|_| {
+                "image expects a non-empty image URL string or an object with image_url and optional detail".to_string()
+            })?;
+            let image_url_key = v8::String::new(scope, "image_url")
+                .ok_or_else(|| "failed to allocate image helper keys".to_string())?;
+            let detail_key = v8::String::new(scope, "detail")
+                .ok_or_else(|| "failed to allocate image helper keys".to_string())?;
+            let image_url = object
+                .get(scope, image_url_key.into())
+                .filter(|value| value.is_string())
+                .map(|value| value.to_rust_string_lossy(scope))
+                .ok_or_else(|| {
+                    "image expects a non-empty image URL string or an object with image_url and optional detail"
+                        .to_string()
+                })?;
+            let detail = match object.get(scope, detail_key.into()) {
+                Some(value) if value.is_string() => Some(value.to_rust_string_lossy(scope)),
+                Some(value) if value.is_null() || value.is_undefined() => None,
+                Some(_) => return Err("image detail must be a string when provided".to_string()),
+                None => None,
+            };
+            (image_url, detail)
+        } else {
+            return Err(
+                "image expects a non-empty image URL string or an object with image_url and optional detail"
+                    .to_string(),
+            );
+        };
+
+        if image_url.is_empty() {
+            return Err(
+                "image expects a non-empty image URL string or an object with image_url and optional detail"
+                    .to_string(),
+            );
+        }
+        let lower = image_url.to_ascii_lowercase();
+        if !(lower.starts_with("http://")
+            || lower.starts_with("https://")
+            || lower.starts_with("data:"))
+        {
+            return Err("image expects an http(s) or data URL".to_string());
+        }
+
+        let detail = match detail {
+            Some(detail) => {
+                let normalized = detail.to_ascii_lowercase();
+                Some(match normalized.as_str() {
+                    "auto" => ImageDetail::Auto,
+                    "low" => ImageDetail::Low,
+                    "high" => ImageDetail::High,
+                    "original" => ImageDetail::Original,
+                    _ => {
+                        return Err(
+                            "image detail must be one of: auto, low, high, original".to_string()
+                        );
+                    }
+                })
+            }
+            None => None,
+        };
+
+        Ok(FunctionCallOutputContentItem::InputImage { image_url, detail })
+    })();
+
+    match result {
+        Ok(item) => Ok(item),
+        Err(error_text) => {
+            throw_type_error(scope, &error_text);
+            Err(())
+        }
+    }
+}
+
+pub(super) fn v8_value_to_json(
+    scope: &mut v8::PinScope<'_, '_>,
+    value: v8::Local<'_, v8::Value>,
+) -> Result<Option<JsonValue>, String> {
+    let tc = std::pin::pin!(v8::TryCatch::new(scope));
+    let mut tc = tc.init();
+    let Some(stringified) = v8::json::stringify(&tc, value) else {
+        if tc.has_caught() {
+            return Err(tc
+                .exception()
+                .map(|exception| value_to_error_text(&mut tc, exception))
+                .unwrap_or_else(|| "unknown code mode exception".to_string()));
+        }
+        return Ok(None);
+    };
+    serde_json::from_str(&stringified.to_rust_string_lossy(&tc))
+        .map(Some)
+        .map_err(|err| format!("failed to serialize JavaScript value: {err}"))
+}
+
+pub(super) fn json_to_v8<'s>(
+    scope: &mut v8::PinScope<'s, '_>,
+    value: &JsonValue,
+) -> Option<v8::Local<'s, v8::Value>> {
+    let json = serde_json::to_string(value).ok()?;
+    let json = v8::String::new(scope, &json)?;
+    v8::json::parse(scope, json)
+}
+
+pub(super) fn value_to_error_text(
+    scope: &mut v8::PinScope<'_, '_>,
+    value: v8::Local<'_, v8::Value>,
+) -> String {
+    if value.is_object()
+        && let Ok(object) = v8::Local::<v8::Object>::try_from(value)
+        && let Some(key) = v8::String::new(scope, "stack")
+        && let Some(stack) = object.get(scope, key.into())
+        && stack.is_string()
+    {
+        return stack.to_rust_string_lossy(scope);
+    }
+    value.to_rust_string_lossy(scope)
+}
+
+pub(super) fn throw_type_error(scope: &mut v8::PinScope<'_, '_>, message: &str) {
+    if let Some(message) = v8::String::new(scope, message) {
+        scope.throw_exception(message.into());
+    }
+}
@@ -0,0 +1,673 @@
+use std::collections::HashMap;
+use std::sync::Arc;
+use std::sync::atomic::AtomicU64;
+use std::sync::atomic::Ordering;
+use std::time::Duration;
+
+use async_trait::async_trait;
+use serde_json::Value as JsonValue;
+use tokio::sync::Mutex;
+use tokio::sync::mpsc;
+use tokio::sync::oneshot;
+use tokio_util::sync::CancellationToken;
+use tracing::warn;
+
+use crate::FunctionCallOutputContentItem;
+use crate::runtime::DEFAULT_EXEC_YIELD_TIME_MS;
+use crate::runtime::ExecuteRequest;
+use crate::runtime::RuntimeCommand;
+use crate::runtime::RuntimeEvent;
+use crate::runtime::RuntimeResponse;
+use crate::runtime::TurnMessage;
+use crate::runtime::WaitRequest;
+use crate::runtime::spawn_runtime;
+
+#[async_trait]
+pub trait CodeModeTurnHost: Send + Sync {
+    async fn invoke_tool(
+        &self,
+        tool_name: String,
+        input: Option<JsonValue>,
+        cancellation_token: CancellationToken,
+    ) -> Result<JsonValue, String>;
+
+    async fn notify(&self, call_id: String, cell_id: String, text: String) -> Result<(), String>;
+}
+
+#[derive(Clone)]
+struct SessionHandle {
+    control_tx: mpsc::UnboundedSender<SessionControlCommand>,
+    runtime_tx: std::sync::mpsc::Sender<RuntimeCommand>,
+}
+
+struct Inner {
+    stored_values: Mutex<HashMap<String, JsonValue>>,
+    sessions: Mutex<HashMap<String, SessionHandle>>,
+    turn_message_tx: mpsc::UnboundedSender<TurnMessage>,
+    turn_message_rx: Arc<Mutex<mpsc::UnboundedReceiver<TurnMessage>>>,
+    next_cell_id: AtomicU64,
+}
+
+pub struct CodeModeService {
+    inner: Arc<Inner>,
+}
+
+impl CodeModeService {
+    pub fn new() -> Self {
+        let (turn_message_tx, turn_message_rx) = mpsc::unbounded_channel();
+
+        Self {
+            inner: Arc::new(Inner {
+                stored_values: Mutex::new(HashMap::new()),
+                sessions: Mutex::new(HashMap::new()),
+                turn_message_tx,
+                turn_message_rx: Arc::new(Mutex::new(turn_message_rx)),
+                next_cell_id: AtomicU64::new(1),
+            }),
+        }
+    }
+
+    pub async fn stored_values(&self) -> HashMap<String, JsonValue> {
+        self.inner.stored_values.lock().await.clone()
+    }
+
+    pub async fn replace_stored_values(&self, values: HashMap<String, JsonValue>) {
+        *self.inner.stored_values.lock().await = values;
+    }
+
+    pub async fn execute(&self, request: ExecuteRequest) -> Result<RuntimeResponse, String> {
+        let cell_id = self
+            .inner
+            .next_cell_id
+            .fetch_add(1, Ordering::Relaxed)
+            .to_string();
+        let (event_tx, event_rx) = mpsc::unbounded_channel();
+        let (runtime_tx, runtime_terminate_handle) = spawn_runtime(request.clone(), event_tx)?;
+        let (control_tx, control_rx) = mpsc::unbounded_channel();
+        let (response_tx, response_rx) = oneshot::channel();
+
+        self.inner.sessions.lock().await.insert(
+            cell_id.clone(),
+            SessionHandle {
+                control_tx: control_tx.clone(),
+                runtime_tx: runtime_tx.clone(),
+            },
+        );
+
+        tokio::spawn(run_session_control(
+            Arc::clone(&self.inner),
+            SessionControlContext {
+                cell_id: cell_id.clone(),
+                runtime_tx,
+                runtime_terminate_handle,
+            },
+            event_rx,
+            control_rx,
+            response_tx,
+            request.yield_time_ms.unwrap_or(DEFAULT_EXEC_YIELD_TIME_MS),
+        ));
+
+        response_rx
+            .await
+            .map_err(|_| "exec runtime ended unexpectedly".to_string())
+    }
+
+    pub async fn wait(&self, request: WaitRequest) -> Result<RuntimeResponse, String> {
+        let cell_id = request.cell_id.clone();
+        let handle = self
+            .inner
+            .sessions
+            .lock()
+            .await
+            .get(&request.cell_id)
+            .cloned();
+        let Some(handle) = handle else {
+            return Ok(missing_cell_response(cell_id));
+        };
+        let (response_tx, response_rx) = oneshot::channel();
+        let control_message = if request.terminate {
+            SessionControlCommand::Terminate { response_tx }
+        } else {
+            SessionControlCommand::Poll {
+                yield_time_ms: request.yield_time_ms,
+                response_tx,
+            }
+        };
+        if handle.control_tx.send(control_message).is_err() {
+            return Ok(missing_cell_response(cell_id));
+        }
+        match response_rx.await {
+            Ok(response) => Ok(response),
+            Err(_) => Ok(missing_cell_response(request.cell_id)),
+        }
+    }
+
+    pub fn start_turn_worker(&self, host: Arc<dyn CodeModeTurnHost>) -> CodeModeTurnWorker {
+        let (shutdown_tx, mut shutdown_rx) = oneshot::channel();
+        let inner = Arc::clone(&self.inner);
+        let turn_message_rx = Arc::clone(&self.inner.turn_message_rx);
+
+        tokio::spawn(async move {
+            loop {
+                let next_message = tokio::select! {
+                    _ = &mut shutdown_rx => break,
+                    message = async {
+                        let mut turn_message_rx = turn_message_rx.lock().await;
+                        turn_message_rx.recv().await
+                    } => message,
+                };
+                let Some(next_message) = next_message else {
+                    break;
+                };
+                match next_message {
+                    TurnMessage::Notify {
+                        cell_id,
+                        call_id,
+                        text,
+                    } => {
+                        if let Err(err) = host.notify(call_id, cell_id.clone(), text).await {
+                            warn!(
+                                "failed to deliver code mode notification for cell {cell_id}: {err}"
+                            );
+                        }
+                    }
+                    TurnMessage::ToolCall {
+                        cell_id,
+                        id,
+                        name,
+                        input,
+                    } => {
+                        let host = Arc::clone(&host);
+                        let inner = Arc::clone(&inner);
+                        tokio::spawn(async move {
+                            let response = host
+                                .invoke_tool(name, input, CancellationToken::new())
+                                .await;
+                            let runtime_tx = inner
+                                .sessions
+                                .lock()
+                                .await
+                                .get(&cell_id)
+                                .map(|handle| handle.runtime_tx.clone());
+                            let Some(runtime_tx) = runtime_tx else {
+                                return;
+                            };
+                            let command = match response {
+                                Ok(result) => RuntimeCommand::ToolResponse { id, result },
+                                Err(error_text) => RuntimeCommand::ToolError { id, error_text },
+                            };
+                            let _ = runtime_tx.send(command);
+                        });
+                    }
+                }
+            }
+        });
+
+        CodeModeTurnWorker {
+            shutdown_tx: Some(shutdown_tx),
+        }
+    }
+}
+
+impl Default for CodeModeService {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+pub struct CodeModeTurnWorker {
+    shutdown_tx: Option<oneshot::Sender<()>>,
+}
+
+impl Drop for CodeModeTurnWorker {
+    fn drop(&mut self) {
+        if let Some(shutdown_tx) = self.shutdown_tx.take() {
+            let _ = shutdown_tx.send(());
+        }
+    }
+}
+
+enum SessionControlCommand {
+    Poll {
+        yield_time_ms: u64,
+        response_tx: oneshot::Sender<RuntimeResponse>,
+    },
+    Terminate {
+        response_tx: oneshot::Sender<RuntimeResponse>,
+    },
+}
+
+struct PendingResult {
+    content_items: Vec<FunctionCallOutputContentItem>,
+    stored_values: HashMap<String, JsonValue>,
+    error_text: Option<String>,
+}
+
+struct SessionControlContext {
+    cell_id: String,
+    runtime_tx: std::sync::mpsc::Sender<RuntimeCommand>,
+    runtime_terminate_handle: v8::IsolateHandle,
+}
+
+fn missing_cell_response(cell_id: String) -> RuntimeResponse {
+    RuntimeResponse::Result {
+        error_text: Some(format!("exec cell {cell_id} not found")),
+        cell_id,
+        content_items: Vec::new(),
+        stored_values: HashMap::new(),
+    }
+}
+
+fn pending_result_response(cell_id: &str, result: PendingResult) -> RuntimeResponse {
+    RuntimeResponse::Result {
+        cell_id: cell_id.to_string(),
+        content_items: result.content_items,
+        stored_values: result.stored_values,
+        error_text: result.error_text,
+    }
+}
+
+fn send_or_buffer_result(
+    cell_id: &str,
+    result: PendingResult,
+    response_tx: &mut Option<oneshot::Sender<RuntimeResponse>>,
+    pending_result: &mut Option<PendingResult>,
+) -> bool {
+    if let Some(response_tx) = response_tx.take() {
+        let _ = response_tx.send(pending_result_response(cell_id, result));
+        return true;
+    }
+
+    *pending_result = Some(result);
+    false
+}
+
+async fn run_session_control(
+    inner: Arc<Inner>,
+    context: SessionControlContext,
+    mut event_rx: mpsc::UnboundedReceiver<RuntimeEvent>,
+    mut control_rx: mpsc::UnboundedReceiver<SessionControlCommand>,
+    initial_response_tx: oneshot::Sender<RuntimeResponse>,
+    initial_yield_time_ms: u64,
+) {
+    let SessionControlContext {
+        cell_id,
+        runtime_tx,
+        runtime_terminate_handle,
+    } = context;
+    let mut content_items = Vec::new();
+    let mut pending_result: Option<PendingResult> = None;
+    let mut response_tx = Some(initial_response_tx);
+    let mut termination_requested = false;
+    let mut runtime_closed = false;
+    let mut yield_timer: Option<std::pin::Pin<Box<tokio::time::Sleep>>> = None;
+
+    loop {
+        tokio::select! {
+            maybe_event = async {
+                if runtime_closed {
+                    std::future::pending::<Option<RuntimeEvent>>().await
+                } else {
+                    event_rx.recv().await
+                }
+            } => {
+                let Some(event) = maybe_event else {
+                    runtime_closed = true;
+                    if termination_requested {
+                        if let Some(response_tx) = response_tx.take() {
+                            let _ = response_tx.send(RuntimeResponse::Terminated {
+                                cell_id: cell_id.clone(),
+                                content_items: std::mem::take(&mut content_items),
+                            });
+                        }
+                        break;
+                    }
+                    if pending_result.is_none() {
+                        let result = PendingResult {
+                            content_items: std::mem::take(&mut content_items),
+                            stored_values: HashMap::new(),
+                            error_text: Some("exec runtime ended unexpectedly".to_string()),
+                        };
+                        if send_or_buffer_result(
+                            &cell_id,
+                            result,
+                            &mut response_tx,
+                            &mut pending_result,
+                        ) {
+                            break;
+                        }
+                    }
+                    continue;
+                };
+                match event {
+                    RuntimeEvent::Started => {
+                        yield_timer = Some(Box::pin(tokio::time::sleep(Duration::from_millis(initial_yield_time_ms))));
+                    }
+                    RuntimeEvent::ContentItem(item) => {
+                        content_items.push(item);
+                    }
+                    RuntimeEvent::YieldRequested => {
+                        yield_timer = None;
+                        if let Some(response_tx) = response_tx.take() {
+                            let _ = response_tx.send(RuntimeResponse::Yielded {
+                                cell_id: cell_id.clone(),
+                                content_items: std::mem::take(&mut content_items),
+                            });
+                        }
+                    }
+                    RuntimeEvent::Notify { call_id, text } => {
+                        let _ = inner.turn_message_tx.send(TurnMessage::Notify {
+                            cell_id: cell_id.clone(),
+                            call_id,
+                            text,
+                        });
+                    }
+                    RuntimeEvent::ToolCall { id, name, input } => {
+                        let _ = inner.turn_message_tx.send(TurnMessage::ToolCall {
+                            cell_id: cell_id.clone(),
+                            id,
+                            name,
+                            input,
+                        });
+                    }
+                    RuntimeEvent::Result {
+                        stored_values,
+                        error_text,
+                    } => {
+                        yield_timer = None;
+                        if termination_requested {
+                            if let Some(response_tx) = response_tx.take() {
+                                let _ = response_tx.send(RuntimeResponse::Terminated {
+                                    cell_id: cell_id.clone(),
+                                    content_items: std::mem::take(&mut content_items),
+                                });
+                            }
+                            break;
+                        }
+                        let result = PendingResult {
+                            content_items: std::mem::take(&mut content_items),
+                            stored_values,
+                            error_text,
+                        };
+                        if send_or_buffer_result(
+                            &cell_id,
+                            result,
+                            &mut response_tx,
+                            &mut pending_result,
+                        ) {
+                            break;
+                        }
+                    }
+                }
+            }
+            maybe_command = control_rx.recv() => {
+                let Some(command) = maybe_command else {
+                    break;
+                };
+                match command {
+                    SessionControlCommand::Poll {
+                        yield_time_ms,
+                        response_tx: next_response_tx,
+                    } => {
+                        if let Some(result) = pending_result.take() {
+                            let _ = next_response_tx.send(pending_result_response(&cell_id, result));
+                            break;
+                        }
+                        response_tx = Some(next_response_tx);
+                        yield_timer = Some(Box::pin(tokio::time::sleep(Duration::from_millis(yield_time_ms))));
+                    }
+                    SessionControlCommand::Terminate { response_tx: next_response_tx } => {
+                        if let Some(result) = pending_result.take() {
+                            let _ = next_response_tx.send(pending_result_response(&cell_id, result));
+                            break;
+                        }
+
+                        response_tx = Some(next_response_tx);
+                        termination_requested = true;
+                        yield_timer = None;
+                        let _ = runtime_tx.send(RuntimeCommand::Terminate);
+                        let _ = runtime_terminate_handle.terminate_execution();
+                        if runtime_closed {
+                            if let Some(response_tx) = response_tx.take() {
+                                let _ = response_tx.send(RuntimeResponse::Terminated {
+                                    cell_id: cell_id.clone(),
+                                    content_items: std::mem::take(&mut content_items),
+                                });
+                            }
+                            break;
+                        } else {
+                            continue;
+                        }
+                    }
+                }
+            }
+            _ = async {
+                if let Some(yield_timer) = yield_timer.as_mut() {
+                    yield_timer.await;
+                } else {
+                    std::future::pending::<()>().await;
+                }
+            } => {
+                yield_timer = None;
+                if let Some(response_tx) = response_tx.take() {
+                    let _ = response_tx.send(RuntimeResponse::Yielded {
+                        cell_id: cell_id.clone(),
+                        content_items: std::mem::take(&mut content_items),
+                    });
+                }
+            }
+        }
+    }
+
+    let _ = runtime_tx.send(RuntimeCommand::Terminate);
+    inner.sessions.lock().await.remove(&cell_id);
+}
+
+#[cfg(test)]
+mod tests {
+    use std::collections::HashMap;
+    use std::sync::Arc;
+    use std::sync::atomic::AtomicU64;
+    use std::time::Duration;
+
+    use pretty_assertions::assert_eq;
+    use tokio::sync::Mutex;
+    use tokio::sync::mpsc;
+    use tokio::sync::oneshot;
+
+    use super::CodeModeService;
+    use super::Inner;
+    use super::RuntimeCommand;
+    use super::RuntimeResponse;
+    use super::SessionControlCommand;
+    use super::SessionControlContext;
+    use super::run_session_control;
+    use crate::FunctionCallOutputContentItem;
+    use crate::runtime::ExecuteRequest;
+    use crate::runtime::RuntimeEvent;
+    use crate::runtime::spawn_runtime;
+
+    fn execute_request(source: &str) -> ExecuteRequest {
+        ExecuteRequest {
+            tool_call_id: "call_1".to_string(),
+            enabled_tools: Vec::new(),
+            source: source.to_string(),
+            stored_values: HashMap::new(),
+            yield_time_ms: Some(1),
+            max_output_tokens: None,
+        }
+    }
+
+    fn test_inner() -> Arc<Inner> {
+        let (turn_message_tx, turn_message_rx) = mpsc::unbounded_channel();
+        Arc::new(Inner {
+            stored_values: Mutex::new(HashMap::new()),
+            sessions: Mutex::new(HashMap::new()),
+            turn_message_tx,
+            turn_message_rx: Arc::new(Mutex::new(turn_message_rx)),
+            next_cell_id: AtomicU64::new(1),
+        })
+    }
+
+    #[tokio::test]
+    async fn synchronous_exit_returns_successfully() {
+        let service = CodeModeService::new();
+
+        let response = service
+            .execute(ExecuteRequest {
+                source: r#"text("before"); exit(); text("after");"#.to_string(),
+                yield_time_ms: None,
+                ..execute_request("")
+            })
+            .await
+            .unwrap();
+
+        assert_eq!(
+            response,
+            RuntimeResponse::Result {
+                cell_id: "1".to_string(),
+                content_items: vec![FunctionCallOutputContentItem::InputText {
+                    text: "before".to_string(),
+                }],
+                stored_values: HashMap::new(),
+                error_text: None,
+            }
+        );
+    }
+
+    #[tokio::test]
+    async fn v8_console_is_not_exposed_on_global_this() {
+        let service = CodeModeService::new();
+
+        let response = service
+            .execute(ExecuteRequest {
+                source: r#"text(String(Object.hasOwn(globalThis, "console")));"#.to_string(),
+                yield_time_ms: None,
+                ..execute_request("")
+            })
+            .await
+            .unwrap();
+
+        assert_eq!(
+            response,
+            RuntimeResponse::Result {
+                cell_id: "1".to_string(),
+                content_items: vec![FunctionCallOutputContentItem::InputText {
+                    text: "false".to_string(),
+                }],
+                stored_values: HashMap::new(),
+                error_text: None,
+            }
+        );
+    }
+
+    #[tokio::test]
+    async fn output_helpers_return_undefined() {
+        let service = CodeModeService::new();
+
+        let response = service
+            .execute(ExecuteRequest {
+                source: r#"
+const returnsUndefined = [
+  text("first"),
+  image("https://example.com/image.jpg"),
+  notify("ping"),
+].map((value) => value === undefined);
+text(JSON.stringify(returnsUndefined));
+"#
+                .to_string(),
+                yield_time_ms: None,
+                ..execute_request("")
+            })
+            .await
+            .unwrap();
+
+        assert_eq!(
+            response,
+            RuntimeResponse::Result {
+                cell_id: "1".to_string(),
+                content_items: vec![
+                    FunctionCallOutputContentItem::InputText {
+                        text: "first".to_string(),
+                    },
+                    FunctionCallOutputContentItem::InputImage {
+                        image_url: "https://example.com/image.jpg".to_string(),
+                        detail: None,
+                    },
+                    FunctionCallOutputContentItem::InputText {
+                        text: "[true,true,true]".to_string(),
+                    },
+                ],
+                stored_values: HashMap::new(),
+                error_text: None,
+            }
+        );
+    }
+
+    #[tokio::test]
+    async fn terminate_waits_for_runtime_shutdown_before_responding() {
+        let inner = test_inner();
+        let (event_tx, event_rx) = mpsc::unbounded_channel();
+        let (control_tx, control_rx) = mpsc::unbounded_channel();
+        let (initial_response_tx, initial_response_rx) = oneshot::channel();
+        let (runtime_event_tx, _runtime_event_rx) = mpsc::unbounded_channel();
+        let (runtime_tx, runtime_terminate_handle) = spawn_runtime(
+            ExecuteRequest {
+                source: "await new Promise(() => {})".to_string(),
+                yield_time_ms: None,
+                ..execute_request("")
+            },
+            runtime_event_tx,
+        )
+        .unwrap();
+
+        tokio::spawn(run_session_control(
+            inner,
+            SessionControlContext {
+                cell_id: "cell-1".to_string(),
+                runtime_tx: runtime_tx.clone(),
+                runtime_terminate_handle,
+            },
+            event_rx,
+            control_rx,
+            initial_response_tx,
+            60_000,
+        ));
+
+        event_tx.send(RuntimeEvent::Started).unwrap();
+        event_tx.send(RuntimeEvent::YieldRequested).unwrap();
+        assert_eq!(
+            initial_response_rx.await.unwrap(),
+            RuntimeResponse::Yielded {
+                cell_id: "cell-1".to_string(),
+                content_items: Vec::new(),
+            }
+        );
+
+        let (terminate_response_tx, terminate_response_rx) = oneshot::channel();
+        control_tx
+            .send(SessionControlCommand::Terminate {
+                response_tx: terminate_response_tx,
+            })
+            .unwrap();
+        let terminate_response = async { terminate_response_rx.await.unwrap() };
+        tokio::pin!(terminate_response);
+        assert!(
+            tokio::time::timeout(Duration::from_millis(100), terminate_response.as_mut())
+                .await
+                .is_err()
+        );
+
+        drop(event_tx);
+
+        assert_eq!(
+            terminate_response.await,
+            RuntimeResponse::Terminated {
+                cell_id: "cell-1".to_string(),
+                content_items: Vec::new(),
+            }
+        );
+
+        let _ = runtime_tx.send(RuntimeCommand::Terminate);
+    }
+}
@@ -31,17 +31,18 @@ codex-api = { workspace = true }
 codex-app-server-protocol = { workspace = true }
 codex-apply-patch = { workspace = true }
 codex-async-utils = { workspace = true }
-codex-client = { workspace = true }
+codex-code-mode = { workspace = true }
 codex-connectors = { workspace = true }
 codex-config = { workspace = true }
 codex-exec-server = { workspace = true }
+codex-features = { workspace = true }
+codex-login = { workspace = true }
 codex-shell-command = { workspace = true }
 codex-skills = { workspace = true }
 codex-execpolicy = { workspace = true }
 codex-file-search = { workspace = true }
 codex-git = { workspace = true }
 codex-hooks = { workspace = true }
-codex-keyring-store = { workspace = true }
 codex-network-proxy = { workspace = true }
 codex-otel = { workspace = true }
 codex-artifacts = { workspace = true }
@@ -70,11 +71,9 @@ http = { workspace = true }
 iana-time-zone = { workspace = true }
 image = { workspace = true, features = ["jpeg", "png", "webp"] }
 indexmap = { workspace = true }
-keyring = { workspace = true, features = ["crypto-rust"] }
 libc = { workspace = true }
 notify = { workspace = true }
 once_cell = { workspace = true }
-os_info = { workspace = true }
 rand = { workspace = true }
 regex-lite = { workspace = true }
 reqwest = { workspace = true, features = ["json", "stream"] }
@@ -89,7 +88,6 @@ serde = { workspace = true, features = ["derive"] }
 serde_json = { workspace = true }
 serde_yaml = { workspace = true }
 sha1 = { workspace = true }
-sha2 = { workspace = true }
 shlex = { workspace = true }
 similar = { workspace = true }
 tempfile = { workspace = true }
@@ -120,13 +118,11 @@ wildmatch = { workspace = true }
 zip = { workspace = true }

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

 [target.'cfg(target_os = "macos")'.dependencies]
 core-foundation = "0.9"
-keyring = { workspace = true, features = ["apple-native"] }

 # Build OpenSSL from source for musl builds.
 [target.x86_64-unknown-linux-musl.dependencies]
@@ -137,16 +133,12 @@ openssl-sys = { workspace = true, features = ["vendored"] }
 openssl-sys = { workspace = true, features = ["vendored"] }

 [target.'cfg(target_os = "windows")'.dependencies]
-keyring = { workspace = true, features = ["windows-native"] }
 windows-sys = { version = "0.52", features = [
    "Win32_Foundation",
    "Win32_System_Com",
    "Win32_UI_Shell",
 ] }

-[target.'cfg(any(target_os = "freebsd", target_os = "openbsd"))'.dependencies]
-keyring = { workspace = true, features = ["sync-secret-service"] }
-
 [target.'cfg(unix)'.dependencies]
 codex-shell-escalation = { workspace = true }

@@ -61,9 +61,11 @@ cases like `/repo = write`, `/repo/a = none`, `/repo/a/b = write`, where the
 more specific writable child must reopen under a denied parent.

 The Linux sandbox helper prefers `/usr/bin/bwrap` whenever it is available and
-falls back to the vendored bubblewrap path otherwise. When `/usr/bin/bwrap` is
-missing, Codex also surfaces a startup warning through its normal notification
-path instead of printing directly from the sandbox helper.
+supports the required argv-rewrite flags, and falls back to the vendored
+bubblewrap path compiled into the binary otherwise. When `/usr/bin/bwrap` is
+missing or too old to support the required flags, Codex also surfaces a startup
+warning through its normal notification path instead of printing directly from
+the sandbox helper.

 ### Windows

@@ -422,15 +422,15 @@
            "multi_agent": {
              "type": "boolean"
            },
+            "multi_agent_v2": {
+              "type": "boolean"
+            },
            "personality": {
              "type": "boolean"
            },
            "plugins": {
              "type": "boolean"
            },
-            "powershell_utf8": {
-              "type": "boolean"
-            },
            "prevent_idle_sleep": {
              "type": "boolean"
            },
@@ -1524,13 +1524,21 @@
        "enabled": {
          "type": "boolean"
        },
+        "name": {
+          "description": "Name-based selector.",
+          "type": "string"
+        },
        "path": {
-          "$ref": "#/definitions/AbsolutePathBuf"
+          "allOf": [
+            {
+              "$ref": "#/definitions/AbsolutePathBuf"
+            }
+          ],
+          "description": "Path-based selector."
        }
      },
      "required": [
-        "enabled",
-        "path"
+        "enabled"
      ],
      "type": "object"
    },
@@ -2028,15 +2036,15 @@
        "multi_agent": {
          "type": "boolean"
        },
+        "multi_agent_v2": {
+          "type": "boolean"
+        },
        "personality": {
          "type": "boolean"
        },
        "plugins": {
          "type": "boolean"
        },
-        "powershell_utf8": {
-          "type": "boolean"
-        },
        "prevent_idle_sleep": {
          "type": "boolean"
        },
--- a/Show More
+++ b/Show More