Add files using upload-large-folder tool

.bazelignore

@@ -0,0 +1,4 @@
+# Without this, Bazel will consider BUILD.bazel files in
+# .git/sl/origbackups (which can be populated by Sapling SCM).
+.git
+codex-rs/target

.bazelrc

@@ -0,0 +1,229 @@
+common --repo_env=BAZEL_DO_NOT_DETECT_CPP_TOOLCHAIN=1
+common --repo_env=BAZEL_NO_APPLE_CPP_TOOLCHAIN=1
+# Dummy xcode config so we don't need to build xcode_locator in repo rule.
+common --xcode_version_config=//:disable_xcode
+
+common --disk_cache=~/.cache/bazel-disk-cache
+common --repo_contents_cache=~/.cache/bazel-repo-contents-cache
+common --repository_cache=~/.cache/bazel-repo-cache
+common --remote_cache_compression
+startup --experimental_remote_repo_contents_cache
+
+common --experimental_platform_in_output_dir
+
+build --workspace_status_command=./scripts/workspace-status.sh
+build:windows --workspace_status_command=./scripts/workspace-status.cmd
+
+# Runfiles strategy rationale: codex-rs/utils/cargo-bin/README.md
+common --noenable_runfiles
+
+common --enable_platform_specific_config
+common:linux --host_platform=//:local_linux
+common:windows --host_platform=//:local_windows
+common --@rules_cc//cc/toolchains/args/archiver_flags:use_libtool_on_macos=False
+common --@llvm//config:experimental_stub_libgcc_s
+
+# TODO(zbarsky): rules_rust doesn't implement this flag properly with remote exec...
+# common --@rules_rust//rust/settings:pipelined_compilation
+
+common --incompatible_strict_action_env
+# Not ideal, but We need to allow dotslash to be found
+common:linux --test_env=PATH=/usr/local/bin:/usr/bin:/bin:/usr/sbin:/sbin
+common:macos --test_env=PATH=/opt/homebrew/bin:/usr/local/bin:/usr/bin:/bin:/usr/sbin:/sbin
+# Native pkg-config configure checks execute target programs.
+common:macos --strategy=CcConfigureMakeRule=remote,sandboxed,local
+
+# Pass through some env vars Windows needs to use powershell?
+common:windows --test_env=SYSTEMROOT
+common:windows --test_env=COMSPEC
+common:windows --test_env=WINDIR
+# Rust's libtest harness runs test bodies on std-spawned threads. The default
+# 2 MiB stack can be too small for large async test futures on Windows CI; see
+# https://github.com/openai/codex/pull/19067 for the motivating failure.
+common --test_env=RUST_MIN_STACK=8388608 # 8 MiB
+
+common --test_output=errors
+common --nobuild_runfile_links
+# These settings tune BuildBuddy/RBE behavior but do not contact a remote
+# service unless a `buildbuddy-*` configuration below supplies an endpoint.
+common --remote_download_toplevel
+common --remote_timeout=3600
+common --noexperimental_throttle_remote_action_building
+common --experimental_remote_execution_keepalive
+common --grpc_keepalive_time=30s
+
+# Opt-in remote configurations selected by
+# `.github/scripts/run_bazel_with_buildbuddy.py`. Plain Bazel commands do not
+# contact BuildBuddy unless a user selects one of these configurations.
+# Use the generic host for cache, BES, and downloads without remote execution.
+common:buildbuddy-generic --bes_backend=grpcs://remote.buildbuddy.io
+common:buildbuddy-generic --bes_results_url=https://app.buildbuddy.io/invocation/
+common:buildbuddy-generic --remote_cache=grpcs://remote.buildbuddy.io
+common:buildbuddy-generic --experimental_remote_downloader=grpcs://remote.buildbuddy.io
+
+# Add remote execution on the generic host.
+common:buildbuddy-generic-rbe --config=buildbuddy-generic
+common:buildbuddy-generic-rbe --config=remote
+common:buildbuddy-generic-rbe --remote_executor=grpcs://remote.buildbuddy.io
+
+# Use the OpenAI tenant for cache, BES, and downloads without remote execution.
+common:buildbuddy-openai --bes_backend=grpcs://openai.buildbuddy.io
+common:buildbuddy-openai --bes_results_url=https://openai.buildbuddy.io/invocation/
+common:buildbuddy-openai --remote_cache=grpcs://openai.buildbuddy.io
+common:buildbuddy-openai --experimental_remote_downloader=grpcs://openai.buildbuddy.io
+
+# Add remote execution on the OpenAI tenant.
+common:buildbuddy-openai-rbe --config=buildbuddy-openai
+common:buildbuddy-openai-rbe --config=remote
+common:buildbuddy-openai-rbe --remote_executor=grpcs://openai.buildbuddy.io
+
+# This limits both in-flight executions and concurrent downloads. Even with high number
+# of jobs execution will still be limited by CPU cores, so this just pays a bit of
+# memory in exchange for higher download concurrency.
+common --jobs=30
+
+# Shared remote execution policy. The endpoint-bearing `buildbuddy-*-rbe`
+# configurations include this group; CI configs override TestRunner below
+# when tests must remain local on their runner.
+common:remote --strategy=remote
+# Native Mac voice actions need the local Apple tools; Linux remains remote.
+common:macos --strategy=VoiceNativePrefix=remote,sandboxed,local
+common:macos --strategy=VoiceNativeRuntime=remote,sandboxed,local
+common:remote --extra_execution_platforms=//:rbe
+common:remote --jobs=800
+# TODO(team): Evaluate if this actually helps, zbarsky is not sure, everything seems bottlenecked on `core` either way.
+# Enable pipelined compilation since we are not bound by local CPU count.
+#common:remote --@rules_rust//rust/settings:pipelined_compilation
+
+# GitHub Actions CI configs.
+common:ci --remote_download_minimal
+common:ci --keep_going
+common:ci --verbose_failures
+common:ci --build_metadata=REPO_URL=https://github.com/openai/codex.git
+common:ci --build_metadata=ROLE=CI
+common:ci --build_metadata=VISIBILITY=PUBLIC
+
+# Disable disk cache in CI since we have a remote one and aren't using persistent workers.
+common:ci --disk_cache=
+
+# Shared config for the main Bazel CI workflow.
+common:ci-bazel --config=ci
+common:ci-bazel --build_metadata=TAG_workflow=bazel
+
+# Shared config for Bazel-backed Rust linting.
+build:clippy --aspects=@rules_rust//rust:defs.bzl%rust_clippy_aspect
+build:clippy --output_groups=+clippy_checks
+build:clippy --@rules_rust//rust/settings:clippy.toml=//codex-rs:clippy.toml
+# Keep this deny-list in sync with `codex-rs/Cargo.toml` `[workspace.lints.clippy]`.
+# Cargo applies those lint levels to member crates that opt into `[lints] workspace = true`
+# in their own `Cargo.toml`, but `rules_rust` Bazel clippy does not read Cargo lint levels.
+# `clippy.toml` can configure lint behavior, but it cannot set allow/warn/deny/forbid levels.
+build:clippy --@rules_rust//rust/settings:clippy_flag=-Dwarnings
+build:clippy --@rules_rust//rust/settings:clippy_flag=--deny=clippy::await_holding_invalid_type
+build:clippy --@rules_rust//rust/settings:clippy_flag=--deny=clippy::await_holding_lock
+build:clippy --@rules_rust//rust/settings:clippy_flag=--deny=clippy::disallowed_methods
+build:clippy --@rules_rust//rust/settings:clippy_flag=--deny=clippy::expect_used
+build:clippy --@rules_rust//rust/settings:clippy_flag=--deny=clippy::identity_op
+build:clippy --@rules_rust//rust/settings:clippy_flag=--deny=clippy::manual_clamp
+build:clippy --@rules_rust//rust/settings:clippy_flag=--deny=clippy::manual_filter
+build:clippy --@rules_rust//rust/settings:clippy_flag=--deny=clippy::manual_find
+build:clippy --@rules_rust//rust/settings:clippy_flag=--deny=clippy::manual_flatten
+build:clippy --@rules_rust//rust/settings:clippy_flag=--deny=clippy::manual_map
+build:clippy --@rules_rust//rust/settings:clippy_flag=--deny=clippy::manual_memcpy
+build:clippy --@rules_rust//rust/settings:clippy_flag=--deny=clippy::manual_non_exhaustive
+build:clippy --@rules_rust//rust/settings:clippy_flag=--deny=clippy::manual_ok_or
+build:clippy --@rules_rust//rust/settings:clippy_flag=--deny=clippy::manual_range_contains
+build:clippy --@rules_rust//rust/settings:clippy_flag=--deny=clippy::manual_retain
+build:clippy --@rules_rust//rust/settings:clippy_flag=--deny=clippy::manual_strip
+build:clippy --@rules_rust//rust/settings:clippy_flag=--deny=clippy::manual_try_fold
+build:clippy --@rules_rust//rust/settings:clippy_flag=--deny=clippy::manual_unwrap_or
+build:clippy --@rules_rust//rust/settings:clippy_flag=--deny=clippy::needless_borrow
+build:clippy --@rules_rust//rust/settings:clippy_flag=--deny=clippy::needless_borrowed_reference
+build:clippy --@rules_rust//rust/settings:clippy_flag=--deny=clippy::needless_collect
+build:clippy --@rules_rust//rust/settings:clippy_flag=--deny=clippy::needless_late_init
+build:clippy --@rules_rust//rust/settings:clippy_flag=--deny=clippy::needless_option_as_deref
+build:clippy --@rules_rust//rust/settings:clippy_flag=--deny=clippy::needless_question_mark
+build:clippy --@rules_rust//rust/settings:clippy_flag=--deny=clippy::needless_update
+build:clippy --@rules_rust//rust/settings:clippy_flag=--deny=clippy::redundant_clone
+build:clippy --@rules_rust//rust/settings:clippy_flag=--deny=clippy::redundant_closure
+build:clippy --@rules_rust//rust/settings:clippy_flag=--deny=clippy::redundant_closure_for_method_calls
+build:clippy --@rules_rust//rust/settings:clippy_flag=--deny=clippy::redundant_static_lifetimes
+build:clippy --@rules_rust//rust/settings:clippy_flag=--deny=clippy::trivially_copy_pass_by_ref
+build:clippy --@rules_rust//rust/settings:clippy_flag=--deny=clippy::uninlined_format_args
+build:clippy --@rules_rust//rust/settings:clippy_flag=--deny=clippy::unnecessary_filter_map
+build:clippy --@rules_rust//rust/settings:clippy_flag=--deny=clippy::unnecessary_lazy_evaluations
+build:clippy --@rules_rust//rust/settings:clippy_flag=--deny=clippy::unnecessary_sort_by
+build:clippy --@rules_rust//rust/settings:clippy_flag=--deny=clippy::unnecessary_to_owned
+build:clippy --@rules_rust//rust/settings:clippy_flag=--deny=clippy::unwrap_used
+
+# Shared config for Bazel-backed argument-comment-lint.
+build:argument-comment-lint --aspects=//tools/argument-comment-lint:lint_aspect.bzl%rust_argument_comment_lint_aspect
+build:argument-comment-lint --output_groups=argument_comment_lint_checks
+build:argument-comment-lint --@rules_rust//rust/toolchain/channel=nightly
+
+# Rearrange caches on Windows so they're on the same volume as the checkout.
+common:ci-windows --config=ci-bazel
+common:ci-windows --build_metadata=TAG_os=windows
+common:ci-windows --repo_contents_cache=D:/a/.cache/bazel-repo-contents-cache
+# The hidden dynamic-tool callback currently times out on Windows, and ConPTY
+# cannot reliably interrupt foreground processes on Windows Bazel runners.
+common:ci-windows --test_env=CODEX_BAZEL_TEST_SKIP_FILTERS=suite::code_mode::code_mode_can_call_hidden_dynamic_tools,tests::windows_tests::conpty_ctrl_c_interrupts_powershell_foreground_child
+
+# We prefer to run the build actions entirely remotely so we can dial up the concurrency.
+# We have platform-specific tests, so we want to execute the tests on all platforms using the strongest sandboxing available on each platform.
+
+# On linux, we can do a full remote build/test, by targeting the right (x86/arm) runners, so we have coverage of both.
+# Linux crossbuilds don't work until we untangle the libc constraint mess.
+common:ci-linux --config=ci-bazel
+common:ci-linux --build_metadata=TAG_os=linux
+common:ci-linux --platforms=//:rbe
+
+# On mac, we can run all the build actions remotely but test actions locally.
+common:ci-macos --config=ci-bazel
+common:ci-macos --build_metadata=TAG_os=macos
+common:ci-macos --strategy=TestRunner=darwin-sandbox,local
+
+# On Windows, use Linux remote execution for build actions but keep test actions
+# on the Windows runner so Bazel's normal test sharding and flaky-test retries
+# still run against Windows binaries.
+common:ci-windows-cross --config=ci-windows
+common:ci-windows-cross --build_metadata=TAG_windows_cross_compile=true
+common:ci-windows-cross --host_platform=//:rbe
+common:ci-windows-cross --strategy=TestRunner=local
+# V8 embeds IsolateData offsets in snapshot builtins; Windows snapshots must be
+# generated by a Windows mksnapshot binary rather than the Linux RBE host tool.
+common:ci-windows-cross --strategy=V8Mksnapshot=local
+common:ci-windows-cross --local_test_jobs=8
+common:ci-windows-cross --test_env=RUST_TEST_THREADS=1
+# Native Windows CI still covers the PowerShell parser-process tests. The
+# cross-built gnullvm binaries currently hang in those tests when run on the
+# Windows runner. This replaces the Windows skip list, so retain its exclusions.
+common:ci-windows-cross --test_env=CODEX_BAZEL_TEST_SKIP_FILTERS=command_safety::powershell_parser::tests::,suite::code_mode::code_mode_can_call_hidden_dynamic_tools,tests::windows_tests::conpty_ctrl_c_interrupts_powershell_foreground_child
+common:ci-windows-cross --platforms=//:windows_x86_64_gnullvm
+common:ci-windows-cross --extra_execution_platforms=//:rbe,//:windows_x86_64_msvc
+common:ci-windows-cross --extra_toolchains=//:windows_gnullvm_tests_on_msvc_host_toolchain
+
+# Linux-only V8 CI config.
+common:ci-v8 --config=ci
+common:ci-v8 --build_metadata=TAG_workflow=v8
+common:ci-v8 --build_metadata=TAG_os=linux
+
+# Source-built Bazel V8 artifacts use the in-process sandbox by default. This
+# does not affect Cargo's default prebuilt rusty_v8 path.
+common --@v8//:v8_enable_pointer_compression=True
+common --@v8//:v8_enable_sandbox=True
+
+# Keep currently published rusty_v8 release artifacts non-sandboxed until the
+# artifact migration ships matching Rust feature selection for Cargo consumers.
+common:v8-release-compat --@v8//:v8_enable_pointer_compression=False
+common:v8-release-compat --@v8//:v8_enable_sandbox=False
+common:v8-target-x64 --@v8//bazel/config:v8_target_cpu=x64
+common:v8-target-arm64 --@v8//bazel/config:v8_target_cpu=arm64
+
+# Match rusty_v8's upstream GN release contract for published artifacts: every
+# target object uses Chromium's custom libc++ headers and the archive folds in
+# the matching runtime objects.
+common:rusty-v8-upstream-libcxx --@v8//:v8_use_rusty_v8_custom_libcxx=True
+
+# Optional per-user local overrides.
+try-import %workspace%/user.bazelrc

.bazelversion

@@ -0,0 +1 @@
+9.0.0

.codespellignore

@@ -0,0 +1,7 @@
+iTerm
+iTerm2
+numer
+psuedo
+SOM
+te
+TE

.codespellrc

@@ -0,0 +1,6 @@
+[codespell]
+# Ref: https://github.com/codespell-project/codespell#using-a-config-file
+skip = .git*,vendor,*-lock.yaml,*.lock,.codespellrc,*test.ts,*.jsonl,frame*.txt,*.snap,*.snap.new
+check-hidden = true
+ignore-regex = ^\s*"image/\S+": ".*|\b(afterAll)\b
+ignore-words-list = ratatui,ser,iTerm,iterm2,iterm,te,TE,PASE,SEH

.gitattributes

@@ -1,35 +1,3 @@
-*.7z filter=lfs diff=lfs merge=lfs -text
-*.arrow filter=lfs diff=lfs merge=lfs -text
-*.bin filter=lfs diff=lfs merge=lfs -text
-*.bz2 filter=lfs diff=lfs merge=lfs -text
-*.ckpt filter=lfs diff=lfs merge=lfs -text
-*.ftz filter=lfs diff=lfs merge=lfs -text
-*.gz filter=lfs diff=lfs merge=lfs -text
-*.h5 filter=lfs diff=lfs merge=lfs -text
-*.joblib filter=lfs diff=lfs merge=lfs -text
-*.lfs.* filter=lfs diff=lfs merge=lfs -text
-*.mlmodel filter=lfs diff=lfs merge=lfs -text
-*.model filter=lfs diff=lfs merge=lfs -text
-*.msgpack filter=lfs diff=lfs merge=lfs -text
-*.npy filter=lfs diff=lfs merge=lfs -text
-*.npz filter=lfs diff=lfs merge=lfs -text
-*.onnx filter=lfs diff=lfs merge=lfs -text
-*.ot filter=lfs diff=lfs merge=lfs -text
-*.parquet filter=lfs diff=lfs merge=lfs -text
-*.pb filter=lfs diff=lfs merge=lfs -text
-*.pickle filter=lfs diff=lfs merge=lfs -text
-*.pkl filter=lfs diff=lfs merge=lfs -text
-*.pt filter=lfs diff=lfs merge=lfs -text
-*.pth filter=lfs diff=lfs merge=lfs -text
-*.rar filter=lfs diff=lfs merge=lfs -text
-*.safetensors filter=lfs diff=lfs merge=lfs -text
-saved_model/**/* filter=lfs diff=lfs merge=lfs -text
-*.tar.* filter=lfs diff=lfs merge=lfs -text
-*.tar filter=lfs diff=lfs merge=lfs -text
-*.tflite filter=lfs diff=lfs merge=lfs -text
-*.tgz filter=lfs diff=lfs merge=lfs -text
-*.wasm filter=lfs diff=lfs merge=lfs -text
-*.xz filter=lfs diff=lfs merge=lfs -text
-*.zip filter=lfs diff=lfs merge=lfs -text
-*.zst filter=lfs diff=lfs merge=lfs -text
-*tfevents* filter=lfs diff=lfs merge=lfs -text
+codex-rs/app-server-protocol/schema/** linguist-generated
+codex-rs/hooks/schema/generated/** linguist-generated
+third_party/voice/sources.json text eol=lf

.gitignore

@@ -0,0 +1,96 @@
+# deps
+# Node.js dependencies
+node_modules
+.pnpm-store
+.pnpm-debug.log
+
+# Keep pnpm-lock.yaml
+!pnpm-lock.yaml
+
+# build
+dist/
+bazel-*
+user.bazelrc
+build/
+out/
+storybook-static/
+
+# ignore README for publishing
+codex-cli/README.md
+
+# ignore Nix derivation results
+result
+
+# editor
+.vscode/
+.idea/
+.history/
+.zed/
+*.swp
+*~
+
+# cli tools
+CLAUDE.md
+.claude/
+AGENTS.override.md
+
+# caches
+.cache/
+.turbo/
+.parcel-cache/
+.eslintcache
+.nyc_output/
+.jest/
+*.tsbuildinfo
+
+# logs
+*.log
+npm-debug.log*
+yarn-debug.log*
+yarn-error.log*
+
+# env
+.env*
+!.env.example
+.venv/
+
+# package
+*.tgz
+
+# ci
+.vercel/
+.netlify/
+/.tmp/sdk-ci/
+/upstream-rusty-v8/
+
+# patches
+apply_patch/
+
+# coverage
+coverage/
+
+# personal files
+personal/
+
+# os
+.DS_Store
+Thumbs.db
+Icon?
+.Spotlight-V100/
+
+# Unwanted package managers
+.yarn/
+yarn.lock
+
+# release
+package.json-e
+session.ts-e
+CHANGELOG.ignore.md
+
+# nix related
+.direnv
+.envrc
+
+# Python bytecode files
+__pycache__/
+*.pyc

.markdownlint-cli2.yaml

@@ -0,0 +1,6 @@
+config:
+  MD013:
+    line_length: 100
+
+globs:
+  - "docs/tui-chat-composer.md"

.npmrc

@@ -0,0 +1,4 @@
+shamefully-hoist=true
+strict-peer-dependencies=false
+node-linker=hoisted
+prefer-workspace-packages=true

.prettierignore

@@ -0,0 +1,7 @@
+/codex-cli/dist
+/codex-cli/node_modules
+pnpm-lock.yaml
+
+prompt.md
+*_prompt.md
+*_instructions.md

.prettierrc.toml

@@ -0,0 +1,8 @@
+printWidth = 80
+quoteProps = "consistent"
+semi = true
+tabWidth = 2
+trailingComma = "all"
+
+# Preserve existing behavior for markdown/text wrapping.
+proseWrap = "preserve"

.worktreeinclude

@@ -0,0 +1 @@
+user.bazelrc

AGENTS.md

@@ -0,0 +1,320 @@
+# Rust/codex-rs
+
+In the codex-rs folder where the rust code lives:
+
+- Crate names are prefixed with `codex-`. For example, the `core` folder's crate is named `codex-core`
+- When using format! and you can inline variables into {}, always do that.
+- Install any commands the repo relies on (for example `just`, `rg`, or `cargo-insta`) if they aren't already available before running instructions here.
+- Never add or modify any code related to `CODEX_SANDBOX_NETWORK_DISABLED_ENV_VAR` or `CODEX_SANDBOX_ENV_VAR`.
+  - You operate in a sandbox where `CODEX_SANDBOX_NETWORK_DISABLED=1` will be set whenever you use the `shell` tool. Any existing code that uses `CODEX_SANDBOX_NETWORK_DISABLED_ENV_VAR` was authored with this fact in mind. It is often used to early exit out of tests that the author knew you would not be able to run given your sandbox limitations.
+  - Similarly, when you spawn a process using Seatbelt (`/usr/bin/sandbox-exec`), `CODEX_SANDBOX=seatbelt` will be set on the child process. Integration tests that want to run Seatbelt themselves cannot be run under Seatbelt, so checks for `CODEX_SANDBOX=seatbelt` are also often used to early exit out of tests, as appropriate.
+- Always collapse if statements per https://rust-lang.github.io/rust-clippy/master/index.html#collapsible_if
+- Always inline format! args when possible per https://rust-lang.github.io/rust-clippy/master/index.html#uninlined_format_args
+- Use method references over closures when possible per https://rust-lang.github.io/rust-clippy/master/index.html#redundant_closure_for_method_calls
+- Avoid bool or ambiguous `Option` parameters that force callers to write hard-to-read code such as `foo(false)` or `bar(None)`. Prefer enums, named methods, newtypes, or other idiomatic Rust API shapes when they keep the callsite self-documenting.
+- When you cannot make that API change and still need a small positional-literal callsite in Rust, follow the `argument_comment_lint` convention:
+  - Use an exact `/*param_name*/` comment before opaque literal arguments such as `None`, booleans, and numeric literals when passing them by position.
+  - A method's sole non-self argument is exempt when the method and parameter names match, such as `.enabled(false)` for `fn enabled(&self, enabled: bool)`.
+  - Do not add these comments for string or char literals unless the comment adds real clarity; those literals are intentionally exempt from the lint.
+  - The parameter name in the comment must exactly match the callee signature.
+  - You can run `just argument-comment-lint` to run the lint check locally. This is powered by Bazel, so running it the first time can be slow if Bazel is not warmed up, though incremental invocations should take <15s. Most of the time, it is best to update the PR and let CI take responsibility for checking this (or run it asynchronously in the background after submitting the PR). Note CI checks all three platforms, which the local run does not.
+- When possible, make `match` statements exhaustive and avoid wildcard arms.
+- Newly added traits should include doc comments that explain their role and how implementations are expected to use them.
+- Discourage both `#[async_trait]` and `#[allow(async_fn_in_trait)]` in Rust traits.
+  - Prefer native RPITIT trait methods with explicit `Send` bounds on the returned future, as in `3c7f013f9735` / `#16630`.
+  - Preferred trait shape:
+    `fn foo(&self, ...) -> impl std::future::Future<Output = T> + Send;`
+  - Implementations may still use `async fn foo(&self, ...) -> T` when they satisfy that contract.
+  - Do not use `#[allow(async_fn_in_trait)]` as a shortcut around spelling the future contract explicitly.
+- When writing tests, prefer comparing the equality of entire objects over fields one by one.
+- Do not add tests for values that are statically defined.
+- Do not add negative tests for logic that was removed.
+- Do not add general product or user-facing documentation to the `docs/` folder. The official Codex documentation lives elsewhere. The exception is app-server API documentation, which is covered by the app-server guidance below.
+- Prefer private modules and explicitly exported public crate API.
+- If you change `ConfigToml` or nested config types, run `just write-config-schema` to update `codex-rs/core/config.schema.json`.
+- When working with MCP tool calls, prefer using `codex-rs/codex-mcp/src/mcp_connection_manager.rs` to handle mutation of tools and tool calls. Aim to minimize the footprint of changes and leverage existing abstractions rather than plumbing code through multiple levels of function calls.
+- Do not call `reset_client_session` unnecessarily; let the incremental check logic decide whether to reuse the previous request.
+- If you change Rust dependencies (`Cargo.toml` or `Cargo.lock`), run `just bazel-lock-update` from the
+  repo root to refresh `MODULE.bazel.lock`, and include that lockfile update in the same change. CI
+  verifies lockfile drift.
+- Bazel does not automatically make source-tree files available to compile-time Rust file access. If
+  you add `include_str!`, `include_bytes!`, `sqlx::migrate!`, or similar build-time file or
+  directory reads, update the crate's `BUILD.bazel` (`compile_data`, `build_script_data`, or test
+  data) or Bazel may fail even when Cargo passes.
+- Do not create small helper methods that are referenced only once.
+- For tracing async work, instrument the function or method definition with
+  `#[tracing::instrument(...)]` instead of attaching spans to futures with
+  `.instrument(...)` at call sites. Before adding instrumentation, check whether the callee—or
+  the implementation method it immediately delegates to—is already instrumented.
+- Avoid large modules:
+  - Prefer adding new modules instead of growing existing ones.
+  - Target Rust modules under 500 LoC, excluding tests.
+  - If a file exceeds roughly 800 LoC, add new functionality in a new module instead of extending
+    the existing file unless there is a strong documented reason not to.
+  - This rule applies especially to high-touch files that already attract unrelated changes, such
+    as `codex-rs/tui/src/app.rs`, `codex-rs/tui/src/bottom_pane/chat_composer.rs`,
+    `codex-rs/tui/src/bottom_pane/footer.rs`, `codex-rs/tui/src/chatwidget.rs`,
+    `codex-rs/tui/src/bottom_pane/mod.rs`, and similarly central orchestration modules.
+  - When extracting code from a large module, move the related tests and module/type docs toward
+    the new implementation so the invariants stay close to the code that owns them.
+  - Avoid adding new standalone methods to `codex-rs/tui/src/chatwidget.rs` unless the change is
+    trivial; prefer new modules/files and keep `chatwidget.rs` focused on orchestration.
+- When running Rust commands (e.g. `just fix` or `just test`) be patient with the command and never try to kill them using the PID. Rust lock can make the execution slow, this is expected.
+
+Run `just fmt` (in the `codex-rs` directory) automatically after you have finished making code changes anywhere in this repository; do not ask for approval to run it. Additionally, run the tests:
+
+1. Do not run `cargo test` directly. Use `just test` so test execution follows the repo defaults.
+2. Run the test for the specific project that was changed. For example, if changes were made in `codex-rs/tui`, run `just test -p codex-tui`.
+3. Once those pass, if any changes were made in common, core, or protocol, run the complete test suite with `just test`. Avoid `--all-features` for routine local runs because it expands the build matrix and can significantly increase `target/` disk usage; use it only when you specifically need full feature coverage. project-specific or individual tests can be run without asking the user, but do ask the user before running the complete test suite.
+
+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`.
+
+## The `codex-core` crate
+
+Over time, the `codex-core` crate (defined in `codex-rs/core/`) has become bloated because it is the largest crate, so it is often easier to add something new to `codex-core` rather than refactor out the library code you need so your new code neither takes a dependency on, nor contributes to the size of, `codex-core`.
+
+To that end: **resist adding code to codex-core**!
+
+Particularly when introducing a new concept/feature/API, before adding to `codex-core`, consider whether:
+
+- There is an existing crate other than `codex-core` that is an appropriate place for your new code to live.
+- It is time to introduce a new crate to the Cargo workspace for your new functionality. Refactor existing code as necessary to make this happen.
+
+Likewise, when reviewing code, do not hesitate to push back on PRs that would unnecessarily add code to `codex-core`.
+
+## Code Review Rules
+
+### Crate API surface
+
+Keep crate API surfaces as small as possible. Avoid proliferating test-only helpers.
+
+### Model visible context
+
+Codex maintains a context (history of messages) that is sent to the model in inference requests.
+
+1. No history rewrite - the context must be built up incrementally.
+2. Avoid frequent changes to context that cause cache misses.
+3. No unbounded items - everything injected in the model context must have a bounded size and a hard cap.
+4. No items larger than 10K tokens.
+5. Highlight new individual items that can cross >1k tokens as P0. These need an additional manual review.
+6. All injected fragments must be defined as structs in `core/context` and implement ContextualUserFragment trait
+
+### Breaking changes
+
+Search for breaking changes in external integration surfaces:
+
+- app-server APIs
+- raw response item events (`rawResponseItem/*`), even while experimental
+- CLI parameters
+- configuration loading
+- resuming sessions from existing rollouts
+
+### Test authoring guidance
+
+For agent changes prefer integration tests over unit tests. Integration tests are under `core/suite` and use `test_codex` to set up a test instance of codex.
+
+Features that change the agent logic MUST add an integration test:
+
+- Provide a list of major logic changes and user-facing behaviors that need to be tested.
+
+If unit tests are needed, put them in a dedicated test file (\*\_tests.rs).
+Avoid test-only functions in the main implementation.
+
+Check whether there are existing helpers to make tests more streamlined and readable.
+
+### Change size guidance (800 lines)
+
+Unless the change is mechanical the total number of changed lines should not exceed 800 lines.
+For complex logic changes the size should be under 500 lines.
+
+If the change is larger, explore whether it can be split into reviewable stages and identify the smallest coherent stage to land first.
+Base the staging suggestion on the actual diff, dependencies, and affected call sites.
+
+## TUI style conventions
+
+See `codex-rs/tui/styles.md`.
+
+## TUI code conventions
+
+- Use concise styling helpers from ratatui’s Stylize trait.
+  - Basic spans: use "text".into()
+  - Styled spans: use "text".red(), "text".green(), "text".magenta(), "text".dim(), etc.
+  - Prefer these over constructing styles with `Span::styled` and `Style` directly.
+  - Example: patch summary file lines
+    - Desired: vec!["  └ ".into(), "M".red(), " ".dim(), "tui/src/app.rs".dim()]
+
+### TUI Styling (ratatui)
+
+- Prefer Stylize helpers: use "text".dim(), .bold(), .cyan(), .italic(), .underlined() instead of manual Style where possible.
+- Prefer simple conversions: use "text".into() for spans and vec![…].into() for lines; when inference is ambiguous (e.g., Paragraph::new/Cell::from), use Line::from(spans) or Span::from(text).
+- Computed styles: if the Style is computed at runtime, using `Span::styled` is OK (`Span::from(text).set_style(style)` is also acceptable).
+- Avoid hardcoded white: do not use `.white()`; prefer the default foreground (no color).
+- Chaining: combine helpers by chaining for readability (e.g., url.cyan().underlined()).
+- Single items: prefer "text".into(); use Line::from(text) or Span::from(text) only when the target type isn’t obvious from context, or when using .into() would require extra type annotations.
+- Building lines: use vec![…].into() to construct a Line when the target type is obvious and no extra type annotations are needed; otherwise use Line::from(vec![…]).
+- Avoid churn: don’t refactor between equivalent forms (Span::styled ↔ set_style, Line::from ↔ .into()) without a clear readability or functional gain; follow file‑local conventions and do not introduce type annotations solely to satisfy .into().
+- Compactness: prefer the form that stays on one line after rustfmt; if only one of Line::from(vec![…]) or vec![…].into() avoids wrapping, choose that. If both wrap, pick the one with fewer wrapped lines.
+
+### Text wrapping
+
+- Always use textwrap::wrap to wrap plain strings.
+- If you have a ratatui Line and you want to wrap it, use the helpers in tui/src/wrapping.rs, e.g. word_wrap_lines / word_wrap_line.
+- If you need to indent wrapped lines, use the initial_indent / subsequent_indent options from RtOptions if you can, rather than writing custom logic.
+- If you have a list of lines and you need to prefix them all with some prefix (optionally different on the first vs subsequent lines), use the `prefix_lines` helper from line_utils.
+
+## Tests
+
+### Test module organization
+
+- When adding a new test module, define its contents in a separate sibling file rather than inline in the implementation file.
+- Use an explicit `#[path = "..._tests.rs"]` attribute so the test filename is descriptive and easy to locate:
+
+  ```rust
+  #[cfg(test)]
+  #[path = "parser_tests.rs"]
+  mod tests;
+  ```
+
+- This applies only when introducing a new test module. Do not move or rewrite existing inline `#[cfg(test)] mod tests { ... }` modules solely to follow this convention.
+
+### Snapshot tests
+
+This repo uses snapshot tests (via `insta`), especially in `codex-rs/tui`, to validate rendered output.
+
+**Requirement:** any change that affects user-visible UI (including adding new UI) must include
+corresponding `insta` snapshot coverage (add a new snapshot test if one doesn't exist yet, or
+update the existing snapshot). Review and accept snapshot updates as part of the PR so UI impact
+is easy to review and future diffs stay visual.
+
+When UI or text output changes intentionally, update the snapshots as follows:
+
+- Run tests to generate any updated snapshots:
+  - `just test -p codex-tui`
+- Check what’s pending:
+  - `cargo insta pending-snapshots -p codex-tui`
+- Review changes by reading the generated `*.snap.new` files directly in the repo, or preview a specific file:
+  - `cargo insta show -p codex-tui path/to/file.snap.new`
+- Only if you intend to accept all new snapshots in this crate, run:
+  - `cargo insta accept -p codex-tui`
+
+If you don’t have the tool:
+
+- `cargo install --locked cargo-insta`
+
+### Benchmarks
+
+cargo benchmarks can be run with `just bench`, use the divan crate to write new ones.
+
+Use `just bench-smoke` to dry-run the benchmark for a single iteration to ensure it works.
+
+### Test assertions
+
+- Tests should use pretty_assertions::assert_eq for clearer diffs. Import this at the top of the test module if it isn't already.
+- Prefer deep equals comparisons whenever possible. Perform `assert_eq!()` on entire objects, rather than individual fields.
+- Avoid mutating process environment in tests; prefer passing environment-derived flags or dependencies from above.
+
+### Spawning workspace binaries in tests (Cargo vs Bazel)
+
+- Prefer `codex_utils_cargo_bin::cargo_bin("...")` over `assert_cmd::Command::cargo_bin(...)` or `escargot` when tests need to spawn first-party binaries.
+  - Under Bazel, binaries and resources may live under runfiles; use `codex_utils_cargo_bin::cargo_bin` to resolve absolute paths that remain stable after `chdir`.
+- When locating fixture files or test resources under Bazel, avoid `env!("CARGO_MANIFEST_DIR")`. Prefer `codex_utils_cargo_bin::find_resource!` so paths resolve correctly under both Cargo and Bazel runfiles.
+
+### Integration tests
+
+#### codex_core integration testing
+
+- Prefer the utilities in `core_test_support::responses` when writing end-to-end Codex tests.
+- Use `TestCodexBuilder::build_with_auto_env()` by default to ensure that new tests work with
+  foreign app/exec OSes. See $remote-tests for details.
+- All `mount_sse*` helpers return a `ResponseMock`; hold onto it so you can assert against outbound `/responses` POST bodies.
+- Use `ResponseMock::single_request()` when a test should only issue one POST, or `ResponseMock::requests()` to inspect every captured `ResponsesRequest`.
+- `ResponsesRequest` exposes helpers (`body_json`, `input`, `function_call_output`, `custom_tool_call_output`, `call_output`, `header`, `path`, `query_param`) so assertions can target structured payloads instead of manual JSON digging.
+- Build SSE payloads with the provided `ev_*` constructors and the `sse(...)`.
+- Prefer `wait_for_event` over `wait_for_event_with_timeout`.
+- Prefer `mount_sse_once` over `mount_sse_once_match` or `mount_sse_sequence`
+
+- Typical pattern:
+
+  ```rust
+  let mock = responses::mount_sse_once(&server, responses::sse(vec![
+      responses::ev_response_created("resp-1"),
+      responses::ev_function_call(call_id, "shell", &serde_json::to_string(&args)?),
+      responses::ev_completed("resp-1"),
+  ])).await;
+
+  codex.submit(Op::UserTurn { ... }).await?;
+
+  // Assert request body if needed.
+  let request = mock.single_request();
+  // assert using request.function_call_output(call_id) or request.json_body() or other helpers.
+  ```
+
+#### app-server integration testing
+
+- Tests should exercise app-server's public JSON-RPC API.
+- Use similar server mocking as for core integration tests.
+- Use `TestAppServer::builder().build()` and `TestAppServer::send_thread_start_request_with_auto_env()`
+  by default to ensure that new tests work with foreign app/exec OSes. See `$remote-tests` for
+  details.
+
+## App-server API Development Best Practices
+
+These guidelines apply to app-server protocol work in `codex-rs`, especially:
+
+- `app-server-protocol/src/protocol/common.rs`
+- `app-server-protocol/src/protocol/v2.rs`
+
+### Core Rules
+
+- All active API development should happen in app-server v2. Do not add new API surface area to v1.
+- Follow payload naming consistently:
+  `*Params` for request payloads, `*Response` for responses, and `*Notification` for notifications.
+- Expose RPC methods as `<resource>/<method>` and keep `<resource>` singular (for example, `thread/read`, `app/list`).
+- Always expose fields as camelCase on the wire with `#[serde(rename_all = "camelCase")]` unless a tagged union or explicit compatibility requirement needs a targeted rename.
+- Always expose string enum values as camelCase on the wire with matching serde and TS `rename_all = "camelCase"` annotations unless an explicit compatibility requirement needs targeted renames.
+- Exception: config RPC payloads are expected to use snake_case to mirror config.toml keys (see the config read/write/list APIs in `app-server-protocol/src/protocol/v2.rs`).
+- Always set `#[ts(export_to = "v2/")]` on v2 request/response/notification types so generated TypeScript lands in the correct namespace.
+- Never use `#[serde(skip_serializing_if = "Option::is_none")]` for v2 API payload fields.
+  Exception: client->server requests that intentionally have no params may use:
+  `params: #[ts(type = "undefined")] #[serde(skip_serializing_if = "Option::is_none")] Option<()>`.
+- Keep Rust and TS wire renames aligned. If a field or variant uses `#[serde(rename = "...")]`, add matching `#[ts(rename = "...")]`.
+- For discriminated unions, use explicit tagging in both serializers:
+  `#[serde(tag = "type", ...)]` and `#[ts(tag = "type", ...)]`.
+- Prefer plain `String` IDs at the API boundary (do UUID parsing/conversion internally if needed).
+- Timestamps should be integer Unix seconds (`i64`) and named `*_at` (for example, `created_at`, `updated_at`, `resets_at`).
+- For experimental API surface area:
+  use `#[experimental("method/or/field")]`, derive `ExperimentalApi` when field-level gating is needed, and use `inspect_params: true` in `common.rs` when only some fields of a method are experimental.
+
+### Client->server request payloads (`*Params`)
+
+- Every optional field must be annotated with `#[ts(optional = nullable)]`. Do not use `#[ts(optional = nullable)]` outside client->server request payloads (`*Params`).
+- Optional collection fields (for example `Vec`, `HashMap`) must use `Option<...>` + `#[ts(optional = nullable)]`. Do not use `#[serde(default)]` to model optional collections, and do not use `skip_serializing_if` on v2 payload fields.
+- When you want omission to mean `false` for boolean fields, use `#[serde(default, skip_serializing_if = "std::ops::Not::not")] pub field: bool` over `Option<bool>`.
+- For new list methods, implement cursor pagination by default:
+  request fields `pub cursor: Option<String>` and `pub limit: Option<u32>`,
+  response fields `pub data: Vec<...>` and `pub next_cursor: Option<String>`.
+
+### Development Workflow
+
+- Regenerate schema fixtures when API shapes change:
+  `just write-app-server-schema`
+  (and `just write-app-server-schema --experimental` when experimental API fixtures are affected).
+- Validate with `just test -p codex-app-server-protocol`.
+- Avoid boilerplate tests that only assert experimental field markers for individual
+  request fields in `common.rs`; rely on schema generation/tests and behavioral coverage instead.
+
+## Python Development Best Practices
+
+### Ignore Python 2 compatibility
+
+This project uses Python 3+. You should not use the `__future__` module.
+
+If you need to worry about feature compatibility between different 3.xx point releases, check the
+closest `pyproject.toml`'s `requires-python` field to see what minimum runtime version is supported.
+
+## Platform Support
+
+Tests and features must support Linux, macOS and Windows unless feature is explicitly OS-specific.
+
+Codex supports running connected app-server and exec-server on different operating systems. See the
+`$remote-tests` skill for details about integration testing these configurations.

BUILD.bazel

@@ -0,0 +1,79 @@
+load("@apple_support//xcode:xcode_config.bzl", "xcode_config")
+
+xcode_config(name = "disable_xcode")
+
+# We mark the local platform as glibc-compatible so that rust can grab a toolchain for us.
+# TODO(zbarsky): Upstream a better libc constraint into rules_rust.
+# We only enable this on linux though for sanity, and because it breaks remote execution.
+platform(
+    name = "local_linux",
+    constraint_values = [
+        # We mark the local platform as glibc-compatible because musl-built rust cannot dlopen proc macros.
+        "@llvm//constraints/libc:gnu.2.28",
+    ],
+    parents = ["@platforms//host"],
+)
+
+platform(
+    name = "local_windows",
+    constraint_values = [
+        "@llvm//constraints/windows/abi:gnullvm",
+        "@llvm//constraints/windows/crt:msvcrt",
+    ],
+    parents = ["@platforms//host"],
+)
+
+platform(
+    name = "local_windows_msvc",
+    constraint_values = [
+        "@llvm//constraints/windows/abi:msvc",
+    ],
+    parents = ["@platforms//host"],
+)
+
+platform(
+    name = "windows_x86_64_gnullvm",
+    constraint_values = [
+        "@platforms//cpu:x86_64",
+        "@platforms//os:windows",
+        "@llvm//constraints/windows/abi:gnullvm",
+        "@llvm//constraints/windows/crt:msvcrt",
+    ],
+)
+
+platform(
+    name = "windows_x86_64_msvc",
+    constraint_values = [
+        "@platforms//cpu:x86_64",
+        "@platforms//os:windows",
+        "@llvm//constraints/windows/abi:msvc",
+    ],
+)
+
+toolchain(
+    name = "windows_gnullvm_tests_on_msvc_host_toolchain",
+    exec_compatible_with = [
+        "@platforms//cpu:x86_64",
+        "@platforms//os:windows",
+        "@llvm//constraints/windows/abi:msvc",
+    ],
+    target_compatible_with = [
+        "@platforms//cpu:x86_64",
+        "@platforms//os:windows",
+        "@llvm//constraints/windows/abi:gnullvm",
+        "@llvm//constraints/windows/crt:msvcrt",
+    ],
+    toolchain = "@bazel_tools//tools/test:empty_toolchain",
+    toolchain_type = "@bazel_tools//tools/test:default_test_toolchain_type",
+)
+
+alias(
+    name = "rbe",
+    actual = "@rbe_platform",
+)
+
+exports_files([
+    "AGENTS.md",
+    "workspace_root_test_launcher.bat.tpl",
+    "workspace_root_test_launcher.sh.tpl",
+])

CHANGELOG.md

@@ -0,0 +1 @@
+The changelog can be found on the [releases page](https://github.com/openai/codex/releases).

LICENSE

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+1.  Definitions.
+
+    "License" shall mean the terms and conditions for use, reproduction,
+    and distribution as defined by Sections 1 through 9 of this document.
+
+    "Licensor" shall mean the copyright owner or entity authorized by
+    the copyright owner that is granting the License.
+
+    "Legal Entity" shall mean the union of the acting entity and all
+    other entities that control, are controlled by, or are under common
+    control with that entity. For the purposes of this definition,
+    "control" means (i) the power, direct or indirect, to cause the
+    direction or management of such entity, whether by contract or
+    otherwise, or (ii) ownership of fifty percent (50%) or more of the
+    outstanding shares, or (iii) beneficial ownership of such entity.
+
+    "You" (or "Your") shall mean an individual or Legal Entity
+    exercising permissions granted by this License.
+
+    "Source" form shall mean the preferred form for making modifications,
+    including but not limited to software source code, documentation
+    source, and configuration files.
+
+    "Object" form shall mean any form resulting from mechanical
+    transformation or translation of a Source form, including but
+    not limited to compiled object code, generated documentation,
+    and conversions to other media types.
+
+    "Work" shall mean the work of authorship, whether in Source or
+    Object form, made available under the License, as indicated by a
+    copyright notice that is included in or attached to the work
+    (an example is provided in the Appendix below).
+
+    "Derivative Works" shall mean any work, whether in Source or Object
+    form, that is based on (or derived from) the Work and for which the
+    editorial revisions, annotations, elaborations, or other modifications
+    represent, as a whole, an original work of authorship. For the purposes
+    of this License, Derivative Works shall not include works that remain
+    separable from, or merely link (or bind by name) to the interfaces of,
+    the Work and Derivative Works thereof.
+
+    "Contribution" shall mean any work of authorship, including
+    the original version of the Work and any modifications or additions
+    to that Work or Derivative Works thereof, that is intentionally
+    submitted to Licensor for inclusion in the Work by the copyright owner
+    or by an individual or Legal Entity authorized to submit on behalf of
+    the copyright owner. For the purposes of this definition, "submitted"
+    means any form of electronic, verbal, or written communication sent
+    to the Licensor or its representatives, including but not limited to
+    communication on electronic mailing lists, source code control systems,
+    and issue tracking systems that are managed by, or on behalf of, the
+    Licensor for the purpose of discussing and improving the Work, but
+    excluding communication that is conspicuously marked or otherwise
+    designated in writing by the copyright owner as "Not a Contribution."
+
+    "Contributor" shall mean Licensor and any individual or Legal Entity
+    on behalf of whom a Contribution has been received by Licensor and
+    subsequently incorporated within the Work.
+
+2.  Grant of Copyright License. Subject to the terms and conditions of
+    this License, each Contributor hereby grants to You a perpetual,
+    worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+    copyright license to reproduce, prepare Derivative Works of,
+    publicly display, publicly perform, sublicense, and distribute the
+    Work and such Derivative Works in Source or Object form.
+
+3.  Grant of Patent License. Subject to the terms and conditions of
+    this License, each Contributor hereby grants to You a perpetual,
+    worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+    (except as stated in this section) patent license to make, have made,
+    use, offer to sell, sell, import, and otherwise transfer the Work,
+    where such license applies only to those patent claims licensable
+    by such Contributor that are necessarily infringed by their
+    Contribution(s) alone or by combination of their Contribution(s)
+    with the Work to which such Contribution(s) was submitted. If You
+    institute patent litigation against any entity (including a
+    cross-claim or counterclaim in a lawsuit) alleging that the Work
+    or a Contribution incorporated within the Work constitutes direct
+    or contributory patent infringement, then any patent licenses
+    granted to You under this License for that Work shall terminate
+    as of the date such litigation is filed.
+
+4.  Redistribution. You may reproduce and distribute copies of the
+    Work or Derivative Works thereof in any medium, with or without
+    modifications, and in Source or Object form, provided that You
+    meet the following conditions:
+
+    (a) You must give any other recipients of the Work or
+    Derivative Works a copy of this License; and
+
+    (b) You must cause any modified files to carry prominent notices
+    stating that You changed the files; and
+
+    (c) You must retain, in the Source form of any Derivative Works
+    that You distribute, all copyright, patent, trademark, and
+    attribution notices from the Source form of the Work,
+    excluding those notices that do not pertain to any part of
+    the Derivative Works; and
+
+    (d) If the Work includes a "NOTICE" text file as part of its
+    distribution, then any Derivative Works that You distribute must
+    include a readable copy of the attribution notices contained
+    within such NOTICE file, excluding those notices that do not
+    pertain to any part of the Derivative Works, in at least one
+    of the following places: within a NOTICE text file distributed
+    as part of the Derivative Works; within the Source form or
+    documentation, if provided along with the Derivative Works; or,
+    within a display generated by the Derivative Works, if and
+    wherever such third-party notices normally appear. The contents
+    of the NOTICE file are for informational purposes only and
+    do not modify the License. You may add Your own attribution
+    notices within Derivative Works that You distribute, alongside
+    or as an addendum to the NOTICE text from the Work, provided
+    that such additional attribution notices cannot be construed
+    as modifying the License.
+
+    You may add Your own copyright statement to Your modifications and
+    may provide additional or different license terms and conditions
+    for use, reproduction, or distribution of Your modifications, or
+    for any such Derivative Works as a whole, provided Your use,
+    reproduction, and distribution of the Work otherwise complies with
+    the conditions stated in this License.
+
+5.  Submission of Contributions. Unless You explicitly state otherwise,
+    any Contribution intentionally submitted for inclusion in the Work
+    by You to the Licensor shall be under the terms and conditions of
+    this License, without any additional terms or conditions.
+    Notwithstanding the above, nothing herein shall supersede or modify
+    the terms of any separate license agreement you may have executed
+    with Licensor regarding such Contributions.
+
+6.  Trademarks. This License does not grant permission to use the trade
+    names, trademarks, service marks, or product names of the Licensor,
+    except as required for reasonable and customary use in describing the
+    origin of the Work and reproducing the content of the NOTICE file.
+
+7.  Disclaimer of Warranty. Unless required by applicable law or
+    agreed to in writing, Licensor provides the Work (and each
+    Contributor provides its Contributions) on an "AS IS" BASIS,
+    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+    implied, including, without limitation, any warranties or conditions
+    of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+    PARTICULAR PURPOSE. You are solely responsible for determining the
+    appropriateness of using or redistributing the Work and assume any
+    risks associated with Your exercise of permissions under this License.
+
+8.  Limitation of Liability. In no event and under no legal theory,
+    whether in tort (including negligence), contract, or otherwise,
+    unless required by applicable law (such as deliberate and grossly
+    negligent acts) or agreed to in writing, shall any Contributor be
+    liable to You for damages, including any direct, indirect, special,
+    incidental, or consequential damages of any character arising as a
+    result of this License or out of the use or inability to use the
+    Work (including but not limited to damages for loss of goodwill,
+    work stoppage, computer failure or malfunction, or any and all
+    other commercial damages or losses), even if such Contributor
+    has been advised of the possibility of such damages.
+
+9.  Accepting Warranty or Additional Liability. While redistributing
+    the Work or Derivative Works thereof, You may choose to offer,
+    and charge a fee for, acceptance of support, warranty, indemnity,
+    or other liability obligations and/or rights consistent with this
+    License. However, in accepting such obligations, You may act only
+    on Your own behalf and on Your sole responsibility, not on behalf
+    of any other Contributor, and only if You agree to indemnify,
+    defend, and hold each Contributor harmless for any liability
+    incurred by, or claims asserted against, such Contributor by reason
+    of your accepting any such warranty or additional liability.
+
+END OF TERMS AND CONDITIONS
+
+APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+Copyright 2025 OpenAI
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.

MODULE.bazel

@@ -0,0 +1,843 @@
+module(name = "codex")
+
+bazel_dep(name = "bazel_lib", version = "3.2.2")
+bazel_dep(name = "bazel_skylib", version = "1.9.0")
+bazel_dep(name = "platforms", version = "1.0.0")
+
+# Expose the public protobuf rules already used transitively by rules_rs.
+bazel_dep(name = "protobuf", version = "34.0.bcr.1", repo_name = "com_google_protobuf")
+bazel_dep(name = "llvm", version = "0.8.11")
+bazel_dep(name = "windows_support", version = "0.2.0")
+
+# Patch hermetic LLVM for Codex's custom libc++ and Windows gnullvm runtime
+# needs that have not landed upstream.
+single_version_override(
+    module_name = "llvm",
+    patch_strip = 1,
+    patches = [
+        "//patches:llvm_rusty_v8_custom_libcxx.patch",
+        "//patches:llvm_windows_arm64_powl.patch",
+        "//patches:llvm_windows_mingw_compat.patch",
+    ],
+)
+
+# Preserve case-only SDK aliases when native Windows repository setup feeds
+# case-sensitive remote executors.
+single_version_override(
+    module_name = "windows_support",
+    patch_strip = 1,
+    patches = [
+        "//patches:windows-support-remote-case-aliases.patch",
+        "//patches:windows-support-native-tools.patch",
+    ],
+    version = "0.2.0",
+)
+
+# MSVC repository materialization fails closed until a user who has accepted
+# Microsoft's Visual Studio terms explicitly supplies
+# --repo_env=BAZEL_MSVC_RUNTIME_VISUAL_STUDIO_EULA=1. Do not configure that
+# acceptance globally: Linux, macOS, and Windows GNU do not require it.
+msvc_runtime = use_extension("@windows_support//windows:extensions.bzl", "msvc_runtime")
+msvc_runtime.configure(
+    architectures = [
+        "x64",
+        "arm64",
+    ],
+    msvc_version = "14.50.35717",
+    visual_studio_installer_manifest_integrity = "sha256-qOhU+p8/uurCfXME4pfxZg1xN0ATid61fPeYPzPBb+8=",
+    visual_studio_installer_manifest_url = "https://download.visualstudio.microsoft.com/download/pr/fdc37f6e-59f6-4054-838a-b476eeaa6ec3/1d82370739911457e0a2f6be15d8b5f569531b352b2eabb961429eea1e99e356/VisualStudio.vsman",
+)
+use_repo(msvc_runtime, "msvc_runtime")
+
+windows_sdk = use_extension("@windows_support//windows:extensions.bzl", "windows_sdk")
+windows_sdk.configure(
+    architectures = [
+        "x64",
+        "arm64",
+    ],
+    transformations = {
+        "base/c/Include/10.0.26100.0/shared/driverspecs.h": "base/c/Include/10.0.26100.0/shared/DriverSpecs.h",
+        "base/c/Include/10.0.26100.0/shared/specstrings.h": "base/c/Include/10.0.26100.0/shared/SpecStrings.h",
+        "base/c/Include/10.0.26100.0/um/ole2.h": "base/c/Include/10.0.26100.0/um/Ole2.h",
+        "base/c/Include/10.0.26100.0/um/olectl.h": "base/c/Include/10.0.26100.0/um/OleCtl.h",
+        "**/*.h": "lowercase",
+        "**/*.lib": "lowercase",
+        "**/*.Lib": "lowercase",
+    },
+    windows_sdk_integrity = {
+        "Microsoft.Windows.SDK.CPP": "sha256-/0VWYL7gcadEcVqWZWZvopwHaBV509gVlZqe7FpVZCQ=",
+        "Microsoft.Windows.SDK.CPP.x64": "sha256-rWzpD/lAEGmdKVSLPCseUsieuBFD4hmRVdmlw4ABtSs=",
+        "Microsoft.Windows.SDK.CPP.arm64": "sha256-A7wMA9Q5zvhQdLvNQl+dXTptO0Z5Z6zSHaO6bf7q+mc=",
+    },
+    windows_sdk_version = "10.0.26100.7705",
+)
+use_repo(windows_sdk, "windows_sdk")
+
+# Abseil picks a MinGW pthread TLS path that does not match our hermetic
+# windows-gnullvm toolchain; force it onto the portable C++11 thread-local path.
+single_version_override(
+    module_name = "abseil-cpp",
+    patch_strip = 1,
+    patches = [
+        "//patches:abseil_windows_gnullvm_thread_identity.patch",
+    ],
+)
+
+register_toolchains("@llvm//toolchain:all")
+
+osx = use_extension("@llvm//extensions:osx.bzl", "osx")
+osx.from_archive(
+    sha256 = "5f044578cd78a3a9b9c965a42d56bad609ee5d252e1d4e6aa7c42fc3f35fee7b",
+    strip_prefix = "Payload/Library/Developer/CommandLineTools/SDKs/MacOSX26.5.sdk",
+    type = "pkg",
+    urls = [
+        "https://swcdn.apple.com/content/downloads/09/08/047-91568-A_Y1CFZWQCD4/4xekpyz43i26dbp4enxfro8eb1q7wiujh5/CLTools_macOSNMOS_SDK.pkg",
+    ],
+)
+osx.frameworks(names = [
+    "ApplicationServices",
+    "AppKit",
+    "ColorSync",
+    "CoreFoundation",
+    "CoreGraphics",
+    "CoreImage",
+    "CoreMedia",
+    "CoreMIDI",
+    "CoreServices",
+    "CoreText",
+    "CoreVideo",
+    "DiskArbitration",
+    "AudioToolbox",
+    "AVFoundation",
+    "AVFAudio",
+    "AVRouting",
+    "CFNetwork",
+    "Cocoa",
+    "CoreData",
+    "PrintCore",
+    "Symbols",
+    "FontServices",
+    "AudioUnit",
+    "CoreAudio",
+    "CoreAudioTypes",
+    "Foundation",
+    "ImageIO",
+    "IOSurface",
+    "IOKit",
+    "Kernel",
+    "LocalAuthentication",
+    "Metal",
+    "MetalKit",
+    "OpenGL",
+    "OSLog",
+    "QuartzCore",
+    "ScreenCaptureKit",
+    "Security",
+    "SystemConfiguration",
+    "UniformTypeIdentifiers",
+    "VideoToolbox",
+])
+use_repo(osx, "macos_sdk")
+
+# Needed to disable xcode...
+bazel_dep(name = "apple_support", version = "2.1.0")
+bazel_dep(name = "rules_cc", version = "0.2.18")
+
+# Windows voice jobs explicitly select the installed MSVC C toolchains.
+cc_configure = use_extension("@rules_cc//cc:extensions.bzl", "cc_configure_extension")
+use_repo(cc_configure, "local_config_cc")
+
+single_version_override(
+    module_name = "rules_cc",
+    patch_strip = 1,
+    patches = [
+        "//patches:rules_cc_rusty_v8_custom_libcxx.patch",
+    ],
+)
+
+bazel_dep(name = "rules_platform", version = "0.1.0")
+bazel_dep(name = "aws-lc", version = "5.1.0.bcr.1")
+bazel_dep(name = "rules_rs", version = "0.0.96")
+bazel_dep(name = "rules_foreign_cc", version = "0.15.1")
+single_version_override(
+    module_name = "rules_foreign_cc",
+    patch_strip = 1,
+    patches = [
+        "//patches:rules_foreign_cc_make_cppflags.patch",
+        "//patches:rules_foreign_cc_make_xcompile.patch",
+        "//patches:rules_foreign_cc_make_msvc_stdint.patch",
+    ],
+    version = "0.15.1",
+)
+
+bazel_dep(name = "rules_python", version = "1.7.0")
+
+voice_python = use_extension("@rules_python//python/extensions:python.bzl", "python")
+voice_python.defaults(python_version = "3.11")
+voice_python.toolchain(python_version = "3.12")
+use_repo(voice_python, "python_3_12")
+
+# Use the existing pinned Make build for foreign_cc consumers, including the
+# native voice pkg-config bootstrap, instead of a PATH-provided Make.
+register_toolchains("@rules_foreign_cc//toolchains:built_make_toolchain")
+
+foreign_cc_tools = use_extension("@rules_foreign_cc//foreign_cc:extensions.bzl", "tools")
+use_repo(foreign_cc_tools, "cmake-3.31.8-windows-x86_64", "pkgconfig_src")
+
+single_version_override(
+    module_name = "rules_rs",
+    patch_strip = 1,
+    patches = [
+        "//patches:rules_rs_build_script_deps_annotation.patch",
+        "//patches:rules_rs_windows_msvc_linker.patch",
+        "//patches:rules_rs_zlib_snapshot_urls.patch",
+    ],
+    version = "0.0.96",
+)
+
+rules_rust = use_extension("@rules_rs//rs:rules_rust.bzl", "rules_rust")
+rules_rust.patch(
+    patches = [
+        # Carry the OpenAI setup fix that makes build-script tools available
+        # through their runfiles after the rules_rs upgrade.
+        "//patches:rules_rust_build_script_tools_transition.patch",
+        # Prefer Rust's direct linker for Windows/MSVC and keep hermetic
+        # LLVM's non-.lib runtime artifacts compatible with it.
+        "//patches:rules_rust_windows_msvc_direct_link_args.patch",
+        # Skip transient native-Windows linker outputs while consolidating
+        # dependency search paths.
+        "//patches:rules_rust_windows_process_wrapper_skip_temp_outputs.patch",
+        # Group build-script argument files to avoid Windows command-line limits.
+        "//patches:rules_rust_group_build_script_arg_files.patch",
+        "//patches:rules_rust_windows_execroot_separators.patch",
+    ],
+    strip = 1,
+)
+use_repo(rules_rust, "rules_rust")
+
+# argument-comment-lint uses rustc_private and needs nightly rustc-dev
+# components. Keep that rules_rust-reexported toolchain separate from the
+# default rules_rs toolchains below, which do not expose dev_components.
+nightly_rust = use_extension(
+    "@rules_rs//rs:rules_rust_reexported_extensions.bzl",
+    "rust",
+)
+nightly_rust.toolchain(
+    dev_components = True,
+    edition = "2024",
+    versions = ["nightly/2025-09-18"],
+)
+
+# Keep the reexported extension's default Windows set constrained to MSVC so
+# it cannot also match the gnullvm host platform.
+nightly_rust.repository_set(
+    name = "rust_windows_x86_64",
+    dev_components = True,
+    edition = "2024",
+    exec_compatible_with = [
+        "@platforms//cpu:x86_64",
+        "@platforms//os:windows",
+        "@llvm//constraints/windows/abi:msvc",
+    ],
+    exec_triple = "x86_64-pc-windows-msvc",
+    target_compatible_with = [
+        "@platforms//cpu:x86_64",
+        "@platforms//os:windows",
+        "@llvm//constraints/windows/abi:msvc",
+    ],
+    target_triple = "x86_64-pc-windows-msvc",
+    versions = ["nightly/2025-09-18"],
+)
+
+# Also let that MSVC-exec set target gnullvm for existing cross lanes.
+nightly_rust.repository_set(
+    name = "rust_windows_x86_64",
+    target_compatible_with = [
+        "@platforms//cpu:x86_64",
+        "@platforms//os:windows",
+        "@llvm//constraints/windows/abi:gnullvm",
+        "@llvm//constraints/windows/crt:msvcrt",
+    ],
+    target_triple = "x86_64-pc-windows-gnullvm",
+)
+
+# Give Windows lint a native gnullvm exec set so proc-macros link against the
+# same ABI as hermetic LLVM and BCR AWS-LC.
+nightly_rust.repository_set(
+    name = "rust_windows_x86_64_gnullvm",
+    dev_components = True,
+    edition = "2024",
+    exec_compatible_with = [
+        "@platforms//cpu:x86_64",
+        "@platforms//os:windows",
+        "@llvm//constraints/windows/abi:gnullvm",
+        "@llvm//constraints/windows/crt:msvcrt",
+    ],
+    exec_triple = "x86_64-pc-windows-gnullvm",
+    target_compatible_with = [
+        "@platforms//cpu:x86_64",
+        "@platforms//os:windows",
+        "@llvm//constraints/windows/abi:gnullvm",
+        "@llvm//constraints/windows/crt:msvcrt",
+    ],
+    target_triple = "x86_64-pc-windows-gnullvm",
+    versions = ["nightly/2025-09-18"],
+)
+use_repo(nightly_rust, "rust_toolchains")
+
+toolchains = use_extension("@rules_rs//rs/toolchains:module_extension.bzl", "toolchains")
+toolchains.toolchain(
+    edition = "2024",
+    version = "1.95.0",
+)
+use_repo(toolchains, "default_rust_toolchains")
+
+register_toolchains("@default_rust_toolchains//:all")
+
+register_toolchains("@rust_toolchains//:all")
+
+rules_rust_bindgen = use_extension(
+    "@rules_rs//rs:rules_rust_bindgen.bzl",
+    "rules_rust_bindgen",
+)
+use_repo(rules_rust_bindgen, "rules_rust_bindgen")
+
+register_toolchains("@rules_rust_bindgen//:all")
+
+# Generate Rust protobuf/gRPC libraries against the workspace's prost/tonic
+# versions instead of the versions bundled with rules_rs's default toolchain.
+register_toolchains("//bazel/toolchains/prost:toolchain")
+
+crate = use_extension("@rules_rs//rs:extensions.bzl", "crate")
+crate.from_cargo(
+    cargo_lock = "//codex-rs:Cargo.lock",
+    cargo_toml = "//codex-rs:Cargo.toml",
+    platform_triples = [
+        "aarch64-unknown-linux-gnu",
+        "aarch64-unknown-linux-musl",
+        "aarch64-apple-darwin",
+        # Keep both Windows ABIs in the generated Cargo metadata: the V8
+        # experiment still consumes release assets that only exist under the
+        # MSVC names while targeting the GNU toolchain.
+        "aarch64-pc-windows-msvc",
+        "aarch64-pc-windows-gnullvm",
+        "x86_64-unknown-linux-gnu",
+        "x86_64-unknown-linux-musl",
+        "x86_64-apple-darwin",
+        "x86_64-pc-windows-msvc",
+        "x86_64-pc-windows-gnullvm",
+    ],
+)
+crate.from_cargo(
+    name = "argument_comment_lint_crates",
+    cargo_lock = "//tools/argument-comment-lint:Cargo.lock",
+    cargo_toml = "//tools/argument-comment-lint:Cargo.toml",
+    platform_triples = [
+        "aarch64-unknown-linux-gnu",
+        "aarch64-unknown-linux-musl",
+        "aarch64-apple-darwin",
+        "aarch64-pc-windows-msvc",
+        "aarch64-pc-windows-gnullvm",
+        "x86_64-unknown-linux-gnu",
+        "x86_64-unknown-linux-musl",
+        "x86_64-apple-darwin",
+        "x86_64-pc-windows-msvc",
+        "x86_64-pc-windows-gnullvm",
+    ],
+)
+
+bazel_dep(name = "zstd", version = "1.5.7")
+
+crate.annotation(
+    # The Windows lint toolchain cannot reliably materialize blake3's native x86 assembly archives.
+    crate = "blake3",
+    crate_features_select = {
+        "x86_64-pc-windows-gnullvm": ["pure"],
+    },
+)
+crate.annotation(
+    crate = "zstd-sys",
+    gen_build_script = "on",
+    patch_args = ["-p1"],
+    patches = [
+        "//patches:zstd-sys_windows_msvc_include_dirs.patch",
+    ],
+)
+crate.annotation(
+    crate = "ring",
+    patch_args = ["-p1"],
+    patches = [
+        "//patches:ring_windows_msvc_include_dirs.patch",
+    ],
+)
+crate.annotation(
+    additive_build_file = "@rules_rs//3rd_party/aws-lc-sys:additive.BUILD.bazel",
+    crate = "aws-lc-sys",
+    extra_aliased_targets = {"aws_lc_sys_build_info": "aws_lc_sys_build_info"},
+    gen_build_script = "off",
+    repositories = ["crates"],
+    rustc_flags = ["--cfg=use_bindgen_pregenerated"],
+    deps = ["@crates//:aws_lc_sys_build_info"],
+)
+crate.annotation(
+    crate = "aws-lc-rs",
+    gen_build_script = "off",
+    repositories = ["crates"],
+)
+crate.annotation(
+    # The build script only validates embedded source/version metadata.
+    crate = "rustc_apfloat",
+    gen_build_script = "off",
+)
+
+inject_repo(crate, "aws-lc")
+
+inject_repo(crate, "zstd")
+
+use_repo(crate, "argument_comment_lint_crates")
+
+bazel_dep(name = "bzip2", version = "1.0.8.bcr.3")
+single_version_override(
+    module_name = "bzip2",
+    patch_strip = 1,
+    patches = [
+        "//patches:bzip2_windows_stack_args.patch",
+    ],
+)
+
+crate.annotation(
+    crate = "bzip2-sys",
+    gen_build_script = "off",
+    deps = ["@bzip2//:bz2"],
+)
+
+inject_repo(crate, "bzip2")
+
+bazel_dep(name = "zlib", version = "1.3.1.bcr.8")
+
+crate.annotation(
+    crate = "libz-sys",
+    gen_build_script = "on",
+)
+
+inject_repo(crate, "zlib")
+
+bazel_dep(name = "xz", version = "5.4.5.bcr.8")
+single_version_override(
+    module_name = "xz",
+    patch_strip = 1,
+    patches = [
+        "//patches:xz_windows_stack_args.patch",
+    ],
+)
+
+crate.annotation(
+    crate = "lzma-sys",
+    gen_build_script = "off",
+    deps = ["@xz//:lzma"],
+)
+
+bazel_dep(name = "openssl", version = "3.5.4.bcr.0")
+
+inject_repo(crate, "xz")
+
+crate.annotation(
+    build_script_data = [
+        "@openssl//:gen_dir",
+    ],
+    # Build scripts compile in Bazel's exec configuration, so target-specific
+    # optional build deps are otherwise dropped for the musl release platforms.
+    build_script_deps = [
+        "@crates//:openssl-src-300.6.1+3.6.3",
+    ],
+    build_script_env = {
+        "OPENSSL_DIR": "$(execpath @openssl//:gen_dir)",
+        "OPENSSL_NO_VENDOR": "1",
+        "OPENSSL_STATIC": "1",
+    },
+    crate = "openssl-sys",
+    data = ["@openssl//:gen_dir"],
+    gen_build_script = "on",
+)
+
+inject_repo(crate, "openssl")
+
+crate.annotation(
+    crate = "runfiles",
+    workspace_cargo_toml = "rust/runfiles/Cargo.toml",
+)
+
+# MXC keeps its Rust workspace below the repository root.
+[
+    crate.annotation(
+        crate = name,
+        workspace_cargo_toml = "src/Cargo.toml",
+    )
+    for name in [
+        "appcontainer_common",
+        "learning_mode_core",
+        "learning_mode_windows",
+        "mxc_config_contract",
+        "mxc_telemetry",
+        "process_security_environment_spec",
+        "sandbox_spec",
+        "wxc_common",
+    ]
+]
+
+http_archive = use_repo_rule("@bazel_tools//tools/build_defs/repo:http.bzl", "http_archive")
+
+codex_release_archive = use_extension(
+    "//bazel/extensions:codex_release_archive.bzl",
+    "codex_release_archive",
+)
+codex_release_archive.release(
+    sha256 = "0b7afd1de4ecf06a8633f1e4958ec5f8d57d4b7842773416d9cb9d8c816f2c84",
+    version = "0.153.1",
+)
+codex_release_archive.release(
+    sha256 = "71a28d362c96ac9829bf8203a2c71be451aeb726adb843167fdaf0eae8fe7dd9",
+    version = "0.145.0",
+)
+use_repo(
+    codex_release_archive,
+    "codex_release_0.145.0_linux_x86_64",
+    "codex_release_0.153.1_linux_x86_64",
+)
+
+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")
+
+include("//bazel/modules:wine.MODULE.bazel")
+
+voice_sources = use_extension("//third_party/voice:extensions.bzl", "voice_sources")
+use_repo(
+    voice_sources,
+    "voice_archive_glib",
+    "voice_archive_gst_plugins_base",
+    "voice_archive_gst_plugins_good",
+    "voice_archive_gstreamer",
+    "voice_archive_libffi",
+    "voice_archive_meson",
+    "voice_archive_ninja",
+    "voice_archive_opus",
+    "voice_archive_pcre2",
+    "voice_archive_proxy_libintl",
+    "voice_archive_zlib",
+    "voice_glib",
+    "voice_gst_plugins_base",
+    "voice_gst_plugins_good",
+    "voice_gstreamer",
+    "voice_libffi",
+    "voice_meson",
+    "voice_ninja",
+    "voice_opus",
+    "voice_pcre2",
+    "voice_proxy_libintl",
+    "voice_zlib",
+)
+
+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",
+    # Keep the Rust feature aligned with the source-built Bazel artifacts.
+    # Windows MSVC still consumes upstream non-sandboxed prebuilts.
+    crate_features_select = {
+        "aarch64-apple-darwin": ["v8_enable_sandbox"],
+        "aarch64-pc-windows-gnullvm": ["v8_enable_sandbox"],
+        "aarch64-pc-windows-msvc": ["v8_enable_sandbox"],
+        "aarch64-unknown-linux-gnu": ["v8_enable_sandbox"],
+        "aarch64-unknown-linux-musl": ["v8_enable_sandbox"],
+        "x86_64-apple-darwin": ["v8_enable_sandbox"],
+        "x86_64-pc-windows-gnullvm": ["v8_enable_sandbox"],
+        "x86_64-pc-windows-msvc": ["v8_enable_sandbox"],
+        "x86_64-unknown-linux-gnu": ["v8_enable_sandbox"],
+        "x86_64-unknown-linux-musl": ["v8_enable_sandbox"],
+    },
+    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")
+
+crate.annotation(
+    # Provide the hermetic SDK path so the build script doesn't try to invoke an unhermetic `xcrun --show-sdk-path`.
+    build_script_data = [
+        "@macos_sdk//sysroot",
+    ],
+    build_script_env = {
+        "BINDGEN_EXTRA_CLANG_ARGS": "-Xclang -internal-isystem -Xclang $(location @llvm//:builtin_resource_dir)/include",
+        "COREAUDIO_SDK_PATH": "$(location @macos_sdk//sysroot)",
+        "LIBCLANG_PATH": "$(location @llvm-project//clang:libclang_interface_output)",
+    },
+    build_script_tools = [
+        "@llvm-project//clang:libclang_interface_output",
+        "@llvm//:builtin_resource_dir",
+    ],
+    crate = "coreaudio-sys",
+    gen_build_script = "on",
+)
+
+inject_repo(crate, "llvm", "llvm-project", "macos_sdk")
+
+# The bundled Opus encoder uses CMake; supply executable tools and their data,
+# rather than relying on a build worker's PATH. Versions are pinned by the module.
+crate.annotation(
+    build_script_data = ["//third_party/voice:opus-toolchain.cmake"],
+    build_script_env = {
+        "CMAKE": "$${pwd}/$(CMAKE)",
+        "CMAKE_GENERATOR": "Ninja",
+        "CMAKE_TOOLCHAIN_FILE": "$(execpath @@//third_party/voice:opus-toolchain.cmake)",
+        "CODEX_VOICE_NINJA": "$${pwd}/$(NINJA)",
+    },
+    build_script_toolchains = [
+        "@rules_foreign_cc//toolchains:current_cmake_toolchain",
+        "@rules_foreign_cc//toolchains:current_ninja_toolchain",
+    ],
+    build_script_tools = [
+        "@rules_foreign_cc//toolchains:current_cmake_toolchain",
+        "@rules_foreign_cc//toolchains:current_ninja_toolchain",
+    ],
+    crate = "opusic-sys",
+)
+
+# The musl CLI's allocator needs declared native tools and consistent header flags.
+crate.annotation(
+    build_script_env = {
+        "MAKE": "$${pwd}/$(MAKE)",
+        "NM": "$${pwd}/$(execpath @llvm//tools:llvm-nm)",
+        "RANLIB": "$${pwd}/$(execpath @llvm//tools:llvm-ranlib)",
+    },
+    build_script_toolchains = ["@rules_foreign_cc//toolchains:current_make_toolchain"],
+    build_script_tools = [
+        "@llvm//tools:llvm-nm",
+        "@llvm//tools:llvm-ranlib",
+        "@rules_foreign_cc//toolchains:current_make_toolchain",
+    ],
+    crate = "tikv-jemalloc-sys",
+    patch_args = ["-p1"],
+    patches = [
+        "//patches:tikv-jemalloc-sys_make_env.patch",
+        "//patches:tikv-jemalloc-sys_dependency_flags.patch",
+    ],
+)
+
+inject_repo(crate, "rules_foreign_cc")
+
+crate.annotation(
+    # Provide the hermetic SDK path so the build script doesn't try to invoke an unavailable `xcrun --show-sdk-path`.
+    build_script_data = [
+        "@macos_sdk//sysroot",
+    ],
+    build_script_env = {
+        "WEBRTC_SYS_DARWIN_SDK_PATH": "$(location @macos_sdk//sysroot)",
+        "WEBRTC_SYS_LINK_OUT_DIR": "1",
+    },
+    crate = "webrtc-sys",
+    gen_build_script = "on",
+    patch_args = ["-p1"],
+    patches = [
+        "//patches:webrtc-sys_hermetic_darwin_sysroot.patch",
+    ],
+)
+
+# Fix readme inclusions
+crate.annotation(
+    crate = "windows-link",
+    patch_args = ["-p1"],
+    patches = [
+        "//patches:windows-link.patch",
+    ],
+)
+
+bazel_dep(name = "alsa_lib", version = "1.2.9.bcr.4")
+
+crate.annotation(
+    crate = "alsa-sys",
+    gen_build_script = "off",
+    deps = ["@alsa_lib"],
+)
+
+inject_repo(crate, "alsa_lib")
+
+# Keep upstream pkg-config version probes, but link only the prepared runtime.
+# system-deps applies these path/flag overrides after a successful version probe.
+[
+    crate.annotation(
+        build_script_data = [
+            "//third_party/voice:native_link",
+            "//third_party/voice:native_sdk",
+        ],
+        build_script_env = {
+            "PKG_CONFIG": "$(execpath @@//third_party/voice:pkg_config)",
+            "PKG_CONFIG_LIBDIR": "$(execpath @@//third_party/voice:native_sdk)/lib/pkgconfig",
+            "PKG_CONFIG_PATH": "",
+        } | {
+            "SYSTEM_DEPS_" + key + "_SEARCH_NATIVE": "$(execpath @@//third_party/voice:native_link)/.."
+            for key in keys
+        } | {
+            # GStreamer's .pc files add an absolute rpath; CcInfo supplies the
+            # relative Bazel runpath instead. Library/version checks still run.
+            "SYSTEM_DEPS_" + key + "_LDFLAGS": ""
+            for key in keys
+            if key.startswith("GSTREAMER_")
+        },
+        build_script_tools = ["//third_party/voice:pkg_config"],
+        crate = name,
+        gen_build_script = "on",
+        version = version,
+        deps = ["//third_party/voice:native_link"],
+    )
+    for name, version, keys in [
+        (
+            "glib-sys",
+            "0.22.8",
+            [
+                "GLIB_2_0",
+                "GOBJECT_2_0",
+            ],
+        ),
+        (
+            "gobject-sys",
+            "0.22.6",
+            ["GOBJECT_2_0"],
+        ),
+        (
+            "gio-sys",
+            "0.22.8",
+            ["GIO_2_0"],
+        ),
+        (
+            "gstreamer-sys",
+            "0.25.2",
+            ["GSTREAMER_1_0"],
+        ),
+        (
+            "gstreamer-base-sys",
+            "0.25.3",
+            ["GSTREAMER_BASE_1_0"],
+        ),
+        (
+            "gstreamer-app-sys",
+            "0.25.0",
+            ["GSTREAMER_APP_1_0"],
+        ),
+        (
+            "gstreamer-audio-sys",
+            "0.25.3",
+            ["GSTREAMER_AUDIO_1_0"],
+        ),
+        (
+            "glib-sys",
+            "0.22.9",
+            [
+                "GLIB_2_0",
+                "GOBJECT_2_0",
+            ],
+        ),
+        (
+            "gobject-sys",
+            "0.22.9",
+            ["GOBJECT_2_0"],
+        ),
+        (
+            "gio-sys",
+            "0.22.9",
+            ["GIO_2_0"],
+        ),
+    ]
+]
+
+bazel_dep(name = "v8", version = "15.0.245.2")
+archive_override(
+    module_name = "v8",
+    integrity = "sha256-Fk89PgqLTAKjhtOojRsRM9N+XCC+Ajn+zc3eQUpDQNU=",
+    patch_strip = 3,
+    patches = [
+        "//patches:v8_module_deps.patch",
+        "//patches:v8_bazel_rules.patch",
+        "//patches:v8_source_portability.patch",
+    ],
+    strip_prefix = "v8-15.0.245.2",
+    urls = ["https://github.com/v8/v8/archive/refs/tags/15.0.245.2.tar.gz"],
+)
+
+http_archive(
+    name = "v8_crate_150_4_0",
+    build_file = "//third_party/v8:v8_crate.BUILD.bazel",
+    sha256 = "42a978ff11f15b24e5c05a7123cf2b68f41e763546699781a924ef4e2cf43a49",
+    strip_prefix = "v8-150.4.0",
+    type = "tar.gz",
+    urls = ["https://static.crates.io/crates/v8/v8-150.4.0.crate"],
+)
+
+git_repository = use_repo_rule("@bazel_tools//tools/build_defs/repo:git.bzl", "git_repository")
+
+git_repository(
+    name = "rusty_v8_libcxx",
+    build_file = "//third_party/v8:libcxx.BUILD.bazel",
+    commit = "5abc7f839700f0f17338434e1c1c6a8c87c00c11",
+    remote = "https://chromium.googlesource.com/external/github.com/llvm/llvm-project/libcxx.git",
+)
+
+git_repository(
+    name = "rusty_v8_libcxxabi",
+    build_file = "//third_party/v8:libcxxabi.BUILD.bazel",
+    commit = "8f11bb1d4438d0239d0dfc1bd9456a9f31629dda",
+    remote = "https://chromium.googlesource.com/external/github.com/llvm/llvm-project/libcxxabi.git",
+)
+
+git_repository(
+    name = "rusty_v8_llvm_libc",
+    build_file = "//third_party/v8:llvm_libc.BUILD.bazel",
+    commit = "9309c117ebae84dd2f9df1ef99de4782162527d5",
+    remote = "https://chromium.googlesource.com/external/github.com/llvm/llvm-project/libc.git",
+)
+
+http_file(
+    name = "rusty_v8_150_4_0_aarch64_pc_windows_msvc_archive",
+    downloaded_file_path = "rusty_v8_release_aarch64-pc-windows-msvc.lib.gz",
+    sha256 = "54722842af36b74248c403ff531254efac6ff65d281198bab0c6350fc1188ad4",
+    urls = [
+        "https://github.com/openai/codex/releases/download/rusty-v8-v150.4.0/rusty_v8_ptrcomp_sandbox_release_aarch64-pc-windows-msvc.lib.gz",
+    ],
+)
+
+http_file(
+    name = "rusty_v8_150_4_0_x86_64_pc_windows_msvc_archive",
+    downloaded_file_path = "rusty_v8_release_x86_64-pc-windows-msvc.lib.gz",
+    sha256 = "732ec5da4243aa166799780c8519a5eea6f32f6e47657a323342794dc3c239d6",
+    urls = [
+        "https://github.com/openai/codex/releases/download/rusty-v8-v150.4.0/rusty_v8_ptrcomp_sandbox_release_x86_64-pc-windows-msvc.lib.gz",
+    ],
+)
+
+use_repo(crate, "crates")
+
+bazel_dep(name = "libcap", version = "2.27.bcr.1")
+
+rbe_platform_repository = use_repo_rule("//:rbe.bzl", "rbe_platform_repository")
+
+rbe_platform_repository(
+    name = "rbe_platform",
+)

NOTICE

@@ -0,0 +1,6 @@
+OpenAI Codex
+Copyright 2025 OpenAI
+
+This project includes code derived from [Ratatui](https://github.com/ratatui/ratatui), licensed under the MIT license.
+Copyright (c) 2016-2022 Florian Dehau
+Copyright (c) 2023-2025 The Ratatui Developers

README.md

@@ -0,0 +1,93 @@
+---
+license: apache-2.0
+tags:
+  - agent
+  - coding-agent
+  - cli
+  - llm
+  - tool-use
+---
+
+> **This is a source mirror.** This Hugging Face repository is not a model checkpoint — it's a read-only mirror of the [`openai/codex`](https://github.com/openai/codex) GitHub repository, OpenAI's local coding agent CLI. It is hosted here for visibility on the Hub; the canonical repository, issue tracker, and pull requests all live on GitHub. Please file issues and contribute there, not here.
+
+<p align="center"><strong>Codex CLI</strong> is a coding agent from OpenAI that runs locally on your computer.
+<p align="center">
+  <img src="https://github.com/openai/codex/blob/main/.github/codex-cli-splash.png" alt="Codex CLI splash" width="80%" />
+</p>
+</br>
+If you want Codex in your code editor (VS Code, Cursor, Windsurf), <a href="https://developers.openai.com/codex/ide">install in your IDE.</a>
+</br>If you want the desktop app experience, run <code>codex app</code> or visit <a href="https://chatgpt.com/codex?app-landing-page=true">the Codex App page</a>.
+</br>If you are looking for the <em>cloud-based agent</em> from OpenAI, <strong>Codex Web</strong>, go to <a href="https://chatgpt.com/codex">chatgpt.com/codex</a>.</p>
+
+---
+
+## Quickstart
+
+### Installing and running Codex CLI
+
+Run the following on Mac or Linux to install Codex CLI:
+
+```shell
+curl -fsSL https://chatgpt.com/codex/install.sh | sh
+```
+
+Run the following on Windows to install Codex CLI:
+
+```shell
+powershell -ExecutionPolicy ByPass -c "irm https://chatgpt.com/codex/install.ps1 | iex"
+```
+
+The standalone installers download from `https://releases.openai.com/codex` by default and fall back to GitHub Releases if a metadata or asset download is unavailable. To force GitHub Releases, set `CODEX_INSTALLER_USE_RELEASES_OPENAI_COM` to `false` (`0` and `no` are also accepted):
+
+```shell
+curl -fsSL https://chatgpt.com/codex/install.sh | CODEX_INSTALLER_USE_RELEASES_OPENAI_COM=false sh
+```
+
+```powershell
+$env:CODEX_INSTALLER_USE_RELEASES_OPENAI_COM='false'; irm https://chatgpt.com/codex/install.ps1 | iex
+```
+
+Codex CLI can also be installed via the following package managers:
+
+```shell
+# Install using npm
+npm install -g @openai/codex
+```
+
+```shell
+# Install using Homebrew
+brew install --cask codex
+```
+
+Then simply run `codex` to get started.
+
+<details>
+<summary>You can also go to the <a href="https://github.com/openai/codex/releases/latest">latest GitHub Release</a> and download the appropriate binary for your platform.</summary>
+
+Each GitHub Release contains many executables, but in practice, you likely want one of these:
+
+- macOS
+  - Apple Silicon/arm64: `codex-aarch64-apple-darwin.tar.gz`
+  - x86_64 (older Mac hardware): `codex-x86_64-apple-darwin.tar.gz`
+- Linux
+  - x86_64: `codex-x86_64-unknown-linux-musl.tar.gz`
+  - arm64: `codex-aarch64-unknown-linux-musl.tar.gz`
+
+Each archive contains a single entry with the platform baked into the name (e.g., `codex-x86_64-unknown-linux-musl`), so you likely want to rename it to `codex` after extracting it.
+
+</details>
+
+### Using Codex with your ChatGPT plan
+
+Run `codex` and select **Sign in with ChatGPT**. We recommend signing into your ChatGPT account to use Codex as part of your Plus, Pro, Business, Edu, or Enterprise plan. [Learn more about what's included in your ChatGPT plan](https://help.openai.com/en/articles/11369540-codex-in-chatgpt).
+
+You can also use Codex with an API key, but this requires [additional setup](https://developers.openai.com/codex/auth#sign-in-with-an-api-key).
+
+## Docs
+
+- [**Codex Documentation**](https://developers.openai.com/codex)
+- [**Contributing**](./docs/contributing.md)
+- [**Installing & building**](./docs/install.md)
+- [**Open source fund**](./docs/open-source-fund.md)
+
+This repository is licensed under the [Apache-2.0 License](LICENSE).

SECURITY.md

@@ -0,0 +1,17 @@
+# Security Policy
+
+Thank you for helping us keep Codex secure!
+
+## Reporting Security Issues
+
+The security is essential to OpenAI's mission. We appreciate the work of security researchers acting in good faith to identify and responsibly report potential vulnerabilities, helping us maintain strong privacy and security standards for our users and technology.
+
+Our security program is managed through Bugcrowd, and we ask that any validated vulnerabilities be reported via the [Bugcrowd program](https://bugcrowd.com/engagements/openai).
+
+## Vulnerability Disclosure Program
+
+Our Vulnerability Program Guidelines are defined on our [Bugcrowd program page](https://bugcrowd.com/engagements/openai).
+
+## How to operate CODEX safely
+
+For details on Codex security boundaries, including sandboxing, approvals, and network controls, see [Agent approvals & security](https://developers.openai.com/codex/agent-approvals-security).

announcement_tip.toml

@@ -0,0 +1,17 @@
+# Example announcement tips for Codex TUI.
+# Each [[announcements]] entry is evaluated in order; the last matching one is shown.
+# Dates are UTC, formatted as YYYY-MM-DD. The from_date is inclusive and the to_date is exclusive.
+# version_regex matches against the CLI version (env!("CARGO_PKG_VERSION")); omit to apply to all versions.
+# target_app specify which app should display the announcement (cli, vsce, ...).
+
+# Test announcement only for local build version until 2027-05-10 excluded
+[[announcements]]
+content = "This is a test announcement"
+version_regex = "^0\\.0\\.0$"
+to_date = "2027-05-10"
+
+[[announcements]]
+content = "Update Required - This version will no longer be supported starting May 8th. Please upgrade to the latest version (https://github.com/openai/codex/releases/latest) using your preferred package manager."
+# Matches 0.x.y versions from 0.0.y through 0.119.y; excludes 0.120.0 and newer.
+version_regex = "^0\\.(?:[0-9]|[1-9][0-9]|1[01][0-9])\\."
+to_date = "2026-05-08"

codex-cli/.gitignore

@@ -0,0 +1 @@
+/vendor/

codex-cli/package.json

@@ -0,0 +1,22 @@
+{
+  "name": "@openai/codex",
+  "version": "0.0.0-dev",
+  "description": "Codex CLI is a coding agent from OpenAI that runs locally on your computer.",
+  "license": "Apache-2.0",
+  "bin": {
+    "codex": "bin/codex.js"
+  },
+  "type": "module",
+  "engines": {
+    "node": ">=16"
+  },
+  "files": [
+    "bin/codex.js"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/openai/codex.git",
+    "directory": "codex-cli"
+  },
+  "packageManager": "pnpm@10.34.5+sha512.a4ee05f2f73658255bd6a89859c065a45c28a57daefae2c893a168ee2b73168c37b91e83e57ea67654ad03f03031746430e8bce38e362e042605fb8abc80192e"
+}

codex-rs/.gitignore

@@ -0,0 +1,2 @@
+/target/
+/target-*/

codex-rs/BUILD.bazel

@@ -0,0 +1,26 @@
+exports_files([
+    "clippy.toml",
+])
+
+filegroup(
+    name = "workspace-files",
+    srcs = glob(
+        [
+            "*",
+            ".cargo/**",
+        ],
+        exclude = [
+            "BUILD.bazel",
+        ],
+    ),
+    visibility = ["//visibility:public"],
+)
+
+test_suite(
+    name = "e2e-benchmarks",
+    tags = ["manual"],
+    tests = [
+        "//codex-rs/cli:codex-help-bench",
+    ],
+    visibility = ["//visibility:public"],
+)

codex-rs/Cargo.toml

@@ -0,0 +1,632 @@
+[workspace]
+members = [
+    "aws-auth",
+    "analytics",
+    "agent-graph-store",
+    "agent-identity",
+    "agent-roles",
+    "backend-client",
+    "bwrap",
+    "build-info",
+    "ansi-escape",
+    "attachment-store",
+    "async-utils",
+    "app-server",
+    "app-server-transport",
+    "app-server-daemon",
+    "app-server-client",
+    "app-server-protocol",
+    "app-server-protocol-noop-macros",
+    "app-server-test-client",
+    "apply-patch",
+    "arg0",
+    "feedback",
+    "features",
+    "install-context",
+    "codex-backend-openapi-models",
+    "code-mode",
+    "code-mode-host",
+    "code-mode-protocol",
+    "code-mode-runtime",
+    "codex-home",
+    "cloud-config",
+    "cloud-tasks",
+    "cloud-tasks-client",
+    "cloud-tasks-mock-client",
+    "cli",
+    "collaboration-mode-templates",
+    "connectors",
+    "config",
+    "config-schema",
+    "context-fragments",
+    "shell-command",
+    "shell-escalation",
+    "skills",
+    "core",
+    "core-api",
+    "core-plugins",
+    "diagnostics",
+    "guardian-context",
+    "hooks",
+    "history",
+    "http-client",
+    "secrets",
+    "exec",
+    "file-system",
+    "exec-server-protocol",
+    "exec-server",
+    "exec-server/tests/support",
+    "execpolicy",
+    "ext/agent",
+    "ext/connectors",
+    "ext/extension-api",
+    "ext/goal",
+    "ext/git-attribution",
+    "ext/guardian-reviewer",
+    "ext/guardian-v2",
+    "ext/history-notes",
+    "ext/image-generation",
+    "ext/items",
+    "ext/memories",
+    "ext/mcp",
+    "ext/queue",
+    "ext/skills",
+    "ext/web-search",
+    "external-agent-migration",
+    "keyring-store",
+    "file-search",
+    "file-watcher",
+    "linux-sandbox",
+    "lmstudio",
+    "login",
+    "codex-mcp",
+    "memories/read",
+    "memories/write",
+    "mermaid",
+    "model-provider-info",
+    "mxc-sandbox",
+    "models-manager",
+    "network-proxy",
+    "ollama",
+    "process-hardening",
+    "realtime-webrtc",
+    "voice-host",
+    "protocol",
+    "prompts",
+    "rollout",
+    "rollout-trace",
+    "rmcp-client",
+    "responses-api-proxy",
+    "response-debug-context",
+    "sandboxing",
+    "stdio-to-uds",
+    "otel",
+    "otel-trace-websocket",
+    "tcp-tunnel",
+    "tui",
+    "user-verification",
+    "tools",
+    "v8-poc",
+    "websocket-client",
+    "windows-sandbox-service",
+    "worktree",
+    "workload-identity",
+    "utils/absolute-path",
+    "utils/audio",
+    "utils/path-uri",
+    "utils/cargo-bin",
+    "git-utils",
+    "utils/cache",
+    "utils/git-discovery",
+    "utils/image",
+    "utils/json-to-toml",
+    "utils/home-dir",
+    "utils/pty",
+    "utils/readiness",
+    "utils/redacted-string",
+    "utils/rustls-provider",
+    "utils/string",
+    "utils/cli",
+    "utils/elapsed",
+    "utils/sandbox-summary",
+    "utils/sleep-inhibitor",
+    "utils/approval-presets",
+    "utils/oss",
+    "utils/output-truncation",
+    "utils/path-utils",
+    "utils/plugins",
+    "utils/fuzzy-match",
+    "utils/stream-parser",
+    "utils/template",
+    "codex-client",
+    "codex-api",
+    "state",
+    "terminal-detection",
+    "test-binary-support",
+    "thread-manager-sample",
+    "thread-store",
+    "uds",
+    "codex-experimental-api-macros",
+    "plugin",
+    "model-provider",
+]
+resolver = "2"
+
+[workspace.package]
+version = "0.0.0"
+# Track the edition for all workspace crates in one place. Individual
+# crates can still override this value, but keeping it here means new
+# crates created with `cargo new -w ...` automatically inherit the 2024
+# edition.
+edition = "2024"
+license = "Apache-2.0"
+
+[workspace.dependencies]
+# Internal
+codex-realtime-webrtc = { path = "realtime-webrtc" }
+app_test_support = { path = "app-server/tests/common" }
+codex-analytics = { path = "analytics" }
+codex-agent-graph-store = { path = "agent-graph-store" }
+codex-agent-identity = { path = "agent-identity" }
+codex-agent-roles = { path = "agent-roles" }
+codex-ansi-escape = { path = "ansi-escape" }
+codex-api = { path = "codex-api" }
+codex-attachment-store = { path = "attachment-store" }
+codex-aws-auth = { path = "aws-auth" }
+codex-app-server = { path = "app-server" }
+codex-app-server-transport = { path = "app-server-transport" }
+codex-app-server-daemon = { path = "app-server-daemon" }
+codex-app-server-client = { path = "app-server-client" }
+codex-app-server-protocol = { path = "app-server-protocol" }
+codex-app-server-protocol-noop-macros = { path = "app-server-protocol-noop-macros" }
+codex-app-server-test-client = { path = "app-server-test-client" }
+codex-apply-patch = { path = "apply-patch" }
+codex-arg0 = { path = "arg0" }
+codex-async-utils = { path = "async-utils" }
+codex-backend-client = { path = "backend-client" }
+codex-build-info = { path = "build-info" }
+codex-chatgpt = { path = "chatgpt" }
+codex-client = { path = "codex-client" }
+codex-collaboration-mode-templates = { path = "collaboration-mode-templates" }
+codex-cloud-config = { path = "cloud-config" }
+codex-cloud-tasks-client = { path = "cloud-tasks-client" }
+codex-cloud-tasks-mock-client = { path = "cloud-tasks-mock-client" }
+codex-code-mode = { path = "code-mode" }
+codex-code-mode-protocol = { path = "code-mode-protocol" }
+codex-code-mode-runtime = { path = "code-mode-runtime" }
+codex-home = { path = "codex-home" }
+codex-http-client = { path = "http-client" }
+codex-websocket-client = { path = "websocket-client" }
+codex-config = { path = "config" }
+codex-connectors = { path = "connectors" }
+codex-agent-extension = { path = "ext/agent" }
+codex-connectors-extension = { path = "ext/connectors" }
+codex-context-fragments = { path = "context-fragments" }
+codex-core = { path = "core" }
+codex-core-api = { path = "core-api" }
+codex-core-plugins = { path = "core-plugins" }
+codex-diagnostics = { path = "diagnostics" }
+codex-exec = { path = "exec" }
+codex-file-system = { path = "file-system" }
+codex-exec-server-protocol = { path = "exec-server-protocol" }
+codex-exec-server = { path = "exec-server" }
+codex-exec-server-test-support = { path = "exec-server/tests/support" }
+codex-execpolicy = { path = "execpolicy" }
+codex-extension-api = { path = "ext/extension-api" }
+codex-extension-items = { path = "ext/items" }
+codex-goal-extension = { path = "ext/goal" }
+codex-git-attribution = { path = "ext/git-attribution" }
+codex-guardian-reviewer = { path = "ext/guardian-reviewer" }
+codex-guardian-v2 = { path = "ext/guardian-v2" }
+codex-history-notes-extension = { path = "ext/history-notes" }
+codex-image-generation-extension = { path = "ext/image-generation" }
+codex-external-agent-migration = { path = "external-agent-migration" }
+codex-experimental-api-macros = { path = "codex-experimental-api-macros" }
+codex-features = { path = "features" }
+codex-feedback = { path = "feedback" }
+codex-install-context = { path = "install-context" }
+codex-file-search = { path = "file-search" }
+codex-file-watcher = { path = "file-watcher" }
+codex-git-utils = { path = "git-utils" }
+codex-guardian-context = { path = "guardian-context" }
+codex-hooks = { path = "hooks" }
+codex-history = { path = "history" }
+codex-keyring-store = { path = "keyring-store" }
+codex-linux-sandbox = { path = "linux-sandbox" }
+codex-lmstudio = { path = "lmstudio" }
+codex-login = { path = "login" }
+codex-message-history = { path = "message-history" }
+codex-memories-extension = { path = "ext/memories" }
+codex-web-search-extension = { path = "ext/web-search" }
+codex-memories-read = { path = "memories/read" }
+codex-memories-write = { path = "memories/write" }
+codex-mcp = { path = "codex-mcp" }
+codex-mcp-extension = { path = "ext/mcp" }
+codex-model-provider-info = { path = "model-provider-info" }
+codex-models-manager = { path = "models-manager" }
+codex-mxc-sandbox = { path = "mxc-sandbox" }
+codex-network-proxy = { path = "network-proxy" }
+codex-ollama = { path = "ollama" }
+codex-otel = { path = "otel" }
+codex-otel-trace-websocket = { path = "otel-trace-websocket" }
+codex-plugin = { path = "plugin" }
+codex-model-provider = { path = "model-provider" }
+codex-process-hardening = { path = "process-hardening" }
+codex-protocol = { path = "protocol" }
+codex-prompts = { path = "prompts" }
+codex-queue-extension = { path = "ext/queue" }
+codex-responses-api-proxy = { path = "responses-api-proxy" }
+codex-response-debug-context = { path = "response-debug-context" }
+codex-rmcp-client = { path = "rmcp-client" }
+codex-rollout = { path = "rollout" }
+codex-rollout-trace = { path = "rollout-trace" }
+codex-sandboxing = { path = "sandboxing" }
+codex-secrets = { path = "secrets" }
+codex-shell-command = { path = "shell-command" }
+codex-shell-escalation = { path = "shell-escalation" }
+codex-skills-extension = { path = "ext/skills" }
+codex-skills = { path = "skills" }
+codex-state = { path = "state" }
+codex-stdio-to-uds = { path = "stdio-to-uds" }
+codex-terminal-detection = { path = "terminal-detection" }
+codex-test-binary-support = { path = "test-binary-support" }
+codex-thread-store = { path = "thread-store" }
+codex-tools = { path = "tools" }
+codex-tcp-tunnel = { path = "tcp-tunnel" }
+codex-tui = { path = "tui" }
+codex-uds = { path = "uds" }
+codex-utils-absolute-path = { path = "utils/absolute-path" }
+codex-utils-approval-presets = { path = "utils/approval-presets" }
+codex-utils-audio = { path = "utils/audio" }
+codex-utils-cache = { path = "utils/cache" }
+codex-utils-cargo-bin = { path = "utils/cargo-bin" }
+codex-utils-cli = { path = "utils/cli" }
+codex-utils-elapsed = { path = "utils/elapsed" }
+codex-utils-fuzzy-match = { path = "utils/fuzzy-match" }
+codex-utils-git-discovery = { path = "utils/git-discovery" }
+codex-utils-home-dir = { path = "utils/home-dir" }
+codex-utils-image = { path = "utils/image" }
+codex-utils-json-to-toml = { path = "utils/json-to-toml" }
+codex-utils-oss = { path = "utils/oss" }
+codex-utils-output-truncation = { path = "utils/output-truncation" }
+codex-utils-path = { path = "utils/path-utils" }
+codex-utils-path-uri = { path = "utils/path-uri" }
+codex-utils-plugins = { path = "utils/plugins" }
+codex-utils-pty = { path = "utils/pty" }
+codex-utils-redacted-string = { path = "utils/redacted-string" }
+codex-utils-rustls-provider = { path = "utils/rustls-provider" }
+codex-utils-sandbox-summary = { path = "utils/sandbox-summary" }
+codex-worktree = { path = "worktree" }
+codex-utils-sleep-inhibitor = { path = "utils/sleep-inhibitor" }
+codex-utils-stream-parser = { path = "utils/stream-parser" }
+codex-utils-string = { path = "utils/string" }
+codex-utils-template = { path = "utils/template" }
+codex-user-verification = { path = "user-verification" }
+codex-v8-poc = { path = "v8-poc" }
+codex-workload-identity = { path = "workload-identity" }
+codex-windows-sandbox = { path = "windows-sandbox-rs" }
+core_test_support = { path = "core/tests/common" }
+
+# External
+learning_mode_windows = { git = "https://github.com/microsoft/mxc", rev = "6cd3d58f05d3447e67109cfb75e042803b843ca4" }
+wxc_common = { git = "https://github.com/microsoft/mxc", rev = "6cd3d58f05d3447e67109cfb75e042803b843ca4" }
+age = "0.11.1"
+ansi-to-tui = "8.0.1"
+anyhow = "1"
+appcontainer_common = { git = "https://github.com/microsoft/mxc", rev = "6cd3d58f05d3447e67109cfb75e042803b843ca4" }
+arboard = { version = "3", features = ["wayland-data-control"] }
+arc-swap = "1.9.0"
+assert_cmd = "2"
+assert_matches = "1.5.0"
+async-channel = "2.3.1"
+async-io = "2.6.0"
+async-stream = "0.3.6"
+aws-config = "1"
+aws-credential-types = "1"
+aws-sigv4 = "1"
+aws-types = "1"
+axum = { version = "0.8", default-features = false }
+base64 = "0.22.1"
+bitflags = "2.13.1"
+blake3 = "1.8.2"
+bm25 = "2.3.2"
+bytes = "1.10.1"
+chardetng = "0.1.17"
+chrono = "0.4.43"
+clap = "4"
+clap_complete = "4"
+clatter = { version = "2.2.0", default-features = false, features = [
+    "alloc",
+    "getrandom",
+    "use-25519",
+    "use-aes-gcm",
+    "use-rust-crypto-ml-kem",
+    "use-sha",
+] }
+color-eyre = "0.6.3"
+constant_time_eq = "0.3.1"
+crossbeam-channel = "0.5.15"
+crypto_box = { version = "0.9.1", features = ["seal"] }
+crossterm = "0.29.0"
+ctor = "0.6.3"
+deno_core_icudata = "0.77.0"
+derive_more = "2"
+diffy = "0.4.2"
+dirs = "6"
+divan = "0.1.21"
+dns-lookup = "3.0.1"
+dotenvy = "0.15.7"
+dunce = "1.0.4"
+ed25519-dalek = { version = "2.2.0", features = ["pkcs8"] }
+encoding_rs = "0.8.35"
+eventsource-stream = "0.2.3"
+flate2 = "1.1.8"
+futures = { version = "0.3", default-features = false }
+gethostname = "1.1.0"
+gix = { version = "0.81.0", default-features = false, features = ["sha1"] }
+gix-url = "0.35.2"
+glob = "0.3"
+globset = "0.4"
+hmac = "0.12.1"
+http = "1.3.1"
+httpdate = "1.0.3"
+iana-time-zone = "0.1.64"
+icu_decimal = "2.1"
+icu_locale_core = "2.1"
+icu_provider = { version = "2.1", features = ["sync"] }
+ignore = "0.4.23"
+image = { version = "^0.25.9", default-features = false }
+include_dir = "0.7.4"
+indexmap = "2.12.0"
+insta = "1.46.3"
+inventory = "0.3.19"
+itertools = "0.14.0"
+jsonptr = { version = "0.7.1", default-features = false }
+jsonwebtoken = "9.3.1"
+keyring = { version = "3.6", default-features = false }
+landlock = "0.4.4"
+lazy_static = "1"
+libc = "0.2.182"
+# Keep SQLx's bundled SQLite on a version containing the WAL-reset corruption fix:
+# https://www.sqlite.org/wal.html#the_wal_reset_bug
+libsqlite3-sys = { version = "0.37", default-features = false }
+log = "0.4"
+lru = "0.18.2"
+maplit = "1.0.2"
+memchr = "2.7.6"
+mime_guess = "2.0.5"
+multimap = "0.10.0"
+notify = "8.2.0"
+nucleo = { git = "https://github.com/helix-editor/nucleo.git", rev = "4253de9faabb4e5c6d81d946a5e35a90f87347ee" }
+once_cell = "1.20.2"
+openssl-sys = "*"
+opentelemetry = "0.31.0"
+opentelemetry-appender-tracing = "0.31.0"
+opentelemetry-otlp = "0.31.0"
+opentelemetry-semantic-conventions = "0.31.0"
+opentelemetry_sdk = "0.31.0"
+os_info = "3.12.0"
+owo-colors = "4.3.0"
+pathdiff = "0.2"
+portable-pty = "0.9.0"
+predicates = "3"
+pretty_assertions = "1.4.1"
+pulldown-cmark = { version = "0.10", default-features = false }
+quick-xml = "0.41.0"
+rand = "0.9"
+rand_regex = "0.18.1"
+ratatui = { version = "0.30.2", default-features = false, features = [
+    "crossterm",
+    "layout-cache",
+    "underline-color",
+] }
+ratatui-macros = "0.7.2"
+rcgen = { version = "0.14.7", default-features = false, features = [
+    "aws_lc_rs",
+    "pem",
+] }
+regex = "1.12.3"
+regex-automata = { version = "0.4.13", default-features = false, features = ["std", "syntax", "unicode", "nfa-pikevm"] }
+regex-lite = "0.1.8"
+regex-syntax = "0.8.8"
+reqwest = { version = "0.12", features = ["cookies"] }
+rmcp = { version = "=3.2.0", default-features = false }
+runfiles = { git = "https://github.com/dzbarsky/rules_rust", rev = "b56cbaa8465e74127f1ea216f813cd377295ad81" }
+rustix = { version = "1.1.4", features = ["net"] }
+rustls = { version = "0.23.45", default-features = false, features = [
+    "aws_lc_rs",
+    "std",
+] }
+rustls-native-certs = "0.8.3"
+rustls-pki-types = "1.14.0"
+schemars = "0.8.22"
+seccompiler = "0.5.0"
+semver = "1.0"
+sentry = "0.46.0"
+serde = { version = "1", features = ["rc"] }
+serde_ignored = "0.1.14"
+serde_json = "1"
+serde_path_to_error = "0.1.20"
+serde_with = "3.17"
+serde_yaml = "0.9"
+serial_test = "3.2.0"
+sha1 = "0.10.6"
+scopeguard = "1.2.0"
+sha2 = "0.10"
+shlex = "1.3.0"
+signal-hook = "0.3.18"
+similar = "2.7.0"
+symphonia = { version = "0.6.0", default-features = false, features = [
+    "isomp4",
+    "mkv",
+    "mp3",
+    "ogg",
+    "wav",
+] }
+socket2 = "0.6.1"
+# When bumping sqlx, audit the SQLite constructor deny list in clippy.toml.
+sqlx = { version = "0.9.0", default-features = false, features = [
+    "chrono",
+    "json",
+    "macros",
+    "migrate",
+    "runtime-tokio",
+    "tls-rustls",
+    "sqlite-bundled",
+    "time",
+    "uuid",
+] }
+starlark = { version = "0.14.2", default-features = false }
+strum = "0.27.2"
+strum_macros = "0.28.0"
+supports-color = "3.0.2"
+syntect = "5"
+sys-locale = "0.3.2"
+system-configuration = "0.7"
+tar = { version = "=0.4.45", default-features = false }
+tempfile = "3.23.0"
+test-log = "0.2.19"
+textwrap = "0.16.2"
+thiserror = "2.0.17"
+tikv-jemallocator = "=0.7.0"
+time = "0.3.47"
+tiny_http = "0.12"
+tokio = "1"
+tokio-rustls = "0.26.4"
+tokio-stream = "0.1.18"
+tokio-test = "0.4"
+tokio-tungstenite = { version = "0.28.0", features = [
+    "proxy",
+    "rustls-tls-native-roots",
+] }
+tokio-util = "0.7.18"
+toml = "0.9.5"
+toml_edit = "0.24.0"
+tracing = "0.1.44"
+tracing-appender = "0.2.3"
+tracing-opentelemetry = "0.32.0"
+tracing-subscriber = "0.3.22"
+tracing-test = "0.2.5"
+tonic = { version = "0.14.3", default-features = false, features = ["channel", "codegen"] }
+tonic-prost = "0.14.3"
+tree-sitter = "0.25.10"
+tree-sitter-bash = "0.25"
+tree-sitter-powershell = "=0.26.4"
+ts-rs = "11"
+tungstenite = { version = "0.27.0", features = ["deflate", "proxy"] }
+uds_windows = "1.1.0"
+unicode-segmentation = "1.12.0"
+unicode-width = "0.2"
+url = "2"
+urlencoding = "2.1"
+uuid = "1"
+v8 = "=150.4.0"
+vt100 = "0.16.2"
+walkdir = "2.5.0"
+webbrowser = "1.2.2"
+which = "8"
+whoami = "1.6.1"
+wildmatch = "2.6.1"
+winapi-util = "0.1.11"
+zip = "2.4.2"
+zstd = "0.13"
+
+wiremock = "0.6"
+zeroize = "1.8.2"
+
+[workspace.lints]
+rust = {}
+
+[workspace.lints.clippy]
+await_holding_invalid_type = "deny"
+await_holding_lock = "deny"
+disallowed_methods = "deny"
+expect_used = "deny"
+identity_op = "deny"
+manual_clamp = "deny"
+manual_filter = "deny"
+manual_find = "deny"
+manual_flatten = "deny"
+manual_map = "deny"
+manual_memcpy = "deny"
+manual_non_exhaustive = "deny"
+manual_ok_or = "deny"
+manual_range_contains = "deny"
+manual_retain = "deny"
+manual_strip = "deny"
+manual_try_fold = "deny"
+manual_unwrap_or = "deny"
+needless_borrow = "deny"
+needless_borrowed_reference = "deny"
+needless_collect = "deny"
+needless_late_init = "deny"
+needless_option_as_deref = "deny"
+needless_question_mark = "deny"
+needless_update = "deny"
+redundant_clone = "deny"
+redundant_closure = "deny"
+redundant_closure_for_method_calls = "deny"
+redundant_static_lifetimes = "deny"
+trivially_copy_pass_by_ref = "deny"
+uninlined_format_args = "deny"
+unnecessary_filter_map = "deny"
+unnecessary_lazy_evaluations = "deny"
+unnecessary_sort_by = "deny"
+unnecessary_to_owned = "deny"
+unwrap_used = "deny"
+
+# cargo-shear cannot see the platform-specific openssl-sys usage, so we
+# silence the false positive here instead of deleting a real dependency.
+[workspace.metadata.cargo-shear]
+ignored = [
+    "icu_provider",
+    "openssl-sys",
+    "codex-v8-poc",
+]
+
+[profile.dev]
+# Keep line tables/backtraces while avoiding expensive full variable debug info
+# across local dev builds.
+debug = "limited"
+
+[profile.dev-small]
+inherits = "dev"
+opt-level = 0
+debug = "none"
+strip = "symbols"
+
+[profile.release]
+lto = "thin"
+debug = "line-tables-only"
+split-debuginfo = "off"
+# Keep release binaries symbolicateable until packaging has archived the
+# sidecar symbols and stripped the binaries.
+strip = false
+
+# Balance parallel release code generation against binary size.
+codegen-units = 4
+
+[profile.profiling]
+inherits = "release"
+debug = "full"
+lto = false
+strip = false
+
+[profile.ci-test]
+# Reduce binary size to reduce disk pressure.
+debug = "limited"
+inherits = "test"
+opt-level = 0
+
+[patch.crates-io]
+# Uncomment to debug local changes.
+# ratatui = { path = "../../ratatui" }
+crossterm = { git = "https://github.com/openai-oss-forks/crossterm", rev = "45fecb9508105988f42fe6ff0441783ed3717f92" }
+tokio-tungstenite = { git = "https://github.com/openai-oss-forks/tokio-tungstenite", rev = "0e5b2d73aa18dd9f0a50ee9ff199d5aef7594186" }
+tungstenite = { git = "https://github.com/openai-oss-forks/tungstenite-rs", rev = "4fffad30fe373adbdcffab9545e9e9bf4f2fc19f" }
+
+# Uncomment to debug local changes.
+# rmcp = { path = "../../rust-sdk/crates/rmcp" }
+
+[patch."ssh://git@github.com/openai-oss-forks/tungstenite-rs.git"]
+tungstenite = { git = "https://github.com/openai-oss-forks/tungstenite-rs", rev = "4fffad30fe373adbdcffab9545e9e9bf4f2fc19f" }

codex-rs/README.md

@@ -0,0 +1,3 @@
+# Codex CLI
+
+[**Codex CLI Documentation**](https://developers.openai.com/codex/cli)

codex-rs/clippy.toml

@@ -0,0 +1,32 @@
+allow-expect-in-tests = true
+allow-unwrap-in-tests = true
+await-holding-invalid-types = [
+    "tokio::sync::MutexGuard",
+    "tokio::sync::RwLockReadGuard",
+    "tokio::sync::RwLockWriteGuard",
+]
+disallowed-methods = [
+    { path = "ratatui::style::Color::Rgb", reason = "Use ANSI colors, which work better in various terminal themes." },
+    { path = "ratatui::style::Color::Indexed", reason = "Use ANSI colors, which work better in various terminal themes." },
+    { path = "ratatui::style::Stylize::white", reason = "Avoid hardcoding white; prefer default fg or dim/bold. Exception: Disable this rule if rendering over a hardcoded ANSI background." },
+    { path = "ratatui::style::Stylize::black", reason = "Avoid hardcoding black; prefer default fg or dim/bold. Exception: Disable this rule if rendering over a hardcoded ANSI background." },
+    { path = "ratatui::style::Stylize::yellow", reason = "Avoid yellow; prefer other colors in `tui/styles.md`." },
+    # Audited against workspace sqlx 0.9.0. Revisit this SQLite escape-hatch list when bumping sqlx.
+    { path = "sqlx::Pool::connect", reason = "Create SQLite pools through codex-state's sqlite shim." },
+    { path = "sqlx::Pool::connect_with", reason = "Create SQLite pools through codex-state's sqlite shim." },
+    { path = "sqlx::Pool::connect_lazy", reason = "Create SQLite pools through codex-state's sqlite shim." },
+    { path = "sqlx::Pool::connect_lazy_with", reason = "Create SQLite pools through codex-state's sqlite shim." },
+    { path = "sqlx::Pool::set_connect_options", reason = "Do not replace options on SQLite pools created by codex-state's sqlite shim." },
+    { path = "sqlx::pool::PoolOptions::connect", reason = "Create SQLite pools through codex-state's sqlite shim." },
+    { path = "sqlx::pool::PoolOptions::connect_with", reason = "Create SQLite pools through codex-state's sqlite shim." },
+    { path = "sqlx::pool::PoolOptions::connect_lazy", reason = "Create SQLite pools through codex-state's sqlite shim." },
+    { path = "sqlx::pool::PoolOptions::connect_lazy_with", reason = "Create SQLite pools through codex-state's sqlite shim." },
+    { path = "sqlx::Connection::connect", reason = "Create SQLite connections through codex-state's sqlite shim." },
+    { path = "sqlx::Connection::connect_with", reason = "Create SQLite connections through codex-state's sqlite shim." },
+    { path = "sqlx::ConnectOptions::connect", reason = "Create SQLite connections through codex-state's sqlite shim." },
+    { path = "sqlx::migrate::MigrateDatabase::create_database", reason = "Create SQLite databases through codex-state's sqlite shim." },
+]
+
+# Increase the size threshold for result_large_err to accommodate
+# richer error variants.
+large-error-threshold = 256

codex-rs/config.md

@@ -0,0 +1,6 @@
+# Configuration docs moved
+
+This file has moved. Please see the latest configuration documentation here:
+
+- Full config docs: [docs/config.md](https://github.com/openai/codex/blob/main/docs/config.md)
+- MCP servers section: [docs/config.md#connecting-to-mcp-servers](https://github.com/openai/codex/blob/main/docs/config.md#connecting-to-mcp-servers)

codex-rs/default.nix

@@ -0,0 +1,55 @@
+{
+  cmake,
+  llvmPackages,
+  openssl,
+  libcap ? null,
+  rustPlatform,
+  pkg-config,
+  lib,
+  stdenv,
+  version ? "0.0.0",
+  ...
+}:
+rustPlatform.buildRustPackage (_: {
+  env.PKG_CONFIG_PATH = lib.makeSearchPathOutput "dev" "lib/pkgconfig" (
+    [ openssl ] ++ lib.optionals stdenv.isLinux [ libcap ]
+  );
+  pname = "codex-rs";
+  inherit version;
+  cargoLock.lockFile = ./Cargo.lock;
+  doCheck = false;
+  src = ./.;
+
+  # Patch the workspace Cargo.toml so that cargo embeds the correct version in
+  # CARGO_PKG_VERSION (which the binary reads via env!("CARGO_PKG_VERSION")).
+  # On release commits the Cargo.toml already contains the real version and
+  # this sed is a no-op.
+  postPatch = ''
+    sed -i 's/^version = "0\.0\.0"$/version = "${version}"/' Cargo.toml
+  '';
+  nativeBuildInputs = [
+    cmake
+    llvmPackages.clang
+    llvmPackages.libclang.lib
+    openssl
+    pkg-config
+  ] ++ lib.optionals stdenv.isLinux [
+    libcap
+  ];
+
+  cargoLock.outputHashes = {
+    "crossterm-0.29.0" = "sha256-ewiWWQPEU1lSUHzmZTiO5yes5luIaQ9TrvCNnTWhxpE=";
+    "nucleo-0.5.0" = "sha256-Hm4SxtTSBrcWpXrtSqeO0TACbUxq3gizg1zD/6Yw/sI=";
+    "nucleo-matcher-0.3.1" = "sha256-Hm4SxtTSBrcWpXrtSqeO0TACbUxq3gizg1zD/6Yw/sI=";
+    "runfiles-0.1.0" = "sha256-uJpVLcQh8wWZA3GPv9D8Nt43EOirajfDJ7eq/FB+tek=";
+    "tokio-tungstenite-0.28.0" = "sha256-hJAkvWxDjB9A9GqansahWhTmj/ekcelslLUTtwqI7lw=";
+    "tungstenite-0.27.0" = "sha256-AN5wql2X2yJnQ7lnDxpljNw0Jua40GtmT+w3wjER010=";
+  };
+
+  meta = with lib; {
+    description = "OpenAI Codex command‑line interface rust implementation";
+    license = licenses.asl20;
+    homepage = "https://github.com/openai/codex";
+    mainProgram = "codex";
+  };
+})

codex-rs/deny.toml

@@ -0,0 +1,332 @@
+# This template contains all of the possible sections and their default values
+
+# Note that all fields that take a lint level have these possible values:
+# * deny - An error will be produced and the check will fail
+# * warn - A warning will be produced, but the check will not fail
+# * allow - No warning or error will be produced, though in some cases a note
+# will be
+
+# The values provided in this template are the default values that will be used
+# when any section or field is not specified in your own configuration
+
+# Root options
+
+# The graph table configures how the dependency graph is constructed and thus
+# which crates the checks are performed against
+[graph]
+# If 1 or more target triples (and optionally, target_features) are specified,
+# only the specified targets will be checked when running `cargo deny check`.
+# This means, if a particular package is only ever used as a target specific
+# dependency, such as, for example, the `nix` crate only being used via the
+# `target_family = "unix"` configuration, that only having windows targets in
+# this list would mean the nix crate, as well as any of its exclusive
+# dependencies not shared by any other crates, would be ignored, as the target
+# list here is effectively saying which targets you are building for.
+targets = [
+    # The triple can be any string, but only the target triples built in to
+    # rustc (as of 1.40) can be checked against actual config expressions
+    #"x86_64-unknown-linux-musl",
+    # You can also specify which target_features you promise are enabled for a
+    # particular target. target_features are currently not validated against
+    # the actual valid features supported by the target architecture.
+    #{ triple = "wasm32-unknown-unknown", features = ["atomics"] },
+]
+# When creating the dependency graph used as the source of truth when checks are
+# executed, this field can be used to prune crates from the graph, removing them
+# from the view of cargo-deny. This is an extremely heavy hammer, as if a crate
+# is pruned from the graph, all of its dependencies will also be pruned unless
+# they are connected to another crate in the graph that hasn't been pruned,
+# so it should be used with care. The identifiers are [Package ID Specifications]
+# (https://doc.rust-lang.org/cargo/reference/pkgid-spec.html)
+#exclude = []
+# If true, metadata will be collected with `--all-features`. Note that this can't
+# be toggled off if true, if you want to conditionally enable `--all-features` it
+# is recommended to pass `--all-features` on the cmd line instead
+all-features = false
+# If true, metadata will be collected with `--no-default-features`. The same
+# caveat with `all-features` applies
+no-default-features = false
+# If set, these feature will be enabled when collecting metadata. If `--features`
+# is specified on the cmd line they will take precedence over this option.
+#features = []
+
+# The output table provides options for how/if diagnostics are outputted
+[output]
+# When outputting inclusion graphs in diagnostics that include features, this
+# option can be used to specify the depth at which feature edges will be added.
+# This option is included since the graphs can be quite large and the addition
+# of features from the crate(s) to all of the graph roots can be far too verbose.
+# This option can be overridden via `--feature-depth` on the cmd line
+feature-depth = 1
+
+# This section is considered when running `cargo deny check advisories`
+# More documentation for the advisories section can be found here:
+# https://embarkstudios.github.io/cargo-deny/checks/advisories/cfg.html
+[advisories]
+# The path where the advisory databases are cloned/fetched into
+#db-path = "$CARGO_HOME/advisory-dbs"
+# The url(s) of the advisory databases to use
+#db-urls = ["https://github.com/rustsec/advisory-db"]
+# A list of advisory IDs to ignore. Note that ignored advisories will still
+# output a note when they are encountered.
+ignore = [
+    # Reviewed 2026-07-02. Keep this list in sync with .cargo/audit.toml.
+    # Each exception must identify the dependency path and removal condition.
+    { id = "RUSTSEC-2024-0388", reason = "derivative is unmaintained; pulled in via starlark/starlark_syntax v0.14.2 used by execpolicy/cli/core; no fixed starlark release yet" },
+    { id = "RUSTSEC-2025-0057", reason = "fxhash is unmaintained; pulled in via starlark_map under starlark v0.14.2 used by execpolicy/cli/core and bm25 used by core; remove when upstream dependencies drop fxhash" },
+    { id = "RUSTSEC-2024-0436", reason = "paste is unmaintained; pulled in via starlark/v8 used by execpolicy/code-mode; no fixed release yet" },
+    { id = "RUSTSEC-2023-0089", reason = "atomic-polyfill is unmaintained; pulled in via postcard/heapless/pagable under starlark v0.14.2 used by execpolicy/cli/core; no fixed starlark release yet" },
+    # TODO(fcoury): remove this exception when syntect drops yaml-rust and bincode, or updates to versions that have fixed the vulnerabilities.
+    { id = "RUSTSEC-2024-0320", reason = "yaml-rust is unmaintained; pulled in via syntect v5.3.0 used by codex-tui for syntax highlighting; no fixed release yet" },
+    { id = "RUSTSEC-2025-0141", reason = "bincode is unmaintained; pulled in via syntect v5.3.0 used by codex-tui for syntax highlighting; no fixed release yet" },
+    { id = "RUSTSEC-2026-0118", reason = "hickory-proto v0.25.2 is pulled in via rama-dns/rama-tcp used by codex-network-proxy; DNSSEC features are not enabled; remove when rama updates to hickory 0.26.1 or hickory-net" },
+    { id = "RUSTSEC-2026-0119", reason = "hickory-proto v0.25.2 is pulled in via rama-dns/rama-tcp used by codex-network-proxy; no fixed rama release is available yet; remove when rama updates to hickory 0.26.1 or hickory-net" },
+    { id = "RUSTSEC-2026-0173", reason = "proc-macro-error2 is unmaintained; pulled in via i18n-embed-fl/age used by codex-secrets local storage; remove when codex-secrets migrates off age or age drops i18n-embed-fl" },
+    { id = "RUSTSEC-2026-0194", reason = "quick-xml v0.39.4 remains via plist/syntect and wayland-scanner; plist does not exercise the affected APIs and wayland-scanner parses trusted build-time XML; remove when rust-plist#191 and wayland-rs#938 are released" },
+    { id = "RUSTSEC-2026-0195", reason = "quick-xml v0.39.4 remains via plist/syntect and wayland-scanner; plist does not exercise the affected APIs and wayland-scanner parses trusted build-time XML; remove when rust-plist#191 and wayland-rs#938 are released" },
+]
+# If this is true, then cargo deny will use the git executable to fetch advisory database.
+# If this is false, then it uses a built-in git library.
+# Setting this to true can be helpful if you have special authentication requirements that cargo-deny does not support.
+# See Git Authentication for more information about setting up git authentication.
+#git-fetch-with-cli = true
+
+# This section is considered when running `cargo deny check licenses`
+# More documentation for the licenses section can be found here:
+# https://embarkstudios.github.io/cargo-deny/checks/licenses/cfg.html
+[licenses]
+# List of explicitly allowed licenses
+# See https://spdx.org/licenses/ for list of possible licenses
+# [possible values: any SPDX 3.11 short identifier (+ optional exception)].
+allow = [
+    # Apache-2.0 - https://www.apache.org/licenses/LICENSE-2.0
+    # Used by: allocative, anyhow, arboard, assert_cmd, assert_matches, async-channel, async-trait, base64, chardetng, chrono, clap, clap_complete, color-eyre, ctor, diffy, dirs, dunce, encoding_rs, env_logger, escargot, eventsource-stream, futures, http, image, indexmap, insta, itertools, keyring, landlock, lazy_static, libc, log, maplit, multimap, once_cell, opentelemetry, opentelemetry-appender-tracing, opentelemetry-otlp, opentelemetry-semantic-conventions, opentelemetry_sdk, pathdiff, predicates, pretty_assertions, rand, regex-lite, reqwest, seccompiler, serde, serde_json, serde_with, sha1, sha2, shlex, similar, socket2, starlark, supports-color, sys-locale, tempfile, test-log, thiserror, time, tiny_http, toml, toml_edit, unicode-segmentation, unicode-width, url, uuid, webbrowser, wiremock, zeroize
+    "Apache-2.0",
+    # Apache-2.0 WITH LLVM-exception - https://spdx.org/licenses/LLVM-exception.html
+    # Used by: target-lexicon
+    "Apache-2.0 WITH LLVM-exception",
+    # BSD-2-Clause - https://opensource.org/license/bsd-2-clause
+    # Used by: transitive only
+    "BSD-2-Clause",
+    # BSD-3-Clause - https://opensource.org/license/bsd-3-clause
+    # Used by: encoding_rs, seccompiler
+    "BSD-3-Clause",
+    # BSL-1.0 - https://www.boost.org/users/license.html
+    # Used by: transitive only
+    "BSL-1.0",
+    # CC0-1.0 - https://creativecommons.org/publicdomain/zero/1.0/
+    # Used by: dunce, notify
+    "CC0-1.0",
+    # CDLA-Permissive-2.0 - https://cdla.dev/permissive-2-0/
+    # Used by: transitive only
+    "CDLA-Permissive-2.0",
+    # ISC - https://opensource.org/license/isc-license-txt
+    # Used by: transitive only
+    "ISC",
+    # MIT - https://opensource.org/license/mit
+    # Used by: allocative, ansi-to-tui, anyhow, arboard, assert_cmd, assert_matches, async-channel, async-stream, async-trait, axum, base64, bytes, chardetng, chrono, clap, clap_complete, color-eyre, crossterm, ctor, derive_more, diffy, dirs, dotenvy, encoding_rs, env_logger, escargot, eventsource-stream, futures, http, ignore, image, indexmap, itertools, keyring, landlock, lazy_static, libc, log, lru, maplit, mime_guess, multimap, once_cell, openssl-sys, os_info, owo-colors, path-absolutize, pathdiff, portable-pty, predicates, pretty_assertions, pulldown-cmark, rand, ratatui, ratatui-macros, regex-lite, reqwest, rmcp, schemars, serde, serde_json, serde_with, serial_test, sha1, sha2, shlex, socket2, strum, strum_macros, sys-locale, tempfile, test-log, textwrap, thiserror, time, tiny_http, tokio, tokio-stream, tokio-test, tokio-util, toml, toml_edit, tonic, tracing, tracing-appender, tracing-subscriber, tracing-test, tree-sitter, tree-sitter-bash, tree-sitter-highlight, ts-rs, uds_windows, unicode-segmentation, unicode-width, url, urlencoding, uuid, vt100, walkdir, webbrowser, which, wildmatch, wiremock, zeroize
+    "MIT",
+    # MIT-0 - https://opensource.org/license/mit-0
+    # Used by: dunce
+    "MIT-0",
+    # MPL-2.0 - https://www.mozilla.org/MPL/2.0/
+    # Used by: nucleo-matcher
+    "MPL-2.0",
+    # OpenSSL - https://spdx.org/licenses/OpenSSL.html
+    # Used by: aws-lc-sys
+    "OpenSSL",
+    # Unicode-3.0 - https://opensource.org/license/unicode
+    # Used by: icu_decimal, icu_locale_core, icu_provider
+    "Unicode-3.0",
+    # Unlicense - https://opensource.org/license/unlicense/
+    # Used by: ignore, walkdir
+    "Unlicense",
+    # Zlib - https://opensource.org/license/zlib
+    # Used by: transitive only
+    "Zlib",
+]
+# The confidence threshold for detecting a license from license text.
+# The higher the value, the more closely the license text must be to the
+# canonical license text of a valid SPDX license file.
+# [possible values: any between 0.0 and 1.0].
+confidence-threshold = 0.8
+# Allow 1 or more licenses on a per-crate basis, so that particular licenses
+# aren't accepted for every possible crate as with the normal allow list
+exceptions = [
+    # Each entry is the crate and version constraint, and its specific allow
+    # list
+    #{ allow = ["Zlib"], crate = "adler32" },
+]
+
+# Some crates don't have (easily) machine readable licensing information,
+# adding a clarification entry for it allows you to manually specify the
+# licensing information
+#[[licenses.clarify]]
+# The package spec the clarification applies to
+#crate = "ring"
+# The SPDX expression for the license requirements of the crate
+#expression = "MIT AND ISC AND OpenSSL"
+# One or more files in the crate's source used as the "source of truth" for
+# the license expression. If the contents match, the clarification will be used
+# when running the license check, otherwise the clarification will be ignored
+# and the crate will be checked normally, which may produce warnings or errors
+# depending on the rest of your configuration
+#license-files = [
+# Each entry is a crate relative path, and the (opaque) hash of its contents
+#{ path = "LICENSE", hash = 0xbd0eed23 }
+#]
+
+[licenses.private]
+# If true, ignores workspace crates that aren't published, or are only
+# published to private registries.
+# To see how to mark a crate as unpublished (to the official registry),
+# visit https://doc.rust-lang.org/cargo/reference/manifest.html#the-publish-field.
+ignore = false
+# One or more private registries that you might publish crates to, if a crate
+# is only published to private registries, and ignore is true, the crate will
+# not have its license(s) checked
+registries = [
+    #"https://sekretz.com/registry
+]
+
+# This section is considered when running `cargo deny check bans`.
+# More documentation about the 'bans' section can be found here:
+# https://embarkstudios.github.io/cargo-deny/checks/bans/cfg.html
+[bans]
+# Lint level for when multiple versions of the same crate are detected
+multiple-versions = "warn"
+# Lint level for when a crate version requirement is `*`
+wildcards = "allow"
+# The graph highlighting used when creating dotgraphs for crates
+# with multiple versions
+# * lowest-version - The path to the lowest versioned duplicate is highlighted
+# * simplest-path - The path to the version with the fewest edges is highlighted
+# * all - Both lowest-version and simplest-path are used
+highlight = "all"
+# The default lint level for `default` features for crates that are members of
+# the workspace that is being checked. This can be overridden by allowing/denying
+# `default` on a crate-by-crate basis if desired.
+workspace-default-features = "allow"
+# The default lint level for `default` features for external crates that are not
+# members of the workspace. This can be overridden by allowing/denying `default`
+# on a crate-by-crate basis if desired.
+external-default-features = "allow"
+# List of crates that are allowed. Use with care!
+allow = [
+    #"ansi_term@0.11.0",
+    #{ crate = "ansi_term@0.11.0", reason = "you can specify a reason it is allowed" },
+]
+# List of crates to deny
+deny = [
+    #"ansi_term@0.11.0",
+    #{ crate = "ansi_term@0.11.0", reason = "you can specify a reason it is banned" },
+    # Wrapper crates can optionally be specified to allow the crate when it
+    # is a direct dependency of the otherwise banned crate
+    #{ crate = "ansi_term@0.11.0", wrappers = ["this-crate-directly-depends-on-ansi_term"] },
+    # Removing async-trait materially improves debug build times:
+    # https://github.com/openai/codex/pull/27304
+    { crate = "async-trait", wrappers = [
+        "hickory-proto",
+        "opentelemetry-http",
+        "pagable",
+        "rmcp",
+        "tonic",
+        "webrtc",
+        "zbus",
+    ], reason = "first-party traits must use native async trait methods with explicit Send bounds" },
+    # Migration ratchet: `codex-http-client` is the intended reqwest owner. Remove each temporary
+    # wrapper when that crate's direct reqwest dependency is migrated to the shared abstraction.
+    { crate = "reqwest", wrappers = [
+        # Intended owner.
+        "codex-http-client",
+        # Intentional exception: gRPC uses reqwest directly as tonic's HTTP/2 transport.
+        "codex-code-mode",
+        # Intentional exception: this standalone, privileged Responses API proxy owns its blocking
+        # upstream HTTP transport independently of Codex.
+        "codex-responses-api-proxy",
+        # Temporary migration exceptions.
+        "codex-otel",
+        # Third-party crates that own their reqwest integration. These are not part of the
+        # first-party migration count above.
+        "oauth2",
+        "opentelemetry-http",
+        "opentelemetry-otlp",
+        "rmcp",
+        "sentry",
+        "webrtc-sys-build",
+    ], reason = "new direct reqwest dependencies must use codex-http-client; temporary wrappers track migration debt" },
+]
+
+# List of features to allow/deny
+# Each entry the name of a crate and a version range. If version is
+# not specified, all versions will be matched.
+#[[bans.features]]
+#crate = "reqwest"
+# Features to not allow
+#deny = ["json"]
+# Features to allow
+#allow = [
+#    "rustls",
+#    "__rustls",
+#    "__tls",
+#    "hyper-rustls",
+#    "rustls",
+#    "rustls-pemfile",
+#    "rustls-tls-webpki-roots",
+#    "tokio-rustls",
+#    "webpki-roots",
+#]
+# If true, the allowed features must exactly match the enabled feature set. If
+# this is set there is no point setting `deny`
+#exact = true
+
+# Certain crates/versions that will be skipped when doing duplicate detection.
+skip = [
+    #"ansi_term@0.11.0",
+    #{ crate = "ansi_term@0.11.0", reason = "you can specify a reason why it can't be updated/removed" },
+]
+# Similarly to `skip` allows you to skip certain crates during duplicate
+# detection. Unlike skip, it also includes the entire tree of transitive
+# dependencies starting at the specified crate, up to a certain depth, which is
+# by default infinite.
+skip-tree = [
+    #"ansi_term@0.11.0", # will be skipped along with _all_ of its direct and transitive dependencies
+    #{ crate = "ansi_term@0.11.0", depth = 20 },
+]
+
+# This section is considered when running `cargo deny check sources`.
+# More documentation about the 'sources' section can be found here:
+# https://embarkstudios.github.io/cargo-deny/checks/sources/cfg.html
+[sources]
+# Lint level for what to happen when a crate from a crate registry that is not
+# in the allow list is encountered
+unknown-registry = "deny"
+# Lint level for what to happen when a crate from a git repository that is not
+# in the allow list is encountered
+unknown-git = "deny"
+# Git sources must be pinned to immutable revisions.
+required-git-spec = "rev"
+# List of URLs for allowed crate registries. Defaults to the crates.io index
+# if not specified. If it is specified but empty, no registries are allowed.
+allow-registry = ["https://github.com/rust-lang/crates.io-index"]
+# List of URLs for allowed Git repositories
+allow-git = [
+    "https://github.com/dzbarsky/rules_rust",
+    "https://github.com/helix-editor/nucleo.git",
+    # CONNECT request handling needs this pinned H3 revision until released.
+    "https://github.com/hyperium/h3",
+    "https://github.com/juberti-oai/rust-sdks.git",
+    "https://github.com/microsoft/mxc",
+    "https://github.com/openai-oss-forks/crossterm",
+    "https://github.com/openai-oss-forks/tokio-tungstenite",
+    "https://github.com/openai-oss-forks/tungstenite-rs",
+]
+
+[sources.allow-org]
+# github.com organizations to allow git sources for
+github = [
+]
+# gitlab.com organizations to allow git sources for
+gitlab = []
+# bitbucket.org organizations to allow git sources for
+bitbucket = []

codex-rs/rust-toolchain.toml

@@ -0,0 +1,3 @@
+[toolchain]
+channel = "1.95.0"
+components = ["clippy", "rustfmt", "rust-src"]

codex-rs/rustfmt.toml

@@ -0,0 +1,4 @@
+edition = "2024"
+# The warnings caused by this setting can be ignored.
+# See https://github.com/openai/openai/pull/298039 for details.
+imports_granularity = "Item"

defs.bzl

@@ -0,0 +1,707 @@
+load("@crates//:data.bzl", "DEP_DATA")
+load("@crates//:defs.bzl", "all_crate_deps")
+load("@rules_rust//cargo/private:cargo_build_script_wrapper.bzl", "cargo_build_script")
+load("@rules_rust//rust:defs.bzl", "rust_binary", "rust_library", "rust_proc_macro", "rust_test")
+load("//bazel/rules/testing:foreign_platform_binary.bzl", "foreign_platform_binary")
+load("//bazel/rules/testing/wine:wine_runtime.bzl", "WINE_TEST_TARGET_COMPATIBLE_WITH", "wine_test_runtime")
+
+# Match Cargo's Windows linker behavior so Bazel-built binaries and tests use
+# the same stack reserve on both Windows ABIs and resolve UCRT imports on MSVC.
+WINDOWS_GNULLVM_RUSTC_LINK_FLAGS = [
+    "-C",
+    "link-arg=-Wl,--stack,8388608",  # 8 MiB
+]
+
+WINDOWS_RUSTC_LINK_FLAGS = select({
+    "@llvm//constraints/windows/abi:gnullvm": WINDOWS_GNULLVM_RUSTC_LINK_FLAGS,
+    "@llvm//constraints/windows/abi:msvc": [
+        "-C",
+        "link-arg=/STACK:8388608",  # 8 MiB
+        "-C",
+        "link-arg=/NODEFAULTLIB:libucrt.lib",
+        "-C",
+        "link-arg=ucrt.lib",
+    ],
+    "//conditions:default": [],
+})
+
+WINDOWS_GNULLVM_INCOMPATIBLE = select({
+    "@llvm//constraints/windows/abi:gnullvm": ["@platforms//:incompatible"],
+    "//conditions:default": [],
+})
+
+WINDOWS_GNULLVM_ONLY = select({
+    "@llvm//constraints/windows/abi:gnullvm": [],
+    "//conditions:default": ["@platforms//:incompatible"],
+})
+
+# libwebrtc uses Objective-C categories from native archives. Any Bazel-linked
+# macOS binary/test that can pull it in must keep category symbols alive.
+MACOS_WEBRTC_RUSTC_LINK_FLAGS = select({
+    "@platforms//os:macos": [
+        "-C",
+        "link-arg=-ObjC",
+        "-C",
+        "link-arg=-lc++",
+    ],
+    "//conditions:default": [],
+})
+
+def _workspace_root_test_impl(ctx):
+    is_windows = ctx.target_platform_has_constraint(ctx.attr._windows_constraint[platform_common.ConstraintValueInfo])
+    launcher = ctx.actions.declare_file(ctx.label.name + ".bat" if is_windows else ctx.label.name)
+    test_bin = ctx.executable.test_bin
+    workspace_root_marker = ctx.file.workspace_root_marker
+    launcher_template = ctx.file._windows_launcher_template if is_windows else ctx.file._bash_launcher_template
+    runfile_env_exports = _windows_runfile_env_exports(ctx) if is_windows else _bash_runfile_env_exports(ctx)
+    workspace_root_setup = _windows_workspace_root_setup(ctx) if is_windows else _bash_workspace_root_setup(ctx)
+    ctx.actions.expand_template(
+        template = launcher_template,
+        output = launcher,
+        is_executable = True,
+        substitutions = {
+            "__RUNFILE_ENV_EXPORTS__": runfile_env_exports,
+            "__TEST_BIN__": test_bin.short_path,
+            "__WORKSPACE_ROOT_SETUP__": workspace_root_setup,
+            "__WORKSPACE_ROOT_MARKER__": workspace_root_marker.short_path,
+        },
+    )
+
+    runfiles = ctx.runfiles(files = [test_bin, workspace_root_marker]).merge(ctx.attr.test_bin[DefaultInfo].default_runfiles)
+    for data_dep in ctx.attr.data:
+        runfiles = runfiles.merge(ctx.runfiles(files = data_dep[DefaultInfo].files.to_list()))
+        runfiles = runfiles.merge(data_dep[DefaultInfo].default_runfiles)
+    for runfile_dep in ctx.attr.runfile_env:
+        runfile = _runfile_env_file(runfile_dep)
+        runfiles = runfiles.merge(ctx.runfiles(files = [runfile]))
+        runfiles = runfiles.merge(runfile_dep[DefaultInfo].default_runfiles)
+
+    location_targets = {}
+    for target in (
+        ctx.attr.data +
+        [ctx.attr.test_bin, ctx.attr.workspace_root_marker] +
+        ctx.attr.runfile_env.keys()
+    ):
+        location_targets[target.label] = target
+    env = {
+        key: ctx.expand_location(value, targets = location_targets.values())
+        for key, value in ctx.attr.env.items()
+    }
+    if ctx.attr.test_threads:
+        env["RUST_TEST_THREADS"] = str(ctx.attr.test_threads)
+
+    return [
+        DefaultInfo(
+            executable = launcher,
+            files = depset([launcher]),
+            runfiles = runfiles,
+        ),
+        RunEnvironmentInfo(
+            environment = env,
+        ),
+    ]
+
+def _bash_runfile_env_exports(ctx):
+    lines = []
+    for runfile_dep, env_var in ctx.attr.runfile_env.items():
+        runfile = _runfile_env_file(runfile_dep)
+        lines.append('RUNFILE_ENV_ARGS+=("{}=$(resolve_runfile "{}")")'.format(env_var, _runfile_logical_path(runfile)))
+    return "\n".join(lines)
+
+def _windows_runfile_env_exports(ctx):
+    lines = []
+    for runfile_dep, env_var in ctx.attr.runfile_env.items():
+        runfile = _runfile_env_file(runfile_dep)
+        lines.append('call :resolve_runfile "{}"'.format(_runfile_logical_path(runfile)))
+        lines.append("if errorlevel 1 exit /b 1")
+        lines.append('set "{}=!resolve_runfile_result!"'.format(env_var))
+    return "\n".join(lines)
+
+def _runfile_env_file(target):
+    executable = target[DefaultInfo].files_to_run.executable
+    if executable != None:
+        return executable
+
+    files = target[DefaultInfo].files.to_list()
+    if len(files) != 1:
+        fail("{} must provide an executable or exactly one file for runfile_env".format(target.label))
+    return files[0]
+
+def _runfile_logical_path(file):
+    return file.short_path.removeprefix("../")
+
+def _bash_workspace_root_setup(ctx):
+    if not ctx.attr.chdir_workspace_root:
+        return ""
+    return 'export INSTA_WORKSPACE_ROOT="${workspace_root}"\ncd "${workspace_root}"'
+
+def _windows_workspace_root_setup(ctx):
+    if not ctx.attr.chdir_workspace_root:
+        return ""
+    return """set "INSTA_WORKSPACE_ROOT=%workspace_root%"
+cd /d "%workspace_root%" || exit /b 1"""
+
+workspace_root_test = rule(
+    implementation = _workspace_root_test_impl,
+    test = True,
+    toolchains = ["@bazel_tools//tools/test:default_test_toolchain_type"],
+    attrs = {
+        "chdir_workspace_root": attr.bool(
+            default = True,
+        ),
+        "data": attr.label_list(
+            allow_files = True,
+        ),
+        "env": attr.string_dict(),
+        "runfile_env": attr.label_keyed_string_dict(
+            cfg = "target",
+        ),
+        "test_bin": attr.label(
+            cfg = "target",
+            executable = True,
+            mandatory = True,
+        ),
+        "test_threads": attr.int(),
+        "workspace_root_marker": attr.label(
+            allow_single_file = True,
+            mandatory = True,
+        ),
+        "_windows_constraint": attr.label(
+            default = "@platforms//os:windows",
+            providers = [platform_common.ConstraintValueInfo],
+        ),
+        "_bash_launcher_template": attr.label(
+            allow_single_file = True,
+            default = "//:workspace_root_test_launcher.sh.tpl",
+        ),
+        "_windows_launcher_template": attr.label(
+            allow_single_file = True,
+            default = "//:workspace_root_test_launcher.bat.tpl",
+        ),
+    },
+)
+
+def codex_rust_crate(
+        name,
+        crate_name,
+        crate_features = [],
+        crate_srcs = None,
+        crate_edition = None,
+        proc_macro = False,
+        build_script_enabled = True,
+        build_script_data = [],
+        compile_data = [],
+        binary_compile_data_extra = {},
+        lib_data_extra = [],
+        rustc_flags_extra = [],
+        binary_rustc_flags_extra = {},
+        binaries_with_build_commit = [],
+        rustc_env = {},
+        rustc_env_files = [],
+        deps_extra = [],
+        integration_compile_data_extra = [],
+        integration_test_args = [],
+        unit_test_args = [],
+        binary_test_target_compatible_with = [],
+        integration_test_timeout = None,
+        test_data_extra = [],
+        test_shard_counts = {},
+        test_tags = [],
+        test_threads = 0,
+        unit_test_timeout = None,
+        extra_binaries = [],
+        extra_binaries_non_windows = [],
+        run_tests_with_wine_exec = False):
+    """Defines a Rust crate with library, binaries, and tests wired for Bazel + Cargo parity.
+
+    The macro mirrors Cargo conventions: it builds a library when `src/` exists,
+    wires build scripts, exports `CARGO_BIN_EXE_*` for integration tests, and
+    creates unit + integration test targets. Dependency buckets map to the
+    Cargo.lock resolution in `@crates`.
+
+    Args:
+        name: Bazel target name for the library, should be the directory name.
+            Example: `app-server`.
+        crate_name: Cargo crate name from Cargo.toml
+            Example: `codex_app_server`.
+        crate_features: Cargo features to enable for this crate.
+            Crates are only compiled in a single configuration across the workspace, i.e.
+            with all features in this list enabled. So use sparingly, and prefer to refactor
+            optional functionality to a separate crate.
+        crate_srcs: Optional explicit library srcs; [] disables the library target.
+            Defaults to `src/**/*.rs` excluding binary entrypoints.
+        crate_edition: Rust edition override, if not default.
+            You probably don't want this, it's only here for a single caller.
+        proc_macro: Whether this crate builds a proc-macro library.
+        build_script_data: Data files exposed to the build script at runtime.
+        compile_data: Non-Rust compile-time data for the library target.
+        binary_compile_data_extra: Mapping from binary names to extra non-Rust
+            compile-time data for those binary targets.
+        lib_data_extra: Extra runtime data for the library target.
+        binary_rustc_flags_extra: Mapping from binary names to extra rustc
+            flags for those binary targets.
+        binaries_with_build_commit: Binary names that embed STABLE_GIT_COMMIT from the
+            generated build-commit environment file. Other workspace status is
+            excluded from their compilation inputs.
+        rustc_env: Extra rustc_env entries to merge with defaults.
+        rustc_env_files: Generated compiler environment files for the library target.
+        deps_extra: Extra normal deps beyond @crates resolution.
+            Typically only needed when features add additional deps.
+        integration_compile_data_extra: Extra compile_data for integration tests.
+        integration_test_args: Optional args for integration test binaries.
+        unit_test_args: Optional args for the unit test binary.
+        binary_test_target_compatible_with: Platform constraints for binary unit tests.
+        integration_test_timeout: Optional Bazel timeout for integration test
+            targets generated from `tests/*.rs`.
+        test_data_extra: Extra runtime data for tests.
+        test_shard_counts: Mapping from generated test target name to Bazel
+            shard count. Matching tests use native Bazel sharding on the outer
+            workspace-root launcher, not rules_rust's inner sharding wrapper.
+            The launcher resolves the real Rust test binary through runfiles
+            and then assigns each libtest case to a stable bucket by hashing
+            the test name. Matching tests are also marked flaky, which gives
+            them Bazel's default three attempts.
+        test_tags: Tags applied to unit + integration test targets.
+            Typically used to disable the sandbox, but see https://bazel.build/reference/be/common-definitions#common.tags
+        test_threads: Optional Rust test thread limit for sharded integration tests.
+        unit_test_timeout: Optional Bazel timeout for the unit-test target
+            generated from `src/**/*.rs`.
+        extra_binaries: Additional binary labels to surface as test data and
+            `CARGO_BIN_EXE_*` environment variables. These are only needed for binaries from a different crate.
+        extra_binaries_non_windows: Like `extra_binaries`, but omitted from
+            Windows test data and environment variables. Tests using these
+            binaries must be excluded when targeting Windows.
+        run_tests_with_wine_exec: Boolean, defaults to False. Whether to emit a
+            Wine-exec variant for each integration test. Variants inherit the
+            native test's timeout, tags, and shard count.
+    """
+    test_env = {
+        # The launcher resolves an absolute workspace root at runtime so
+        # manifest-only platforms like macOS still point Insta at the real
+        # `codex-rs` checkout.
+        "INSTA_WORKSPACE_ROOT": ".",
+        "INSTA_SNAPSHOT_PATH": "src",
+    }
+
+    native.filegroup(
+        name = "package-files",
+        srcs = native.glob(
+            ["**"],
+            exclude = [
+                "**/BUILD.bazel",
+                "BUILD.bazel",
+                "target/**",
+            ],
+            allow_empty = True,
+        ),
+        visibility = ["//visibility:public"],
+    )
+
+    rustc_env = {
+        "BAZEL_PACKAGE": native.package_name(),
+    } | rustc_env
+
+    manifest_relpath = native.package_name()
+    if manifest_relpath.startswith("codex-rs/"):
+        manifest_relpath = manifest_relpath[len("codex-rs/"):]
+    manifest_path = manifest_relpath + "/Cargo.toml"
+
+    binaries = DEP_DATA.get(native.package_name())["binaries"]
+
+    lib_srcs = crate_srcs if crate_srcs != None else native.glob(["src/**/*.rs"], exclude = binaries.values(), allow_empty = True)
+
+    maybe_deps = []
+
+    if build_script_enabled and native.glob(["build.rs"], allow_empty = True):
+        cargo_build_script(
+            name = name + "-build-script",
+            srcs = ["build.rs"],
+            deps = all_crate_deps(build = True),
+            data = build_script_data,
+            # Some build script deps sniff version-related env vars...
+            version = "0.0.0",
+        )
+
+        maybe_deps += [name + "-build-script"]
+
+    if lib_srcs:
+        lib_rule = rust_proc_macro if proc_macro else rust_library
+        lib_rule(
+            name = name,
+            crate_name = crate_name,
+            crate_features = crate_features,
+            deps = all_crate_deps() + maybe_deps + deps_extra,
+            compile_data = compile_data,
+            data = lib_data_extra,
+            srcs = lib_srcs,
+            edition = crate_edition,
+            rustc_flags = rustc_flags_extra,
+            rustc_env = rustc_env,
+            rustc_env_files = rustc_env_files,
+            visibility = ["//visibility:public"],
+        )
+
+        unit_test_name = name + "-unit-tests"
+        unit_test_binary = name + "-unit-tests-bin"
+        unit_test_shard_count = _test_shard_count(test_shard_counts, unit_test_name)
+
+        # Shard at the workspace_root_test layer. rules_rust's sharding wrapper
+        # expects to run from its own runfiles cwd, while workspace_root_test
+        # deliberately changes cwd so Insta sees Cargo-like snapshot paths.
+        rust_test(
+            name = unit_test_binary,
+            crate = name,
+            crate_features = crate_features,
+            deps = all_crate_deps(normal = True, normal_dev = True) + maybe_deps + deps_extra,
+            # Unit tests also compile to standalone Windows executables, so
+            # keep their stack reserve aligned with binaries and integration
+            # tests under gnullvm.
+            # Bazel has emitted both `codex-rs/<crate>/...` and
+            # `../codex-rs/<crate>/...` paths for `file!()`. Strip either
+            # prefix so the workspace-root launcher sees Cargo-like metadata
+            # such as `tui/src/...`.
+            rustc_flags = rustc_flags_extra + WINDOWS_RUSTC_LINK_FLAGS + [
+                "--remap-path-prefix=../codex-rs=",
+                "--remap-path-prefix=codex-rs=",
+            ],
+            rustc_env = rustc_env,
+            data = test_data_extra,
+            tags = test_tags + ["manual"],
+        )
+
+        unit_test_kwargs = {}
+        if unit_test_args:
+            unit_test_kwargs["args"] = unit_test_args
+        if unit_test_timeout:
+            unit_test_kwargs["timeout"] = unit_test_timeout
+        if unit_test_shard_count:
+            unit_test_kwargs["shard_count"] = unit_test_shard_count
+            unit_test_kwargs["flaky"] = True
+
+        workspace_root_test(
+            name = unit_test_name,
+            env = test_env,
+            test_bin = ":" + unit_test_binary,
+            workspace_root_marker = "//codex-rs/utils/cargo-bin:repo_root.marker",
+            tags = test_tags,
+            **unit_test_kwargs
+        )
+
+        maybe_deps += [name]
+
+    sanitized_binaries = []
+    cargo_env = {}
+    cargo_env_runfiles = {}
+    for binary, main in binaries.items():
+        #binary = binary.replace("-", "_")
+        sanitized_binaries.append(binary)
+        cargo_env_runfiles[":" + binary] = "CARGO_BIN_EXE_" + binary
+        cargo_env["CARGO_BIN_EXE_" + binary] = "$(rlocationpath :%s)" % binary
+        rust_binary(
+            name = binary,
+            crate_name = binary.replace("-", "_"),
+            crate_root = main,
+            deps = all_crate_deps() + maybe_deps + deps_extra,
+            edition = crate_edition,
+            # Keep per-binary Cargo link behavior scoped to the matching
+            # generated rust_binary instead of leaking it to sibling binaries.
+            compile_data = binary_compile_data_extra.get(binary, []),
+            rustc_flags = rustc_flags_extra + binary_rustc_flags_extra.get(binary, []) + WINDOWS_RUSTC_LINK_FLAGS,
+            # Keep stamp = 0: rules_rust otherwise makes stable-status.txt and
+            # volatile-status.txt compiler inputs, even though we only consume
+            # STABLE_GIT_COMMIT. BUILD_USER and BUILD_HOST vary across developers
+            # and CI workers, while BUILD_TIMESTAMP varies across builds; these
+            # unrelated values prevent remote cache reuse for the same commit.
+            # Isolate status inputs in build-commit-env's cheap action so its
+            # output, and hence this compiler input, changes only with the commit.
+            rustc_env_files = ["//bazel/build-info:build-commit-env"] if binary in binaries_with_build_commit else [],
+            srcs = native.glob(["src/**/*.rs"]),
+            stamp = 0,
+            visibility = ["//visibility:public"],
+        )
+
+        binary_unit_test_name = binary + "-bin-unit-tests"
+        binary_unit_test_binary = binary_unit_test_name + "-bin"
+        binary_unit_test_shard_count = _test_shard_count(test_shard_counts, binary_unit_test_name)
+
+        # Keep the Rust test manual so the repo-root wrapper owns filtering and
+        # sharding while Clippy can still discover the underlying test crate.
+        rust_test(
+            name = binary_unit_test_binary,
+            crate = ":" + binary,
+            crate_features = crate_features,
+            deps = all_crate_deps(normal_dev = True),
+            rustc_flags = rustc_flags_extra + WINDOWS_RUSTC_LINK_FLAGS + [
+                "--remap-path-prefix=../codex-rs=",
+                "--remap-path-prefix=codex-rs=",
+            ],
+            rustc_env = rustc_env,
+            data = test_data_extra,
+            tags = test_tags + ["manual"],
+        )
+
+        binary_unit_test_kwargs = {}
+        if unit_test_args:
+            binary_unit_test_kwargs["args"] = unit_test_args
+        if unit_test_timeout:
+            binary_unit_test_kwargs["timeout"] = unit_test_timeout
+        if binary_unit_test_shard_count:
+            binary_unit_test_kwargs["shard_count"] = binary_unit_test_shard_count
+            binary_unit_test_kwargs["flaky"] = True
+
+        workspace_root_test(
+            name = binary_unit_test_name,
+            env = test_env,
+            test_bin = ":" + binary_unit_test_binary,
+            workspace_root_marker = "//codex-rs/utils/cargo-bin:repo_root.marker",
+            target_compatible_with = binary_test_target_compatible_with,
+            tags = test_tags,
+            **binary_unit_test_kwargs
+        )
+
+    for binary_label in extra_binaries:
+        sanitized_binaries.append(binary_label)
+        binary = Label(binary_label).name
+        cargo_env_runfiles[binary_label] = "CARGO_BIN_EXE_" + binary
+        cargo_env["CARGO_BIN_EXE_" + binary] = "$(rlocationpath %s)" % binary_label
+
+    integration_test_binaries = sanitized_binaries
+    integration_test_cargo_env = cargo_env
+    integration_test_cargo_env_runfiles = cargo_env_runfiles
+    integration_test_files = native.glob(["tests/**"], allow_empty = True)
+    integration_test_data_extra = [
+        data
+        for data in test_data_extra
+        if data not in cargo_env_runfiles and data not in integration_test_files
+    ]
+    non_windows_sanitized_binaries = []
+    non_windows_cargo_env = {}
+    non_windows_cargo_env_runfiles = {}
+    if extra_binaries_non_windows:
+        for binary_label in extra_binaries_non_windows:
+            non_windows_sanitized_binaries.append(binary_label)
+            binary = Label(binary_label).name
+            non_windows_cargo_env_runfiles[binary_label] = "CARGO_BIN_EXE_" + binary
+            non_windows_cargo_env["CARGO_BIN_EXE_" + binary] = "$(rlocationpath %s)" % binary_label
+
+        integration_test_binaries = sanitized_binaries + select({
+            "@platforms//os:windows": [],
+            "//conditions:default": non_windows_sanitized_binaries,
+        })
+        integration_test_cargo_env = select({
+            "@platforms//os:windows": cargo_env,
+            "//conditions:default": cargo_env | non_windows_cargo_env,
+        })
+        integration_test_cargo_env_runfiles = select({
+            "@platforms//os:windows": cargo_env_runfiles,
+            "//conditions:default": cargo_env_runfiles | non_windows_cargo_env_runfiles,
+        })
+
+    wine_host_binaries = {
+        env_var.removeprefix("CARGO_BIN_EXE_"): binary_label
+        for binary_label, env_var in (cargo_env_runfiles | non_windows_cargo_env_runfiles).items()
+    }
+
+    integration_test_kwargs = {}
+    if integration_test_args:
+        integration_test_kwargs["args"] = integration_test_args
+    if integration_test_timeout:
+        integration_test_kwargs["timeout"] = integration_test_timeout
+
+    for test in native.glob(["tests/*.rs"], allow_empty = True):
+        test_file_stem = test.removeprefix("tests/").removesuffix(".rs")
+        test_crate_name = test_file_stem.replace("-", "_")
+        test_name = name + "-" + test_file_stem.replace("/", "-")
+        if not test_name.endswith("-test"):
+            test_name += "-test"
+        windows_cross_test_binary = test_name + "-windows-cross-bin"
+
+        test_kwargs = {}
+        test_kwargs.update(integration_test_kwargs)
+        test_shard_count = _test_shard_count(test_shard_counts, test_name)
+        if test_shard_count:
+            # Put Bazel sharding on the label users/CI invoke. Do not set
+            # rules_rust's experimental_enable_sharding on the Rust test
+            # binary: that creates an intermediate wrapper that expects a
+            # symlink runfiles tree, while this repo intentionally runs with
+            # --noenable_runfiles and usually has only a runfiles manifest.
+            test_kwargs["shard_count"] = test_shard_count
+            test_kwargs["flaky"] = True
+
+        integration_test_binary = test_name + "-bin"
+
+        # There are four generated integration-test shapes:
+        #
+        # 1. Unsharded native tests keep the plain rust_test label for minimal
+        #    churn and the usual rules_rust Cargo-like environment.
+        # 2. Sharded native tests split into a manual rust_test binary plus an
+        #    outer workspace_root_test. The outer test action receives Bazel's
+        #    sharding environment, resolves the real binary through the
+        #    runfiles manifest, and implements stable libtest sharding itself.
+        # 3. Windows cross tests always use the workspace_root_test wrapper so
+        #    runfile env vars become Windows-native absolute paths before the
+        #    Rust process starts.
+        # 4. Wine-exec tests reuse the native Rust test binary behind a shared
+        #    Linux runner. The runner starts the cross-built Windows exec server
+        #    under pinned Wine, injects its URL into the test environment, and
+        #    owns cleanup. The outer workspace_root_test resolves the runner,
+        #    test, and server from runfiles, sets a Cargo-like cwd, and applies
+        #    the native test's shard count.
+        if test_shard_count:
+            # This target is intentionally a binary-like helper, not the public
+            # test target. The wrapper below owns cwd setup, runfile env
+            # materialization, sharding, and flaky retry behavior.
+            rust_test(
+                name = integration_test_binary,
+                crate_name = test_crate_name,
+                crate_root = test,
+                srcs = [test],
+                data = integration_test_files + integration_test_binaries + integration_test_data_extra,
+                compile_data = integration_test_files + integration_compile_data_extra,
+                deps = all_crate_deps(normal = True, normal_dev = True) + maybe_deps + deps_extra,
+                # Bazel has emitted both `codex-rs/<crate>/...` and
+                # `../codex-rs/<crate>/...` paths for `file!()`. Strip either
+                # prefix so Insta records Cargo-like metadata such as `core/tests/...`.
+                rustc_flags = rustc_flags_extra + WINDOWS_RUSTC_LINK_FLAGS + [
+                    "--remap-path-prefix=../codex-rs=",
+                    "--remap-path-prefix=codex-rs=",
+                ],
+                rustc_env = rustc_env,
+                target_compatible_with = WINDOWS_GNULLVM_INCOMPATIBLE,
+                tags = test_tags + ["manual"],
+            )
+
+            workspace_root_test(
+                name = test_name,
+                env = test_env,
+                # CARGO_BIN_EXE_* values are rlocation paths at analysis time.
+                # The launcher rewrites them to absolute paths at execution
+                # time so tests keep working after chdir_workspace_root and on
+                # manifest-only platforms.
+                runfile_env = integration_test_cargo_env_runfiles,
+                test_bin = ":" + integration_test_binary,
+                test_threads = test_threads,
+                workspace_root_marker = "//codex-rs/utils/cargo-bin:repo_root.marker",
+                target_compatible_with = WINDOWS_GNULLVM_INCOMPATIBLE,
+                tags = test_tags,
+                **test_kwargs
+            )
+        else:
+            # For unsharded tests, the direct rust_test rule is still fine:
+            # there is no rules_rust sharding wrapper to bypass, and env can
+            # use rlocation paths directly because the test starts under
+            # Bazel's normal test environment.
+            rust_test(
+                name = test_name,
+                crate_name = test_crate_name,
+                crate_root = test,
+                srcs = [test],
+                data = integration_test_files + integration_test_binaries + integration_test_data_extra,
+                compile_data = integration_test_files + integration_compile_data_extra,
+                deps = all_crate_deps(normal = True, normal_dev = True) + maybe_deps + deps_extra,
+                # Bazel has emitted both `codex-rs/<crate>/...` and
+                # `../codex-rs/<crate>/...` paths for `file!()`. Strip either
+                # prefix so Insta records Cargo-like metadata such as `core/tests/...`.
+                rustc_flags = rustc_flags_extra + WINDOWS_RUSTC_LINK_FLAGS + [
+                    "--remap-path-prefix=../codex-rs=",
+                    "--remap-path-prefix=codex-rs=",
+                ],
+                rustc_env = rustc_env,
+                env = integration_test_cargo_env,
+                target_compatible_with = WINDOWS_GNULLVM_INCOMPATIBLE,
+                tags = test_tags,
+                **test_kwargs
+            )
+
+        if run_tests_with_wine_exec:
+            wine_test_name = test_name.removesuffix("-test") + "-wine-exec-test"
+            native_test_binary = ":" + (integration_test_binary if test_shard_count else test_name)
+            wine_test_binaries = dict(wine_host_binaries)
+
+            wine_exec_server = wine_test_name + "-windows-exec-server"
+            foreign_platform_binary(
+                name = wine_exec_server,
+                binary = "//codex-rs/exec-server/testing:exec-server",
+                extra_rustc_flags = WINDOWS_GNULLVM_RUSTC_LINK_FLAGS,
+                platform = "//:windows_x86_64_gnullvm",
+                tags = ["manual"],
+                target_compatible_with = [
+                    "@platforms//cpu:x86_64",
+                    "@platforms//os:linux",
+                ],
+                testonly = True,
+                visibility = ["//visibility:private"],
+            )
+            wine_test_binaries["wine-windows-exec-server"] = ":" + wine_exec_server
+            wine_runtime = wine_test_runtime(wine_test_binaries)
+            wine_runfile_env = dict(wine_runtime.runfile_env)
+            wine_runfile_env[native_test_binary] = "CODEX_WINE_EXEC_TEST_BINARY"
+
+            wine_test_kwargs = {}
+            wine_test_kwargs.update(integration_test_kwargs)
+            if test_shard_count:
+                wine_test_kwargs["shard_count"] = test_shard_count
+                wine_test_kwargs["flaky"] = True
+
+            # The Wine runner is a binary rather than a rust_test, but it still
+            # needs a Cargo-like cwd, Bazel sharding, and absolute runfile paths.
+            # `workspace_root_test` establishes all three before Wine starts.
+            workspace_root_test(
+                name = wine_test_name,
+                data = wine_runtime.data,
+                env = test_env,
+                runfile_env = wine_runfile_env,
+                test_bin = "//codex-rs/exec-server/testing:wine-exec-test-runner",
+                workspace_root_marker = "//codex-rs/utils/cargo-bin:repo_root.marker",
+                target_compatible_with = WINE_TEST_TARGET_COMPATIBLE_WITH,
+                # This wrapper has no Rust sources and transitions a data
+                # dependency to a Windows toolchain the lint does not register.
+                tags = test_tags + ["no-argument-comment-lint"],
+                **wine_test_kwargs
+            )
+
+        windows_cross_test_kwargs = {}
+        windows_cross_test_kwargs.update(integration_test_kwargs)
+        if test_shard_count:
+            windows_cross_test_kwargs["shard_count"] = test_shard_count
+            windows_cross_test_kwargs["flaky"] = True
+
+        rust_test(
+            name = windows_cross_test_binary,
+            crate_name = test_crate_name,
+            crate_root = test,
+            srcs = [test],
+            data = integration_test_files + integration_test_binaries + integration_test_data_extra,
+            compile_data = integration_test_files + integration_compile_data_extra,
+            deps = all_crate_deps(normal = True, normal_dev = True) + maybe_deps + deps_extra,
+            rustc_flags = rustc_flags_extra + WINDOWS_RUSTC_LINK_FLAGS + [
+                "--remap-path-prefix=../codex-rs=",
+                "--remap-path-prefix=codex-rs=",
+            ],
+            rustc_env = rustc_env,
+            env = integration_test_cargo_env,
+            target_compatible_with = WINDOWS_GNULLVM_ONLY,
+            tags = test_tags + ["manual"],
+        )
+
+        workspace_root_test(
+            name = test_name + "-windows-cross",
+            chdir_workspace_root = False,
+            env = integration_test_cargo_env,
+            runfile_env = integration_test_cargo_env_runfiles,
+            test_bin = ":" + windows_cross_test_binary,
+            workspace_root_marker = "//codex-rs/utils/cargo-bin:repo_root.marker",
+            target_compatible_with = WINDOWS_GNULLVM_ONLY,
+            tags = test_tags,
+            **windows_cross_test_kwargs
+        )
+
+def _test_shard_count(test_shard_counts, test_name):
+    shard_count = test_shard_counts.get(test_name)
+    if shard_count == None:
+        return None
+
+    if shard_count < 1:
+        fail("test_shard_counts[{}] must be a positive integer".format(test_name))
+
+    return shard_count

flake.lock

@@ -0,0 +1,48 @@
+{
+  "nodes": {
+    "nixpkgs": {
+      "locked": {
+        "lastModified": 1769461804,
+        "narHash": "sha256-msG8SU5WsBUfVVa/9RPLaymvi5bI8edTavbIq3vRlhI=",
+        "owner": "NixOS",
+        "repo": "nixpkgs",
+        "rev": "bfc1b8a4574108ceef22f02bafcf6611380c100d",
+        "type": "github"
+      },
+      "original": {
+        "owner": "NixOS",
+        "ref": "nixos-unstable",
+        "repo": "nixpkgs",
+        "type": "github"
+      }
+    },
+    "root": {
+      "inputs": {
+        "nixpkgs": "nixpkgs",
+        "rust-overlay": "rust-overlay"
+      }
+    },
+    "rust-overlay": {
+      "inputs": {
+        "nixpkgs": [
+          "nixpkgs"
+        ]
+      },
+      "locked": {
+        "lastModified": 1769828398,
+        "narHash": "sha256-zmnvRUm15QrlKH0V1BZoiT3U+Q+tr+P5Osi8qgtL9fY=",
+        "owner": "oxalica",
+        "repo": "rust-overlay",
+        "rev": "a1d32c90c8a4ea43e9586b7e5894c179d5747425",
+        "type": "github"
+      },
+      "original": {
+        "owner": "oxalica",
+        "repo": "rust-overlay",
+        "type": "github"
+      }
+    }
+  },
+  "root": "root",
+  "version": 7
+}

flake.nix

@@ -0,0 +1,87 @@
+{
+  description = "Development Nix flake for OpenAI Codex CLI";
+
+  inputs = {
+    nixpkgs.url = "github:NixOS/nixpkgs/nixos-unstable";
+    rust-overlay = {
+      url = "github:oxalica/rust-overlay";
+      inputs.nixpkgs.follows = "nixpkgs";
+    };
+  };
+
+  outputs = { self, nixpkgs, rust-overlay, ... }:
+    let
+      systems = [
+        "x86_64-linux"
+        "aarch64-linux"
+        "x86_64-darwin"
+        "aarch64-darwin"
+      ];
+      forAllSystems = f: nixpkgs.lib.genAttrs systems f;
+
+      # Read the version from the workspace Cargo.toml (the single source of
+      # truth used by the release workflow).
+      cargoToml = builtins.fromTOML (builtins.readFile ./codex-rs/Cargo.toml);
+      cargoVersion = cargoToml.workspace.package.version;
+
+      # When building from a release commit the Cargo.toml already carries the
+      # real version (e.g. "0.101.0").  On the main branch it is the placeholder
+      # "0.0.0", so we fall back to a dev version derived from the flake source.
+      version =
+        if cargoVersion != "0.0.0"
+        then cargoVersion
+        else "0.0.0-dev+${self.shortRev or "dirty"}";
+    in
+    {
+      packages = forAllSystems (system:
+        let
+          pkgs = import nixpkgs {
+            inherit system;
+            overlays = [ rust-overlay.overlays.default ];
+          };
+          codex-rs = pkgs.callPackage ./codex-rs {
+            inherit version;
+            rustPlatform = pkgs.makeRustPlatform {
+              cargo = pkgs.rust-bin.stable.latest.minimal;
+              rustc = pkgs.rust-bin.stable.latest.minimal;
+            };
+          };
+        in
+        {
+          codex-rs = codex-rs;
+          default = codex-rs;
+        }
+      );
+
+      devShells = forAllSystems (system:
+        let
+          pkgs = import nixpkgs {
+            inherit system;
+            overlays = [ rust-overlay.overlays.default ];
+          };
+          rust = pkgs.rust-bin.stable.latest.default.override {
+            extensions = [ "rust-src" "rust-analyzer" ];
+          };
+        in
+        {
+          default = pkgs.mkShell {
+            buildInputs = [
+              rust
+              pkgs.pkg-config
+              pkgs.openssl
+              pkgs.cmake
+              pkgs.llvmPackages.clang
+              pkgs.llvmPackages.libclang.lib
+            ];
+            PKG_CONFIG_PATH = "${pkgs.openssl.dev}/lib/pkgconfig";
+            LIBCLANG_PATH = "${pkgs.llvmPackages.libclang.lib}/lib";
+            # Use clang for BoringSSL compilation (avoids GCC 15 warnings-as-errors)
+            shellHook = ''
+              export CC=clang
+              export CXX=clang++
+            '';
+          };
+        }
+      );
+    };
+}

justfile

@@ -0,0 +1,205 @@
+set working-directory := "codex-rs"
+set positional-arguments
+export CODEX_REPO_ROOT := justfile_directory()
+export JUST_SHELL := justfile_directory() / "scripts/just-shell.py"
+set shell := ["python3", "-c", 'import os, runpy; runpy.run_path(os.environ["JUST_SHELL"], run_name="__main__")']
+set windows-shell := ["python", "-c", 'import os, runpy; runpy.run_path(os.environ["JUST_SHELL"], run_name="__main__")']
+
+rust_min_stack := "8388608" # 8 MiB
+python := if os_family() == "windows" { "python" } else { "python3" }
+
+# Display help
+help:
+    just -l
+
+# `codex`
+alias c := codex
+codex *args:
+    cargo run --bin codex -- {args}
+
+# `codex exec`
+exec *args:
+    cargo run --bin codex -- exec {args}
+
+# Start `codex exec-server` and run codex-tui.
+[no-cd]
+[positional-arguments]
+[unix]
+tui-with-exec-server *args:
+    {{ justfile_directory() }}/scripts/run_tui_with_exec_server.sh "$@"
+
+# Run the CLI version of the file-search crate.
+file-search *args:
+    cargo run --bin codex-file-search -- {args}
+
+# Run the standalone code-mode host from source.
+code-mode-host *args:
+    cargo run --bin codex-code-mode-host -- {args}
+
+# Assemble a local Codex package.
+[no-cd]
+assemble-codex-package *args:
+    {{ python }} {{ justfile_directory() }}/scripts/build_codex_package.py {args}
+
+# Build the CLI and run the app-server test client
+app-server-test-client *args:
+    cargo build -p codex-cli
+    cargo run -p codex-app-server-test-client -- --codex-bin ./target/debug/codex {args}
+
+# Format the justfile, Rust, Bazel/Starlark, Python SDK code, and Python scripts.
+fmt:
+    @{{ python }} ../scripts/format.py
+
+# Check formatting without modifying files.
+fmt-check:
+    @{{ python }} ../scripts/format.py --check
+
+fix *args:
+    cargo clippy --fix --tests --allow-dirty {args}
+
+clippy *args:
+    cargo clippy --tests {args}
+
+[unix]
+install:
+    rustup show active-toolchain
+    cargo fetch
+
+[windows]
+install:
+    #!powershell.exe -File
+    $pwsh = Get-Command pwsh.exe -ErrorAction SilentlyContinue
+    if (-not $pwsh) {
+        winget install --exact --id Microsoft.PowerShell --source winget --accept-package-agreements --accept-source-agreements
+        if ($LASTEXITCODE -ne 0) { exit $LASTEXITCODE }
+    }
+    rustup show active-toolchain
+    if ($LASTEXITCODE -ne 0) { exit $LASTEXITCODE }
+    cargo fetch
+    exit $LASTEXITCODE
+
+# Run nextest with --no-fail-fast so all tests are run.
+#
+# Run `cargo install --locked cargo-nextest` if you don't have it installed.
+# Prefer this for routine local runs. Workspace crate features are banned, so
+# there should be no need to add `--all-features`.
+[unix]
+test *args:
+    RUST_MIN_STACK={{ rust_min_stack }} NEXTEST_PROFILE=local cargo nextest run --no-fail-fast "$@"
+
+[windows]
+test *args:
+    $env:RUST_MIN_STACK = "{{ rust_min_stack }}"; $env:NEXTEST_PROFILE = "local"; cargo nextest run --no-fail-fast @($args | Select-Object -Skip 1)
+
+# Run from the repository root so scripts that resolve paths from `cwd` see
+# the same layout they use in GitHub Actions.
+[no-cd]
+test-github-scripts:
+    {{ python }} -m unittest discover -s {{ justfile_directory() }}/.github/scripts -p 'test_*.py'
+
+# Run explicit workspace benchmark targets.
+bench *args:
+    cargo bench --workspace --bench '*' {args}
+
+# Run benchmark targets once to ensure they start successfully.
+bench-smoke:
+    just bench -- --test
+
+# Run Bazel-backed end-to-end macrobenchmarks with optimized binaries.
+bench-e2e:
+    # Keep measured binaries comparable to production-style optimized builds.
+    bazel test --compilation_mode=opt --cache_test_results=no --test_output=streamed //codex-rs:e2e-benchmarks
+
+# Run Bazel-backed end-to-end macrobenchmarks once per case with release-like
+# Rust cfg paths but fastbuild codegen.
+bench-e2e-smoke:
+    # Avoid optimizer cost because smoke runs only check that benchmarks work.
+    # Compile target Rust code through the same release-only cfg paths as opt.
+    # Compile exec-platform Rust tools through those release-only cfg paths too.
+    bazel test --compilation_mode=fastbuild --@rules_rust//rust/settings:extra_rustc_flag=-Cdebug-assertions=no --@rules_rust//rust/settings:extra_exec_rustc_flag=-Cdebug-assertions=no --cache_test_results=no --test_output=streamed --test_arg=--test //codex-rs:e2e-benchmarks
+
+# Build and run Codex from source using Bazel.
+# On Unix, use `[no-cd]` and `--run_under="cd $PWD &&"` to ensure Bazel runs
+# the command in the current working directory.
+[no-cd]
+[unix]
+bazel-codex *args:
+    bazel run //codex-rs/cli:codex --run_under="cd $PWD &&" -- "$@"
+
+[windows]
+bazel-codex *args:
+    bazel run //codex-rs/cli:codex --run_under='cd /d "{{ invocation_directory_native() }}" &&' -- @($args | Select-Object -Skip 1)
+
+# Build and run the standalone code-mode host from source using Bazel.
+[no-cd]
+[unix]
+bazel-code-mode-host *args:
+    bazel run //codex-rs/code-mode-host:codex-code-mode-host --run_under="cd $PWD &&" -- "$@"
+
+[windows]
+bazel-code-mode-host *args:
+    bazel run //codex-rs/code-mode-host:codex-code-mode-host --run_under='cd /d "{{ invocation_directory_native() }}" &&' -- @($args | Select-Object -Skip 1)
+
+[no-cd]
+bazel-lock-update:
+    bazel mod deps --lockfile_mode=update
+
+[no-cd]
+[unix]
+bazel-lock-check:
+    {{ justfile_directory() }}/scripts/check-module-bazel-lock.sh
+
+[windows]
+bazel-lock-check:
+    bazel mod deps --lockfile_mode=error; if ($LASTEXITCODE -ne 0) { Write-Error "MODULE.bazel.lock is out of date. Run 'just bazel-lock-update' and commit the updated lockfile."; exit 1 }
+
+bazel-test:
+    bazel test --test_tag_filters=-argument-comment-lint //... --keep_going
+
+[no-cd]
+[unix]
+bazel-clippy:
+    bazel_targets="$({{ justfile_directory() }}/scripts/list-bazel-clippy-targets.sh)" && bazel build --config=clippy -- ${bazel_targets}
+
+[no-cd]
+[unix]
+bazel-argument-comment-lint:
+    bazel build --config=argument-comment-lint -- $({{ justfile_directory() }}/tools/argument-comment-lint/list-bazel-targets.sh)
+
+build-for-release:
+    bazel build //codex-rs/cli:release_binaries
+
+# Regenerate the json schema for config.toml from the current config types.
+write-config-schema:
+    cargo run -p codex-config-schema --bin codex-write-config-schema
+
+# Regenerate app-server protocol schemas and the Python SDK derived from them.
+write-app-server-schema *args:
+    {{ python }} app-server-protocol/scripts/write_schema_fixtures.py {args}
+
+[no-cd]
+write-hooks-schema:
+    cargo run --manifest-path {{ justfile_directory() }}/codex-rs/Cargo.toml -p codex-hooks --bin write_hooks_schema_fixtures
+
+# Run the argument-comment Dylint checks across codex-rs.
+[no-cd]
+[unix]
+argument-comment-lint *args:
+    if [ "$#" -eq 0 ]; then \
+      bazel build --config=argument-comment-lint -- $({{ justfile_directory() }}/tools/argument-comment-lint/list-bazel-targets.sh); \
+    else \
+      {{ justfile_directory() }}/tools/argument-comment-lint/run-prebuilt-linter.py "$@"; \
+    fi
+
+[no-cd]
+argument-comment-lint-from-source *args:
+    {{ python }} {{ justfile_directory() }}/tools/argument-comment-lint/run.py {args}
+
+# Tail logs from the state SQLite database
+[unix]
+log *args:
+    if [ "${1:-}" = "--" ]; then shift; fi; cargo run -p codex-cli --bin logs_client -- "$@"
+
+[windows]
+log *args:
+    $forwarded_args = @($args | Select-Object -Skip 1); if ($forwarded_args.Count -gt 0 -and $forwarded_args[0] -eq "--") { $forwarded_args = @($forwarded_args | Select-Object -Skip 1) }; cargo run -p codex-cli --bin logs_client -- @forwarded_args

package.json

@@ -0,0 +1,39 @@
+{
+  "name": "codex-monorepo",
+  "private": true,
+  "description": "Tools for repo-wide maintenance.",
+  "scripts": {
+    "format": "prettier --check *.json *.md docs/*.md .github/workflows/*.yml **/*.js",
+    "format:fix": "prettier --write *.json *.md docs/*.md .github/workflows/*.yml **/*.js",
+    "write-hooks-schema": "cargo run --manifest-path ./codex-rs/Cargo.toml -p codex-hooks --bin write_hooks_schema_fixtures"
+  },
+  "devDependencies": {
+    "prettier": "^3.5.3"
+  },
+  "resolutions": {
+    "@modelcontextprotocol/sdk": "1.26.0",
+    "braces": "^3.0.3",
+    "esbuild": "0.28.1",
+    "fast-uri": "3.1.1",
+    "flatted": "3.4.2",
+    "glob@10.4.5": "10.5.0",
+    "handlebars": "4.7.9",
+    "hono": "4.12.25",
+    "micromatch": "^4.0.8",
+    "minimatch@3.1.2": "3.1.4",
+    "minimatch@9.0.5": "9.0.7",
+    "path-to-regexp": "8.4.0",
+    "picomatch@2.3.1": "2.3.2",
+    "picomatch@4.0.3": "4.0.4",
+    "rollup": "4.59.0",
+    "semver": "^7.7.1"
+  },
+  "overrides": {
+    "punycode": "^2.3.1"
+  },
+  "engines": {
+    "node": ">=22",
+    "pnpm": ">=10.34.5"
+  },
+  "packageManager": "pnpm@10.34.5+sha512.a4ee05f2f73658255bd6a89859c065a45c28a57daefae2c893a168ee2b73168c37b91e83e57ea67654ad03f03031746430e8bce38e362e042605fb8abc80192e"
+}

patches/rules_rust_build_script_tools_transition.patch

@@ -0,0 +1,19 @@
+diff --git a/cargo/private/cargo_build_script.bzl b/cargo/private/cargo_build_script.bzl
+--- a/cargo/private/cargo_build_script.bzl
++++ b/cargo/private/cargo_build_script.bzl
+@@ -396,3 +396,8 @@ def _cargo_build_script_impl(ctx):
++    script_tools = []
++    for target in ctx.attr.tools:
++        script_tools.append(target[DefaultInfo].files)
++        script_tools.append(target[DefaultInfo].default_runfiles.files)
++
+     workspace_name = ctx.label.workspace_name
+     if not workspace_name:
+         workspace_name = ctx.workspace_name
+@@ -581,5 +586,5 @@ def _cargo_build_script_impl(ctx):
+         direct = [
+             ctx.executable._cargo_build_script_runner,
+         ] + ([toolchain.target_json] if toolchain.target_json else []),
+-        transitive = script_data + toolchain_tools,
++        transitive = script_data + script_tools + toolchain_tools,
+     )

patches/v8_bazel_rules.patch

@@ -0,0 +1,502 @@
+# What: adapt upstream V8 Bazel rules to this workspace's hermetic toolchains
+# and externally provided dependencies.
+# Scope: Bazel BUILD/defs/BUILD.icu integration only, including dependency
+# wiring, generated sources, and visibility; no standalone V8 source patching.
+
+diff --git a/orig/v8-15.0.245.2/bazel/defs.bzl b/mod/v8-15.0.245.2/bazel/defs.bzl
+index bbe1495..6673518 100644
+--- a/orig/v8-15.0.245.2/bazel/defs.bzl
++++ b/mod/v8-15.0.245.2/bazel/defs.bzl
+@@ -33,9 +33,21 @@ _create_option_int = rule(
+ )
+ 
+ def v8_flag(name, default = False):
+-    _create_option_flag(name = name, build_setting_default = default)
+-    native.config_setting(name = "is_" + name, flag_values = {name: "True"})
+-    native.config_setting(name = "is_not_" + name, flag_values = {name: "False"})
++    _create_option_flag(
++        name = name,
++        build_setting_default = default,
++        visibility = ["//visibility:public"],
++    )
++    native.config_setting(
++        name = "is_" + name,
++        flag_values = {name: "True"},
++        visibility = ["//visibility:public"],
++    )
++    native.config_setting(
++        name = "is_not_" + name,
++        flag_values = {name: "False"},
++        visibility = ["//visibility:public"],
++    )
+ 
+ def v8_string(name, default = ""):
+     _create_option_string(name = name, build_setting_default = default)
+@@ -97,7 +109,13 @@ v8_config = rule(
+ 
+ def _default_args():
+     return struct(
+-        deps = [":define_flags", "@libcxx//:libc++"],
++        deps = [":define_flags"] + select({
++            "@v8//:is_v8_use_rusty_v8_custom_libcxx": [
++                "@@//third_party/v8:rusty_v8_custom_libcxx_headers",
++                "@@//third_party/v8:rusty_v8_custom_libcxx_runtime",
++            ],
++            "//conditions:default": [],
++        }),
+         defines = select({
+             "@v8//bazel/config:is_windows": [
+                 "UNICODE",
+@@ -127,12 +145,15 @@ def _default_args():
+             ],
+             "//conditions:default": [],
+         }) + select({
+-            "@v8//bazel/config:is_clang": [
+-                "-Wno-invalid-offsetof",
+-                "-Wno-deprecated-this-capture",
+-                "-Wno-deprecated-declarations",
+-                "-std=c++20",
++            "@v8//:is_v8_use_rusty_v8_custom_libcxx": [
++                "-nostdinc++",
++                "-D_LIBCPP_DISABLE_VISIBILITY_ANNOTATIONS",
++                "-D_LIBCPP_HARDENING_MODE=_LIBCPP_HARDENING_MODE_EXTENSIVE",
++                "-D_LIBCPP_INSTRUMENTED_WITH_ASAN=0",
++                "-D_LIBCXXABI_DISABLE_VISIBILITY_ANNOTATIONS",
+             ],
++            "//conditions:default": [],
++        }) + select({
+             "@v8//bazel/config:is_gcc": [
+                 "-Wno-extra",
+                 "-Wno-array-bounds",
+@@ -152,9 +173,17 @@ def _default_args():
+                 "-std=gnu++2a",
+             ],
+             "@v8//bazel/config:is_windows": [
+-                "/std:c++20",
++                "-Wno-invalid-offsetof",
++                "-Wno-deprecated-this-capture",
++                "-Wno-deprecated-declarations",
++                "-std=c++20",
++            ],
++            "//conditions:default": [
++                "-Wno-invalid-offsetof",
++                "-Wno-deprecated-this-capture",
++                "-Wno-deprecated-declarations",
++                "-std=c++20",
+             ],
+-            "//conditions:default": [],
+         }) + select({
+             "@v8//bazel/config:is_gcc_fastbuild": [
+                 # Non-debug builds without optimizations fail because
+@@ -178,12 +207,12 @@ def _default_args():
+         includes = ["include"],
+         linkopts = select({
+             "@v8//bazel/config:is_windows": [
+-                "Winmm.lib",
+-                "DbgHelp.lib",
+-                "Advapi32.lib",
++                "-lwinmm",
++                "-ldbghelp",
++                "-ladvapi32",
+             ],
+             "@v8//bazel/config:is_macos": ["-pthread"],
+-            "//conditions:default": ["-Wl,--no-as-needed -ldl -latomic -pthread"],
++            "//conditions:default": ["-Wl,--no-as-needed -ldl -pthread"],
+         }) + select({
+             ":should_add_rdynamic": ["-rdynamic"],
+             "//conditions:default": [],
+@@ -459,6 +488,11 @@
+ def _mksnapshot(ctx):
+     prefix = ctx.attr.prefix
+     suffix = ctx.attr.suffix
++    # Windows cross-builds use Linux for the exec configuration, but the
++    # snapshot generator must match the target ABI and run on the Windows
++    # runner. Action strategies only choose where an action runs; they cannot
++    # change this executable from the exec to the target configuration.
++    tool = ctx.executable.target_tool if ctx.attr.target_os == "win" else ctx.executable.tool
+     outs = [
+         ctx.actions.declare_file(prefix + "/snapshot" + suffix + ".cc"),
+         ctx.actions.declare_file(prefix + "/embedded" + suffix + ".S"),
+@@ -477,6 +511,6 @@
+             outs[1].path,
+         ] + ctx.attr.args,
+-        executable = ctx.executable.tool,
++        executable = tool,
+         progress_message = "Running mksnapshot",
+     )
+     return [DefaultInfo(files = depset(outs))]
+@@ -491,6 +525,12 @@
+             executable = True,
+             cfg = "exec",
+         ),
++        "target_tool": attr.label(
++            mandatory = True,
++            allow_files = True,
++            executable = True,
++            cfg = "target",
++        ),
+         "target_os": attr.string(mandatory = True),
+         "prefix": attr.string(mandatory = True),
+         "suffix": attr.string(mandatory = True),
+@@ -504,6 +544,7 @@
+         args = args,
+         prefix = "noicu",
+         tool = ":noicu/mksnapshot" + suffix,
++        target_tool = ":noicu/mksnapshot" + suffix,
+         suffix = suffix,
+         target_os = select({
+             "@v8//bazel/config:is_macos": "mac",
+@@ -516,6 +557,7 @@
+         args = args,
+         prefix = "icu",
+         tool = ":icu/mksnapshot" + suffix,
++        target_tool = ":icu/mksnapshot" + suffix,
+         suffix = suffix,
+         target_os = select({
+             "@v8//bazel/config:is_macos": "mac",
+diff --git a/orig/v8-15.0.245.2/BUILD.bazel b/mod/v8-15.0.245.2/BUILD.bazel
+index b432f86..28c567b 100644
+--- a/orig/v8-15.0.245.2/BUILD.bazel
++++ b/mod/v8-15.0.245.2/BUILD.bazel
+@@ -148,6 +148,10 @@ v8_flag(name = "v8_enable_trace_maps")
+ 
+ v8_flag(name = "v8_enable_v8_checks")
+ 
++v8_flag(name = "v8_enable_sandbox")
++
++v8_flag(name = "v8_use_rusty_v8_custom_libcxx")
++
+ v8_flag(name = "v8_enable_verify_csa")
+ 
+ v8_flag(name = "v8_enable_verify_heap")
+@@ -313,7 +317,7 @@ v8_int(
+ # If no explicit value for v8_enable_pointer_compression, we set it to 'none'.
+ v8_string(
+     name = "v8_enable_pointer_compression",
+-    default = "none",
++    default = "False",
+ )
+ 
+ # Default setting for v8_enable_pointer_compression.
+@@ -513,6 +517,7 @@ v8_config(
+         "v8_enable_slow_dchecks": "ENABLE_SLOW_DCHECKS",
+         "v8_enable_runtime_call_stats": "V8_RUNTIME_CALL_STATS",
+         "v8_enable_snapshot_native_code_counters": "V8_SNAPSHOT_NATIVE_CODE_COUNTERS",
++        "v8_enable_sandbox": "V8_ENABLE_SANDBOX",
+         "v8_enable_trace_maps": "V8_TRACE_MAPS",
+         "v8_enable_turbofan": "V8_ENABLE_TURBOFAN",
+         "v8_enable_v8_checks": "V8_ENABLE_CHECKS",
+@@ -4125,28 +4130,14 @@ filegroup(
+     }),
+ )
+ 
+-v8_library(
+-  name = "lib_dragonbox",
+-  srcs = ["third_party/dragonbox/src/include/dragonbox/dragonbox.h"],
+-  hdrs = [
+-    "third_party/dragonbox/src/include/dragonbox/dragonbox.h",
+-  ],
+-  includes = [
+-    "third_party/dragonbox/src/include",
+-  ],
++alias(
++    name = "lib_dragonbox",
++    actual = "@dragonbox//:dragonbox",
+ )
+ 
+-v8_library(
+-  name = "lib_fp16",
+-  srcs = ["third_party/fp16/src/include/fp16.h"],
+-  hdrs = [
+-    "third_party/fp16/src/include/fp16/fp16.h",
+-    "third_party/fp16/src/include/fp16/bitcasts.h",
+-    "third_party/fp16/src/include/fp16/macros.h",
+-  ],
+-  includes = [
+-    "third_party/fp16/src/include",
+-  ],
++alias(
++    name = "lib_fp16",
++    actual = "@fp16//:fp16",
+ )
+ 
+ filegroup(
+@@ -4441,6 +4432,20 @@ genrule(
+     srcs = [
+         "include/js_protocol.pdl",
+         "src/inspector/inspector_protocol_config.json",
++        "third_party/inspector_protocol/code_generator.py",
++        "third_party/inspector_protocol/pdl.py",
++        "third_party/inspector_protocol/lib/Forward_h.template",
++        "third_party/inspector_protocol/lib/Object_cpp.template",
++        "third_party/inspector_protocol/lib/Object_h.template",
++        "third_party/inspector_protocol/lib/Protocol_cpp.template",
++        "third_party/inspector_protocol/lib/ValueConversions_cpp.template",
++        "third_party/inspector_protocol/lib/ValueConversions_h.template",
++        "third_party/inspector_protocol/lib/Values_cpp.template",
++        "third_party/inspector_protocol/lib/Values_h.template",
++        "third_party/inspector_protocol/templates/Exported_h.template",
++        "third_party/inspector_protocol/templates/Imported_h.template",
++        "third_party/inspector_protocol/templates/TypeBuilder_cpp.template",
++        "third_party/inspector_protocol/templates/TypeBuilder_h.template",
+     ],
+     outs = [
+         "include/inspector/Debugger.h",
+@@ -4462,15 +4467,19 @@ genrule(
+         "src/inspector/protocol/Schema.cpp",
+         "src/inspector/protocol/Schema.h",
+     ],
+-    cmd = "$(location :code_generator) --jinja_dir . \
+-           --inspector_protocol_dir third_party/inspector_protocol \
++    cmd = "INSPECTOR_PROTOCOL_DIR=$$(dirname $(execpath third_party/inspector_protocol/code_generator.py)); \
++           PYTHONPATH=$$INSPECTOR_PROTOCOL_DIR:external/rules_python++pip+v8_python_deps_311_jinja2/site-packages:external/rules_python++pip+v8_python_deps_311_markupsafe/site-packages:$${PYTHONPATH-} \
++           $(execpath @rules_python//python/bin:python) $(execpath third_party/inspector_protocol/code_generator.py) --jinja_dir . \
++           --inspector_protocol_dir $$INSPECTOR_PROTOCOL_DIR \
+            --config $(location :src/inspector/inspector_protocol_config.json) \
+            --config_value protocol.path=$(location :include/js_protocol.pdl) \
++           --config_value crdtp.dir=third_party/inspector_protocol/crdtp \
+            --output_base $(@D)/src/inspector",
+-    local = 1,
+     message = "Generating inspector files",
+     tools = [
+-        ":code_generator",
++        "@rules_python//python/bin:python",
++        requirement("jinja2"),
++        requirement("markupsafe"),
+     ],
+ )
+ 
+@@ -4484,6 +4493,35 @@ filegroup(
+     ],
+ )
+ 
++cc_library(
++    name = "rusty_v8_internal_headers",
++    hdrs = [
++        "src/libplatform/default-platform.h",
++    ],
++    strip_include_prefix = "",
++    visibility = ["//visibility:public"],
++)
++
++cc_library(
++    name = "rusty_v8_crdtp_headers",
++    hdrs = [
++        "third_party/inspector_protocol/crdtp/cbor.h",
++        "third_party/inspector_protocol/crdtp/dispatch.h",
++        "third_party/inspector_protocol/crdtp/error_support.h",
++        "third_party/inspector_protocol/crdtp/export.h",
++        "third_party/inspector_protocol/crdtp/find_by_first.h",
++        "third_party/inspector_protocol/crdtp/frontend_channel.h",
++        "third_party/inspector_protocol/crdtp/json.h",
++        "third_party/inspector_protocol/crdtp/parser_handler.h",
++        "third_party/inspector_protocol/crdtp/protocol_core.h",
++        "third_party/inspector_protocol/crdtp/serializable.h",
++        "third_party/inspector_protocol/crdtp/span.h",
++        "third_party/inspector_protocol/crdtp/status.h",
++    ],
++    strip_include_prefix = "",
++    visibility = ["//visibility:public"],
++)
++
+ filegroup(
+     name = "d8_files",
+     srcs = [
+@@ -4576,12 +4614,10 @@ cc_library(
+     strip_include_prefix = "noicu",
+ )
+-
++
+-cc_library(
+-    name = "llvm_libc_headers",
+-    hdrs = glob(["third_party/llvm-libc/src/shared/**/*.h"]),
+-    includes = ["third_party/llvm-libc/src"],
+-    defines = ["LIBC_NAMESPACE=__llvm_libc_cr"],
+-)
++alias(
++    name = "llvm_libc_headers",
++    actual = "@@//third_party/v8:rusty_v8_llvm_libc_headers",
++)
+-
++
+ v8_library(
+     name = "v8_libbase",
+@@ -4603,16 +4641,9 @@ cc_library(
+     ],
+ )
+ 
+-cc_library(
+-  name = "simdutf",
+-  srcs = ["third_party/simdutf/simdutf.cpp"],
+-  hdrs = ["third_party/simdutf/simdutf.h"],
+-  copts = select({
+-        "@v8//bazel/config:is_clang": ["-std=c++20"],
+-        "@v8//bazel/config:is_gcc": ["-std=gnu++2a"],
+-        "@v8//bazel/config:is_windows": ["/std:c++20"],
+-        "//conditions:default": [],
+-    }),
++alias(
++    name = "simdutf",
++    actual = "@simdutf//:simdutf",
+ )
+ 
+ v8_library(
+@@ -4629,7 +4660,7 @@ v8_library(
+     copts = ["-Wno-implicit-fallthrough"],
+     icu_deps = [
+         ":icu/generated_torque_definitions_headers",
+-        "//external:icu",
++        "@icu//:icu",
+     ],
+     icu_srcs = [
+         ":generated_regexp_special_case",
+@@ -4644,7 +4675,7 @@ v8_library(
+     ],
+     deps = [
+         ":lib_dragonbox",
+-        "//third_party/fast_float/src:fast_float",
++        "@fast_float//:fast_float",
+         ":lib_fp16",
+         ":simdutf",
+         ":v8_libbase",
+@@ -4700,6 +4731,7 @@ alias(
+ alias(
+     name = "core_lib_icu",
+     actual = "icu/v8",
++    visibility = ["//visibility:public"],
+ )
+ 
+ v8_library(
+@@ -4751,7 +4783,7 @@ v8_binary(
+     ],
+     deps = [
+         ":v8_libbase",
+-        "//external:icu",
++        "@icu//:icu",
+     ],
+ )
+ 
+@@ -4791,9 +4823,20 @@ v8_binary(
+         ":icu/generated_torque_initializers",
+         ":icu/v8_initializers_files",
+     ],
++    # Match GN's mksnapshot `disable_icf` config. If the linker folds distinct
++    # external-reference helpers together while producing the snapshot, the
++    # final embedder binary may not fold the same pair and startup
++    # deserialization will reject the snapshot.
++    # GN also increases the x64 Windows stack reserve because constructing the
++    # snapshot overflows the linker's 1 MiB default.
+     linkopts = select({
+         "@v8//bazel/config:is_android": ["-llog"],
+-        "//conditions:default": [],
++        "@v8//bazel/config:is_macos": ["-Wl,-no_deduplicate"],
++        "@v8//bazel/config:is_windows": [
++            "-Wl,/OPT:NOICF",
++            "-Wl,/STACK:2097152",
++        ],
++        "//conditions:default": ["-Wl,--icf=none"],
+     }),
+     noicu_deps = [":v8_libshared_noicu"],
+     noicu_srcs = [
+diff --git a/orig/v8-15.0.245.2/bazel/BUILD.icu b/mod/v8-15.0.245.2/bazel/BUILD.icu
+index 5fda2f4..8c3c372 100644
+--- a/orig/v8-15.0.245.2/bazel/BUILD.icu
++++ b/mod/v8-15.0.245.2/bazel/BUILD.icu
+@@ -1,3 +1,24 @@
++load("@rules_cc//cc:defs.bzl", "cc_library")
++
++CUSTOM_LIBCXX_COPTS = select({
++    "@v8//:is_v8_use_rusty_v8_custom_libcxx": [
++        "-nostdinc++",
++        "-D_LIBCPP_DISABLE_VISIBILITY_ANNOTATIONS",
++        "-D_LIBCPP_HARDENING_MODE=_LIBCPP_HARDENING_MODE_EXTENSIVE",
++        "-D_LIBCPP_INSTRUMENTED_WITH_ASAN=0",
++        "-D_LIBCXXABI_DISABLE_VISIBILITY_ANNOTATIONS",
++    ],
++    "//conditions:default": [],
++})
++
++CUSTOM_LIBCXX_DEPS = select({
++    "@v8//:is_v8_use_rusty_v8_custom_libcxx": [
++        "@@//third_party/v8:rusty_v8_custom_libcxx_headers",
++        "@@//third_party/v8:rusty_v8_custom_libcxx_runtime",
++    ],
++    "//conditions:default": [],
++})
++
+ # Copyright 2021 the V8 project authors. All rights reserved.
+ # Use of this source code is governed by a BSD-style license that can be
+ # found in the LICENSE file.
+@@ -16,15 +37,12 @@ cc_library(
+     ]),
+     copts = select({
+         "@platforms//os:windows": [
+-            "/wd4005",  # Macro redefinition.
+-            "/wd4068",  # Unknown pragmas.
+-            "/wd4267",  # Conversion from size_t on 64-bits.
+-            "/utf-8",  # ICU source files are in UTF-8.
++            "-Wno-deprecated-declarations",
+         ],
+         "//conditions:default": [
+             "-Wno-deprecated-declarations",
+         ],
+-    }),
++    }) + CUSTOM_LIBCXX_COPTS,
+     data = [":icudata"],
+     defines = [
+         "HAVE_DLOPEN=0",
+@@ -54,6 +72,7 @@ cc_library(
+         "U_ICUDATAENTRY_IN_COMMON",
+     ],
+     tags = ["requires-rtti"],
++    deps = CUSTOM_LIBCXX_DEPS,
+     alwayslink = 1,
+ )
+ 
+@@ -65,19 +84,16 @@ cc_library(
+     ]),
+     copts = select({
+         "@platforms//os:windows": [
+-            "/wd4005",  # Macro redefinition.
+-            "/wd4068",  # Unknown pragmas.
+-            "/wd4267",  # Conversion from size_t on 64-bits.
+-            "/utf-8",  # ICU source files are in UTF-8.
++            "-Wno-deprecated-declarations",
+         ],
+         "//conditions:default": [
+             "-Wno-deprecated-declarations",
+         ],
+-    }),
++    }) + CUSTOM_LIBCXX_COPTS,
+     local_defines = [
+         "U_I18N_IMPLEMENTATION",
+     ],
+-    deps = [":icuuc"],
++    deps = [":icuuc"] + CUSTOM_LIBCXX_DEPS,
+     alwayslink = 1,
+ )
+ 
+@@ -93,13 +109,10 @@ cc_library(
+     ]),
+     copts = select({
+         "@platforms//os:windows": [
+-            "/wd4005",  # Macro redefinition.
+-            "/wd4068",  # Unknown pragmas.
+-            "/wd4267",  # Conversion from size_t on 64-bits.
+-            "/utf-8",  # ICU source files are in UTF-8.
++            "-Wno-deprecated-declarations",
+         ],
+         "//conditions:default": [],
+-    }),
++    }) + CUSTOM_LIBCXX_COPTS,
+     include_prefix = "third_party/icu",
+     local_defines = [
+         "U_COMMON_IMPLEMENTATION",
+@@ -108,6 +121,6 @@ cc_library(
+     deps = [
+         ":icui18n",
+         ":icuuc",
+-    ],
++    ] + CUSTOM_LIBCXX_DEPS,
+     alwayslink = 1,
+ )

patches/v8_source_portability.patch

@@ -0,0 +1,316 @@
+# What: make upstream V8 sources build cleanly in this hermetic toolchain setup.
+# Scope: minimal source-level portability fixes only, such as libexecinfo guards,
+# weak glibc symbol handling, and warning annotations; no dependency
+# include-path rewrites or intentional V8 feature changes.
+diff --git a/orig/v8-15.0.245.2/src/base/bits.h b/mod/v8-15.0.245.2/src/base/bits.h
+index 179a10f..4791e96 100644
+--- a/orig/v8-15.0.245.2/src/base/bits.h
++++ b/mod/v8-15.0.245.2/src/base/bits.h
+@@ -270,11 +270,17 @@ inline constexpr uint32_t RoundDownToPowerOfTwo32(uint32_t value) {
+ }
+ 
+ // Precondition: 0 <= shift < 32
++#ifdef RotateRight32
++#undef RotateRight32
++#endif
+ inline constexpr uint32_t RotateRight32(uint32_t value, uint32_t shift) {
+   return (value >> shift) | (value << ((32 - shift) & 31));
+ }
+ 
+ // Precondition: 0 <= shift < 32
++#ifdef RotateLeft32
++#undef RotateLeft32
++#endif
+ inline constexpr uint32_t RotateLeft32(uint32_t value, uint32_t shift) {
+   return (value << shift) | (value >> ((32 - shift) & 31));
+ }
+diff --git a/orig/v8-15.0.245.2/src/base/debug/stack_trace_posix.cc b/mod/v8-15.0.245.2/src/base/debug/stack_trace_posix.cc
+index 6176ed4..a02043d 100644
+--- a/orig/v8-15.0.245.2/src/base/debug/stack_trace_posix.cc
++++ b/mod/v8-15.0.245.2/src/base/debug/stack_trace_posix.cc
+@@ -64,6 +64,7 @@ namespace {
+ volatile sig_atomic_t in_signal_handler = 0;
+ bool dump_stack_in_signal_handler = true;
+ 
++#if HAVE_EXECINFO_H
+ // The prefix used for mangled symbols, per the Itanium C++ ABI:
+ // http://www.codesourcery.com/cxx-abi/abi.html#mangling
+ const char kMangledSymbolPrefix[] = "_Z";
+@@ -73,7 +74,6 @@ const char kMangledSymbolPrefix[] = "_Z";
+ const char kSymbolCharacters[] =
+     "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_";
+ 
+-#if HAVE_EXECINFO_H
+ // Demangles C++ symbols in the given text. Example:
+ //
+ // "out/Debug/base_unittests(_ZN10StackTraceC1Ev+0x20) [0x817778c]"
+diff --git a/orig/v8-15.0.245.2/src/base/export-template.h b/mod/v8-15.0.245.2/src/base/export-template.h
+index 861cfe4..1e73954 100644
+--- a/orig/v8-15.0.245.2/src/base/export-template.h
++++ b/mod/v8-15.0.245.2/src/base/export-template.h
+@@ -153,8 +153,10 @@
+ 
+ EXPORT_TEMPLATE_TEST(DEFAULT, );
+ EXPORT_TEMPLATE_TEST(DEFAULT, __attribute__((visibility("default"))));
++#if defined(_MSC_VER)
+ EXPORT_TEMPLATE_TEST(MSVC_HACK, __declspec(dllexport));
+ EXPORT_TEMPLATE_TEST(DEFAULT, __declspec(dllimport));
++#endif
+ 
+ #undef EXPORT_TEMPLATE_TEST
+ #undef EXPORT_TEMPLATE_TEST_DEFAULT_DEFAULT
+diff --git a/orig/v8-15.0.245.2/src/base/platform/platform-posix.cc b/mod/v8-15.0.245.2/src/base/platform/platform-posix.cc
+index dfb30b6..6ce12a5 100644
+--- a/orig/v8-15.0.245.2/src/base/platform/platform-posix.cc
++++ b/mod/v8-15.0.245.2/src/base/platform/platform-posix.cc
+@@ -95,7 +95,7 @@ extern int madvise(caddr_t, size_t, int);
+ #endif
+ 
+ #if defined(V8_LIBC_GLIBC)
+-extern "C" void* __libc_stack_end;
++extern "C" void* __libc_stack_end V8_WEAK;
+ #endif
+ 
+ namespace v8 {
+@@ -1476,7 +1476,8 @@ Stack::StackSlot Stack::ObtainCurrentThreadStackStart() {
+   // __libc_stack_end is process global and thus is only valid for
+   // the main thread. Check whether this is the main thread by checking
+   // __libc_stack_end is within the thread's stack.
+-  if ((base <= __libc_stack_end) && (__libc_stack_end <= stack_start)) {
++  if (__libc_stack_end != nullptr &&
++      (base <= __libc_stack_end) && (__libc_stack_end <= stack_start)) {
+     DCHECK(MainThreadIsCurrentThread());
+     return __libc_stack_end;
+   }
+diff --git a/orig/v8-15.0.245.2/src/base/platform/platform-win32.cc b/mod/v8-15.0.245.2/src/base/platform/platform-win32.cc
+index 11f9772..854a682 100644
+--- a/orig/v8-15.0.245.2/src/base/platform/platform-win32.cc
++++ b/mod/v8-15.0.245.2/src/base/platform/platform-win32.cc
+@@ -20,7 +20,11 @@
+ #include <windows.h>
+ 
+ // This has to come after windows.h.
++#ifdef __MINGW32__
++#include <versionhelpers.h>
++#else
+ #include <VersionHelpers.h>
++#endif
+ #include <dbghelp.h>            // For SymLoadModule64 and al.
+ #include <malloc.h>             // For _msize()
+ #include <mmsystem.h>           // For timeGetTime().
+@@ -69,9 +73,7 @@ static_assert(offsetof(V8_CRITICAL_SECTION, SpinCount) ==
+ // Extra functions for MinGW. Most of these are the _s functions which are in
+ // the Microsoft Visual Studio C++ CRT.
+ #ifdef __MINGW32__
+-
+-
+-#ifndef __MINGW64_VERSION_MAJOR
++#if !defined(__MINGW64_VERSION_MAJOR)
+ 
+ #define _TRUNCATE 0
+ #define STRUNCATE 80
+@@ -81,9 +83,6 @@ inline void MemoryFence() {
+   __asm__ __volatile__("xchgl %%eax,%0 ":"=r" (barrier));
+ }
+ 
+-#endif  // __MINGW64_VERSION_MAJOR
+-
+-
+ int localtime_s(tm* out_tm, const time_t* time) {
+   tm* posix_local_time_struct = localtime_r(time, out_tm);
+   if (posix_local_time_struct == nullptr) return 1;
+@@ -134,6 +133,8 @@ int strncpy_s(char* dest, size_t dest_size, const char* source, size_t count) {
+   return 0;
+ }
+ 
++#endif  // !defined(__MINGW64_VERSION_MAJOR)
++
+ #endif  // __MINGW32__
+ 
+ namespace v8 {
+@@ -743,8 +744,10 @@ void OS::StrNCpy(char* dest, int length, const char* src, size_t n) {
+ }
+ 
+ 
++#if defined(__MINGW32__) && !defined(__MINGW64_VERSION_MAJOR)
+ #undef _TRUNCATE
+ #undef STRUNCATE
++#endif
+ 
+ DEFINE_LAZY_LEAKY_OBJECT_GETTER(RandomNumberGenerator,
+                                 GetPlatformRandomNumberGenerator)
+@@ -1943,3 +1946,4 @@ Stack::StackSlot Stack::GetCurrentStackPosition() {
+ 
+ }  // namespace base
+ }  // namespace v8
++
+diff --git a/orig/v8-15.0.245.2/src/base/platform/time.cc b/mod/v8-15.0.245.2/src/base/platform/time.cc
+index 8c824e3..f8144d0 100644
+--- a/orig/v8-15.0.245.2/src/base/platform/time.cc
++++ b/mod/v8-15.0.245.2/src/base/platform/time.cc
+@@ -782,12 +782,12 @@ bool ThreadTicks::IsSupported() {
+ #elif defined(__PASE__)
+   // Thread CPU time accounting is unavailable in PASE
+   return false;
++#elif defined(V8_OS_WIN)
++  return IsSupportedWin();
+ #elif (defined(_POSIX_THREAD_CPUTIME) && (_POSIX_THREAD_CPUTIME >= 0)) || \
+     defined(V8_OS_DARWIN) || defined(V8_OS_ANDROID) ||                    \
+     defined(V8_OS_SOLARIS) || defined(V8_OS_ZOS)
+   return true;
+-#elif defined(V8_OS_WIN)
+-  return IsSupportedWin();
+ #else
+   return false;
+ #endif
+@@ -804,13 +804,13 @@ ThreadTicks ThreadTicks::Now() {
+   return ThreadTicks(ComputeThreadTicks());
+ #elif V8_OS_FUCHSIA
+   return ThreadTicks(GetFuchsiaThreadTicks());
++#elif V8_OS_WIN
++  return ThreadTicks::GetForThread(::GetCurrentThread());
+ #elif (defined(_POSIX_THREAD_CPUTIME) && (_POSIX_THREAD_CPUTIME >= 0)) || \
+     defined(V8_OS_ANDROID) || defined(V8_OS_ZOS)
+   return ThreadTicks(ClockNow(CLOCK_THREAD_CPUTIME_ID));
+ #elif V8_OS_SOLARIS
+   return ThreadTicks(gethrvtime() / Time::kNanosecondsPerMicrosecond);
+-#elif V8_OS_WIN
+-  return ThreadTicks::GetForThread(::GetCurrentThread());
+ #else
+   UNREACHABLE();
+ #endif
+diff --git a/orig/v8-15.0.245.2/src/heap/base/asm/x64/push_registers_masm.asm b/mod/v8-15.0.245.2/src/heap/base/asm/x64/push_registers_masm.asm
+index d0d0563..f3f5952 100644
+--- a/orig/v8-15.0.245.2/src/heap/base/asm/x64/push_registers_masm.asm
++++ b/mod/v8-15.0.245.2/src/heap/base/asm/x64/push_registers_masm.asm
+@@ -1,70 +1,47 @@
+-;; Copyright 2020 the V8 project authors. All rights reserved.
+-;; Use of this source code is governed by a BSD-style license that can be
+-;; found in the LICENSE file.
+-
+-;; MASM syntax
+-;; https://docs.microsoft.com/en-us/cpp/assembler/masm/microsoft-macro-assembler-reference?view=vs-2019
+-
+-public PushAllRegistersAndIterateStack
+-
+-.code
+-PushAllRegistersAndIterateStack proc frame
+-    ;; Push all callee-saved registers to get them on the stack for conservative
+-    ;; stack scanning.
+-    ;;
+-    ;; We maintain 16-byte alignment at calls. There is an 8-byte return address
+-    ;; on the stack and we push 232 bytes which maintains 16-byte stack
+-    ;; alignment at the call.
+-    ;; Source: https://docs.microsoft.com/en-us/cpp/build/x64-calling-convention
+-    ;;
+-    ;; rbp is callee-saved. Maintain proper frame pointer for debugging.
+-    push rbp
+-    .pushreg rbp
+-    mov rbp, rsp
+-    .setframe rbp, 0
+-    push 0CDCDCDh  ;; Dummy for alignment.
+-    .allocstack 8
+-    push rsi
+-    .pushreg rsi
+-    push rdi
+-    .pushreg rdi
+-    push rbx
+-    .pushreg rbx
+-    push r12
+-    .pushreg r12
+-    push r13
+-    .pushreg r13
+-    push r14
+-    .pushreg r14
+-    push r15
+-    .pushreg r15
+-    sub rsp, 160
+-    .allocstack 160
+-    .endprolog
+-    ;; Use aligned instrs as we are certain that the stack is properly aligned.
+-    movdqa  xmmword ptr [rsp + 144], xmm6
+-    movdqa  xmmword ptr [rsp + 128], xmm7
+-    movdqa  xmmword ptr [rsp + 112], xmm8
+-    movdqa  xmmword ptr [rsp + 96], xmm9
+-    movdqa  xmmword ptr [rsp + 80], xmm10
+-    movdqa  xmmword ptr [rsp + 64], xmm11
+-    movdqa  xmmword ptr [rsp + 48], xmm12
+-    movdqa  xmmword ptr [rsp + 32], xmm13
+-    movdqa  xmmword ptr [rsp + 16], xmm14
+-    movdqa  xmmword ptr [rsp], xmm15
+-    ;; Pass 1st parameter (rcx) unchanged (Stack*).
+-    ;; Pass 2nd parameter (rdx) unchanged (StackVisitor*).
+-    ;; Save 3rd parameter (r8; IterateStackCallback)
+-    mov r9, r8
+-    ;; Pass 3rd parameter as rsp (stack pointer).
+-    mov r8, rsp
+-    ;; Call the callback.
+-    call r9
+-    ;; Pop the callee-saved registers.
+-    add rsp, 224
+-    ;; Restore rbp as it was used as frame pointer.
+-    pop rbp
+-    ret
+-    PushAllRegistersAndIterateStack endp
+-
+-end
++.text
++.globl PushAllRegistersAndIterateStack
++.seh_proc PushAllRegistersAndIterateStack
++PushAllRegistersAndIterateStack:
++  push %rbp
++  .seh_pushreg %rbp
++  mov %rsp, %rbp
++  .seh_setframe %rbp, 0
++  push $0xCDCDCD
++  .seh_stackalloc 8
++  push %rsi
++  .seh_pushreg %rsi
++  push %rdi
++  .seh_pushreg %rdi
++  push %rbx
++  .seh_pushreg %rbx
++  push %r12
++  .seh_pushreg %r12
++  push %r13
++  .seh_pushreg %r13
++  push %r14
++  .seh_pushreg %r14
++  push %r15
++  .seh_pushreg %r15
++  sub $160, %rsp
++  .seh_stackalloc 160
++  # Preserve Windows unwind metadata even though this is now GNU syntax.
++  # Without the .seh_* directives, SEH and stack walking can mis-handle
++  # unwinding across this callback frame.
++  .seh_endprologue
++  movdqa %xmm6, 144(%rsp)
++  movdqa %xmm7, 128(%rsp)
++  movdqa %xmm8, 112(%rsp)
++  movdqa %xmm9, 96(%rsp)
++  movdqa %xmm10, 80(%rsp)
++  movdqa %xmm11, 64(%rsp)
++  movdqa %xmm12, 48(%rsp)
++  movdqa %xmm13, 32(%rsp)
++  movdqa %xmm14, 16(%rsp)
++  movdqa %xmm15, 0(%rsp)
++  mov %r8, %r9
++  mov %rsp, %r8
++  call *%r9
++  add $224, %rsp
++  pop %rbp
++  ret
++.seh_endproc
+diff --git a/orig/v8-15.0.245.2/src/libplatform/default-thread-isolated-allocator.cc b/mod/v8-15.0.245.2/src/libplatform/default-thread-isolated-allocator.cc
+index bda0e43..b44f1d9 100644
+--- a/orig/v8-15.0.245.2/src/libplatform/default-thread-isolated-allocator.cc
++++ b/mod/v8-15.0.245.2/src/libplatform/default-thread-isolated-allocator.cc
+@@ -23,7 +23,7 @@ extern int pkey_free(int pkey) V8_WEAK;
+ 
+ namespace {
+ 
+-bool KernelHasPkruFix() {
++[[maybe_unused]] bool KernelHasPkruFix() {
+   // PKU was broken on Linux kernels before 5.13 (see
+   // https://lore.kernel.org/all/20210623121456.399107624@linutronix.de/).
+   // A fix is also included in the 5.4.182 and 5.10.103 versions ("x86/fpu:

pnpm-workspace.yaml

@@ -0,0 +1,19 @@
+packages:
+  - codex-cli
+  - codex-rs/responses-api-proxy/npm
+  - sdk/typescript
+
+ignoredBuiltDependencies:
+  - esbuild
+
+minimumReleaseAge: 10080
+minimumReleaseAgeExclude: []
+
+blockExoticSubdeps: true
+strictDepBuilds: true
+trustPolicy: no-downgrade
+trustPolicyIgnoreAfter: 10080
+trustPolicyExclude: []
+allowBuilds:
+  # Build only the official MCP conformance CLI pinned by the TypeScript SDK.
+  "@modelcontextprotocol/conformance@https://codeload.github.com/modelcontextprotocol/conformance/tar.gz/49103de6ed70804e940637bf3e9e29e4a3f54e64": true

rbe.bzl

@@ -0,0 +1,42 @@
+def _rbe_platform_repo_impl(rctx):
+    arch = rctx.os.arch
+    if arch in ["x86_64", "amd64"]:
+        cpu = "x86_64"
+        exec_arch = "amd64"
+        image_sha = "0a8e56bfaa3b2e5279db0d3bb2d62b44ba5e5d63a37d97eb8790f49da570af70"
+    elif arch in ["aarch64", "arm64"]:
+        cpu = "aarch64"
+        exec_arch = "arm64"
+        image_sha = "136487cc4b7cf6f1021816ca18ed00896daed98404ea91dc4d6dd9e9d1cf9564"
+    else:
+        fail("Unsupported host arch for rbe platform: {}".format(arch))
+
+    rctx.file("BUILD.bazel", """\
+platform(
+    name = "rbe_platform",
+    constraint_values = [
+        "@platforms//cpu:{cpu}",
+        "@platforms//os:linux",
+        "@bazel_tools//tools/cpp:clang",
+        "@llvm//constraints/libc:gnu.2.28",
+    ],
+    exec_properties = {{
+        # Ubuntu-based image that includes git, python3, dotslash, and other
+        # tools that various integration tests need.
+        # Verify at https://hub.docker.com/layers/mbolin491/codex-bazel/latest/images/sha256:{image_sha}
+        "container-image": "docker://docker.io/mbolin491/codex-bazel@sha256:{image_sha}",
+        "Arch": "{arch}",
+        "OSFamily": "Linux",
+    }},
+    visibility = ["//visibility:public"],
+)
+""".format(
+        cpu = cpu,
+        arch = exec_arch,
+        image_sha = image_sha,
+    ))
+
+rbe_platform_repository = repository_rule(
+    implementation = _rbe_platform_repo_impl,
+    doc = "Sets up a platform for remote builds with an Arch exec_property matching the host.",
+)

ruff.toml

@@ -0,0 +1 @@
+extend-exclude = ["sdk/python", "codex-rs/vendor"]

tools/buildifier

@@ -0,0 +1,73 @@
+#!/usr/bin/env dotslash
+
+{
+  "name": "buildifier",
+  "platforms": {
+    "macos-aarch64": {
+      "size": 7565746,
+      "hash": "sha256",
+      "digest": "62836a9667fa0db309b0d91e840f0a3f2813a9c8ea3e44b9cd58187c90bc88ba",
+      "path": "buildifier",
+      "providers": [
+        {
+          "url": "https://github.com/bazelbuild/buildtools/releases/download/v8.5.1/buildifier-darwin-arm64"
+        }
+      ]
+    },
+    "macos-x86_64": {
+      "size": 7737072,
+      "hash": "sha256",
+      "digest": "31de189e1a3fe53aa9e8c8f74a0309c325274ad19793393919e1ca65163ca1a4",
+      "path": "buildifier",
+      "providers": [
+        {
+          "url": "https://github.com/bazelbuild/buildtools/releases/download/v8.5.1/buildifier-darwin-amd64"
+        }
+      ]
+    },
+    "linux-aarch64": {
+      "size": 7483831,
+      "hash": "sha256",
+      "digest": "947bf6700d708026b2057b09bea09abbc3cafc15d9ecea35bb3885c4b09ccd04",
+      "path": "buildifier",
+      "providers": [
+        {
+          "url": "https://github.com/bazelbuild/buildtools/releases/download/v8.5.1/buildifier-linux-arm64"
+        }
+      ]
+    },
+    "linux-x86_64": {
+      "size": 7757842,
+      "hash": "sha256",
+      "digest": "887377fc64d23a850f4d18a077b5db05b19913f4b99b270d193f3c7334b5a9a7",
+      "path": "buildifier",
+      "providers": [
+        {
+          "url": "https://github.com/bazelbuild/buildtools/releases/download/v8.5.1/buildifier-linux-amd64"
+        }
+      ]
+    },
+    "windows-aarch64": {
+      "size": 7451648,
+      "hash": "sha256",
+      "digest": "55a276ad8b1ff46be48bf64e432264034ea69a45aa3914e89c1d1936f5c2d85c",
+      "path": "buildifier.exe",
+      "providers": [
+        {
+          "url": "https://github.com/bazelbuild/buildtools/releases/download/v8.5.1/buildifier-windows-arm64.exe"
+        }
+      ]
+    },
+    "windows-x86_64": {
+      "size": 7861760,
+      "hash": "sha256",
+      "digest": "f4ecb9c73de2bc38b845d4ee27668f6248c4813a6647db4b4931a7556052e4e1",
+      "path": "buildifier.exe",
+      "providers": [
+        {
+          "url": "https://github.com/bazelbuild/buildtools/releases/download/v8.5.1/buildifier-windows-amd64.exe"
+        }
+      ]
+    }
+  }
+}

workspace_root_test_launcher.bat.tpl

@@ -0,0 +1,177 @@
+@echo off
+setlocal EnableExtensions EnableDelayedExpansion
+
+call :resolve_runfile "__WORKSPACE_ROOT_MARKER__"
+if errorlevel 1 exit /b 1
+set "workspace_root_marker=!resolve_runfile_result!"
+
+for %%I in ("%workspace_root_marker%") do set "workspace_root_marker_dir=%%~dpI"
+for %%I in ("%workspace_root_marker_dir%..\..") do set "workspace_root=%%~fI"
+
+call :resolve_runfile "__TEST_BIN__"
+if errorlevel 1 exit /b 1
+set "test_bin=!resolve_runfile_result!"
+
+__RUNFILE_ENV_EXPORTS__
+
+if not defined test_bin (
+  >&2 echo resolved test binary was lost while exporting runfile environment variables
+  exit /b 1
+)
+
+__WORKSPACE_ROOT_SETUP__
+
+set "TOTAL_SHARDS=%RULES_RUST_TEST_TOTAL_SHARDS%"
+if not defined TOTAL_SHARDS set "TOTAL_SHARDS=%TEST_TOTAL_SHARDS%"
+if defined TESTBRIDGE_TEST_ONLY if "%~1"=="" (
+  "%test_bin%" "%TESTBRIDGE_TEST_ONLY%"
+  exit /b !ERRORLEVEL!
+)
+if defined CODEX_BAZEL_TEST_SKIP_FILTERS (
+  call :run_selected_libtest %*
+  exit /b !ERRORLEVEL!
+)
+if defined TOTAL_SHARDS if not "%TOTAL_SHARDS%"=="0" (
+  call :run_selected_libtest %*
+  exit /b !ERRORLEVEL!
+)
+
+"%test_bin%" %*
+exit /b %ERRORLEVEL%
+
+:run_selected_libtest
+if defined TEST_SHARD_STATUS_FILE if defined TEST_TOTAL_SHARDS if not "%TEST_TOTAL_SHARDS%"=="0" (
+  type nul > "%TEST_SHARD_STATUS_FILE%"
+)
+
+if not "%~1"=="" (
+  "%test_bin%" %*
+  exit /b !ERRORLEVEL!
+)
+
+set "SHARD_INDEX=%RULES_RUST_TEST_SHARD_INDEX%"
+if not defined SHARD_INDEX set "SHARD_INDEX=%TEST_SHARD_INDEX%"
+set "HAS_SHARDS="
+if defined TOTAL_SHARDS if not "%TOTAL_SHARDS%"=="0" set "HAS_SHARDS=1"
+if defined HAS_SHARDS if not defined SHARD_INDEX (
+  >&2 echo TEST_SHARD_INDEX or RULES_RUST_TEST_SHARD_INDEX must be set when sharding is enabled
+  exit /b 1
+)
+
+set "TEMP_ROOT=%TEST_TMPDIR%"
+if not defined TEMP_ROOT set "TEMP_ROOT=%TEMP%"
+if not defined TEMP_ROOT set "TEMP_ROOT=."
+:CREATE_TEMP_DIR
+set "TEMP_DIR=%TEMP_ROOT%\workspace_root_test_sharding_!RANDOM!_!RANDOM!_!RANDOM!"
+mkdir "!TEMP_DIR!" 2>nul
+if errorlevel 1 goto :CREATE_TEMP_DIR
+set "TEMP_LIST=!TEMP_DIR!\list.txt"
+set "TEMP_SHARD_LIST=!TEMP_DIR!\shard.txt"
+
+"%test_bin%" --list --format terse > "!TEMP_LIST!"
+if errorlevel 1 (
+  rmdir /s /q "!TEMP_DIR!" 2>nul
+  exit /b 1
+)
+
+powershell.exe -NoProfile -ExecutionPolicy Bypass -Command ^
+  "$ErrorActionPreference = 'Stop';" ^
+  "$tests = @(Get-Content -LiteralPath $env:TEMP_LIST | Where-Object { $_.EndsWith(': test') } | ForEach-Object { $_.Substring(0, $_.Length - 6) });" ^
+  "[Array]::Sort($tests, [StringComparer]::Ordinal);" ^
+  "$hasShards = -not [string]::IsNullOrEmpty($env:HAS_SHARDS);" ^
+  "$skipFilters = @();" ^
+  "if (-not [string]::IsNullOrEmpty($env:CODEX_BAZEL_TEST_SKIP_FILTERS)) { $skipFilters = @($env:CODEX_BAZEL_TEST_SKIP_FILTERS -split ',' | Where-Object { $_ -ne '' }) };" ^
+  "if ($hasShards) { $totalShards = [uint32]$env:TOTAL_SHARDS; $shardIndex = [uint32]$env:SHARD_INDEX };" ^
+  "$fnvPrime = [uint64]16777619; $u32Mask = [uint64]4294967295;" ^
+  "foreach ($test in $tests) { $skip = $false; foreach ($filter in $skipFilters) { if ($test.Contains($filter)) { $skip = $true; break } }; if ($skip) { continue }; if ($hasShards) { $hash = [uint32]2166136261; foreach ($byte in [Text.Encoding]::UTF8.GetBytes($test)) { $hash = [uint32](([uint64]($hash -bxor $byte) * $fnvPrime) -band $u32Mask) }; if (($hash %% $totalShards) -eq $shardIndex) { $test } } else { $test } }" ^
+  > "!TEMP_SHARD_LIST!"
+if errorlevel 1 (
+  rmdir /s /q "!TEMP_DIR!" 2>nul
+  exit /b 1
+)
+
+powershell.exe -NoProfile -ExecutionPolicy Bypass -Command ^
+  "$ErrorActionPreference = 'Stop';" ^
+  "$testBin = $env:test_bin;" ^
+  "$tests = @(Get-Content -LiteralPath $env:TEMP_SHARD_LIST);" ^
+  "$failed = $false; $limit = 7000; $batch = @(); $batchChars = $testBin.Length + 8;" ^
+  "function Invoke-TestBatch { if ($script:batch.Count -eq 0) { return }; & $script:testBin @script:batch '--exact'; if ($LASTEXITCODE -ne 0) { $script:failed = $true }; $script:batch = @(); $script:batchChars = $script:testBin.Length + 8 }" ^
+  "foreach ($test in $tests) { $argChars = $test.Length + 3; if (($batch.Count -gt 0) -and ($batchChars + $argChars -gt $limit)) { Invoke-TestBatch }; $batch += $test; $batchChars += $argChars }" ^
+  "Invoke-TestBatch; if ($failed) { exit 1 }"
+set "TEST_EXIT=%ERRORLEVEL%"
+
+rmdir /s /q "!TEMP_DIR!" 2>nul
+exit /b !TEST_EXIT!
+
+:resolve_runfile
+set "resolve_runfile_result="
+set "resolve_runfile_logical_path=%~1"
+set "resolve_runfile_workspace_logical_path=!resolve_runfile_logical_path!"
+if defined TEST_WORKSPACE set "resolve_runfile_workspace_logical_path=%TEST_WORKSPACE%/!resolve_runfile_logical_path!"
+set "resolve_runfile_native_logical_path=!resolve_runfile_logical_path:/=\!"
+set "resolve_runfile_native_workspace_logical_path=!resolve_runfile_workspace_logical_path:/=\!"
+
+for %%R in ("%RUNFILES_DIR%" "%TEST_SRCDIR%") do (
+  set "resolve_runfile_root=%%~R"
+  if defined resolve_runfile_root (
+    if exist "!resolve_runfile_root!\!resolve_runfile_native_logical_path!" (
+      set "resolve_runfile_result=!resolve_runfile_root!\!resolve_runfile_native_logical_path!"
+      goto :resolve_runfile_success
+    )
+    if exist "!resolve_runfile_root!\!resolve_runfile_native_workspace_logical_path!" (
+      set "resolve_runfile_result=!resolve_runfile_root!\!resolve_runfile_native_workspace_logical_path!"
+      goto :resolve_runfile_success
+    )
+  )
+)
+
+set "resolve_runfile_manifest=%RUNFILES_MANIFEST_FILE%"
+if not defined resolve_runfile_manifest if exist "%~f0.runfiles_manifest" set "resolve_runfile_manifest=%~f0.runfiles_manifest"
+if not defined resolve_runfile_manifest if exist "%~dpn0.runfiles_manifest" set "resolve_runfile_manifest=%~dpn0.runfiles_manifest"
+if not defined resolve_runfile_manifest if exist "%~f0.exe.runfiles_manifest" set "resolve_runfile_manifest=%~f0.exe.runfiles_manifest"
+
+if defined resolve_runfile_manifest if exist "!resolve_runfile_manifest!" (
+  rem Read the manifest directly instead of shelling out to findstr. In the
+  rem GitHub Windows runner, the nested `findstr` path produced
+  rem `FINDSTR: Cannot open D:MANIFEST`, which then broke runfile resolution for
+  rem Bazel tests even though the manifest file was present.
+  rem A one-field manifest entry maps to itself, so fall back to %%A when the
+  rem optional mapped path in %%B is empty.
+  for /f "usebackq tokens=1,* delims= " %%A in ("!resolve_runfile_manifest!") do (
+    if "%%A"=="!resolve_runfile_logical_path!" (
+      set "resolve_runfile_manifest_path=%%B"
+      if not defined resolve_runfile_manifest_path set "resolve_runfile_manifest_path=%%A"
+      set "resolve_runfile_result=!resolve_runfile_manifest_path!"
+      goto :resolve_runfile_success
+    )
+    if "%%A"=="!resolve_runfile_workspace_logical_path!" (
+      set "resolve_runfile_manifest_path=%%B"
+      if not defined resolve_runfile_manifest_path set "resolve_runfile_manifest_path=%%A"
+      set "resolve_runfile_result=!resolve_runfile_manifest_path!"
+      goto :resolve_runfile_success
+    )
+  )
+)
+
+>&2 echo failed to resolve runfile: !resolve_runfile_logical_path!
+call :clear_resolve_runfile_state
+exit /b 1
+
+:resolve_runfile_success
+if not defined resolve_runfile_result (
+  >&2 echo resolved runfile has an empty path: !resolve_runfile_logical_path!
+  call :clear_resolve_runfile_state
+  exit /b 1
+)
+call :clear_resolve_runfile_state
+exit /b 0
+
+:clear_resolve_runfile_state
+set "resolve_runfile_logical_path="
+set "resolve_runfile_workspace_logical_path="
+set "resolve_runfile_native_logical_path="
+set "resolve_runfile_native_workspace_logical_path="
+set "resolve_runfile_root="
+set "resolve_runfile_manifest="
+set "resolve_runfile_manifest_path="
+exit /b 0

workspace_root_test_launcher.sh.tpl

@@ -0,0 +1,169 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+resolve_runfile() {
+  local logical_path="$1"
+  local workspace_logical_path="${logical_path}"
+  if [[ -n "${TEST_WORKSPACE:-}" ]]; then
+    workspace_logical_path="${TEST_WORKSPACE}/${logical_path}"
+  fi
+
+  for runfiles_root in "${RUNFILES_DIR:-}" "${TEST_SRCDIR:-}"; do
+    if [[ -n "${runfiles_root}" && -e "${runfiles_root}/${logical_path}" ]]; then
+      printf '%s\n' "${runfiles_root}/${logical_path}"
+      return 0
+    fi
+    if [[ -n "${runfiles_root}" && -e "${runfiles_root}/${workspace_logical_path}" ]]; then
+      printf '%s\n' "${runfiles_root}/${workspace_logical_path}"
+      return 0
+    fi
+  done
+
+  local manifest="${RUNFILES_MANIFEST_FILE:-}"
+  if [[ -z "${manifest}" ]]; then
+    if [[ -f "$0.runfiles_manifest" ]]; then
+      manifest="$0.runfiles_manifest"
+    elif [[ -f "$0.exe.runfiles_manifest" ]]; then
+      manifest="$0.exe.runfiles_manifest"
+    fi
+  fi
+
+  if [[ -n "${manifest}" && -f "${manifest}" ]]; then
+    local resolved=""
+    resolved="$(awk -v key="${logical_path}" '$1 == key { $1 = ""; sub(/^ /, ""); print; exit }' "${manifest}")"
+    if [[ -z "${resolved}" ]]; then
+      resolved="$(awk -v key="${workspace_logical_path}" '$1 == key { $1 = ""; sub(/^ /, ""); print; exit }' "${manifest}")"
+    fi
+    if [[ -n "${resolved}" ]]; then
+      printf '%s\n' "${resolved}"
+      return 0
+    fi
+  fi
+
+  echo "failed to resolve runfile: $logical_path" >&2
+  return 1
+}
+
+workspace_root_marker="$(resolve_runfile "__WORKSPACE_ROOT_MARKER__")"
+workspace_root="$(dirname "$(dirname "$(dirname "${workspace_root_marker}")")")"
+test_bin="$(resolve_runfile "__TEST_BIN__")"
+RUNFILE_ENV_ARGS=()
+
+__RUNFILE_ENV_EXPORTS__
+
+run_test_bin() {
+  if (( ${#RUNFILE_ENV_ARGS[@]} > 0 )); then
+    env "${RUNFILE_ENV_ARGS[@]}" "${test_bin}" "$@"
+  else
+    "${test_bin}" "$@"
+  fi
+}
+
+exec_test_bin() {
+  if (( ${#RUNFILE_ENV_ARGS[@]} > 0 )); then
+    exec env "${RUNFILE_ENV_ARGS[@]}" "${test_bin}" "$@"
+  else
+    exec "${test_bin}" "$@"
+  fi
+}
+
+libtest_args=("$@")
+if [[ ${#libtest_args[@]} -eq 0 && -n "${TESTBRIDGE_TEST_ONLY:-}" ]]; then
+  libtest_args+=("${TESTBRIDGE_TEST_ONLY}")
+fi
+
+test_shard_index() {
+  local test_name="$1"
+  # FNV-1a 32-bit hash. Keep this stable so adding one test does not reshuffle
+  # unrelated tests between shards.
+  local hash=2166136261
+  local byte
+  local char
+  local i
+  local LC_ALL=C
+
+  for ((i = 0; i < ${#test_name}; i++)); do
+    char="${test_name:i:1}"
+    printf -v byte "%d" "'$char"
+    hash=$(( ((hash ^ byte) * 16777619) & 0xffffffff ))
+  done
+
+  echo $(( hash % TOTAL_SHARDS ))
+}
+
+run_selected_libtest() {
+  if [[ -n "${TEST_SHARD_STATUS_FILE:-}" && "${TEST_TOTAL_SHARDS:-0}" != "0" ]]; then
+    touch "${TEST_SHARD_STATUS_FILE}"
+  fi
+
+  # Extra libtest args are usually ad-hoc local filters. Preserve those exactly
+  # rather than combining them with generated exact filters.
+  if [[ ${#libtest_args[@]} -gt 0 ]]; then
+    exec_test_bin "${libtest_args[@]}"
+  fi
+
+  local has_shards=0
+  if [[ -n "${TOTAL_SHARDS}" && "${TOTAL_SHARDS}" != "0" ]]; then
+    has_shards=1
+  fi
+
+  if [[ "${has_shards}" == "1" && -z "${SHARD_INDEX}" ]]; then
+    echo "TEST_SHARD_INDEX or RULES_RUST_TEST_SHARD_INDEX must be set when sharding is enabled" >&2
+    exit 1
+  fi
+
+  local list_output
+  local test_list
+  list_output="$(run_test_bin --list --format terse)"
+  test_list="$(printf '%s\n' "${list_output}" | grep ': test$' | sed 's/: test$//' | LC_ALL=C sort || true)"
+
+  if [[ -z "${test_list}" ]]; then
+    exit 0
+  fi
+
+  local skip_filters="${CODEX_BAZEL_TEST_SKIP_FILTERS:-}"
+
+  local shard_tests=()
+  local test_name
+  while IFS= read -r test_name; do
+    local skip=0
+    if [[ -n "${skip_filters}" ]]; then
+      local filter
+      local old_ifs="${IFS}"
+      IFS=','
+      for filter in ${skip_filters}; do
+        if [[ -n "${filter}" && "${test_name}" == *"${filter}"* ]]; then
+          skip=1
+          break
+        fi
+      done
+      IFS="${old_ifs}"
+    fi
+    if [[ "${skip}" == "1" ]]; then
+      continue
+    fi
+    if [[ "${has_shards}" == "0" || $(test_shard_index "${test_name}") == "${SHARD_INDEX}" ]]; then
+      shard_tests+=("${test_name}")
+    fi
+  done <<< "${test_list}"
+
+  if [[ ${#shard_tests[@]} -eq 0 ]]; then
+    exit 0
+  fi
+
+  exec_test_bin "${shard_tests[@]}" --exact
+}
+
+__WORKSPACE_ROOT_SETUP__
+
+TOTAL_SHARDS="${RULES_RUST_TEST_TOTAL_SHARDS:-${TEST_TOTAL_SHARDS:-}}"
+SHARD_INDEX="${RULES_RUST_TEST_SHARD_INDEX:-${TEST_SHARD_INDEX:-}}"
+if [[ -n "${CODEX_BAZEL_TEST_SKIP_FILTERS:-}" || ( -n "${TOTAL_SHARDS}" && "${TOTAL_SHARDS}" != "0" ) ]]; then
+  run_selected_libtest
+fi
+
+if [[ ${#libtest_args[@]} -gt 0 ]]; then
+  exec_test_bin "${libtest_args[@]}"
+else
+  exec_test_bin
+fi