feat: disable unified_exec on windows

nit: ui on interruption (#9606 )
[bazel] Upgrade to bazel9 (#9576 )
2026-02-01 22:47:52 +00:00 · 2026-01-21 17:59:40 +00:00 · 2026-01-21 14:09:15 +00:00 · 2026-01-21 13:25:36 +00:00 · 2026-01-21 11:53:58 +00:00 · 2026-01-21 11:30:34 +00:00
38 changed files with 2386 additions and 239 deletions
--- a/.bazelversion
+++ b/.bazelversion
@@ -0,0 +1 @@
+9.0.0
--- a/MODULE.bazel
+++ b/MODULE.bazel
@@ -3,12 +3,12 @@ bazel_dep(name = "toolchains_llvm_bootstrapped", version = "0.3.1")
 archive_override(
    module_name = "toolchains_llvm_bootstrapped",
    integrity = "sha256-9ks21bgEqbQWmwUIvqeLA64+Jk6o4ZVjC8KxjVa2Vw8=",
-    strip_prefix = "toolchains_llvm_bootstrapped-e3775e66a7b6d287c705ca0cd24497ef4a77c503",
-    urls = ["https://github.com/cerisier/toolchains_llvm_bootstrapped/archive/e3775e66a7b6d287c705ca0cd24497ef4a77c503/master.tar.gz"],
    patch_strip = 1,
    patches = [
        "//patches:llvm_toolchain_archive_params.patch",
    ],
+    strip_prefix = "toolchains_llvm_bootstrapped-e3775e66a7b6d287c705ca0cd24497ef4a77c503",
+    urls = ["https://github.com/cerisier/toolchains_llvm_bootstrapped/archive/e3775e66a7b6d287c705ca0cd24497ef4a77c503/master.tar.gz"],
 )

 osx = use_extension("@toolchains_llvm_bootstrapped//toolchain/extension:osx.bzl", "osx")
@@ -94,7 +94,7 @@ crate.annotation(
    crate = "windows-link",
    patch_args = ["-p1"],
    patches = [
-        "//patches:windows-link.patch"
+        "//patches:windows-link.patch",
    ],
 )

--- a/MODULE.bazel.lock
+++ b/MODULE.bazel.lock
@@ -1,5 +1,5 @@
 {
-  "lockFileVersion": 24,
+  "lockFileVersion": 26,
  "registryFileHashes": {
    "https://bcr.bazel.build/bazel_registry.json": "8a28e4aff06ee60aed2a8c281907fb8bcbf3b753c91fb5a5c57da3215d5b3497",
    "https://bcr.bazel.build/modules/abseil-cpp/20210324.2/MODULE.bazel": "7cd0312e064fde87c8d1cd79ba06c876bd23630c83466e9500321be55c96ace2",
@@ -9,11 +9,19 @@
    "https://bcr.bazel.build/modules/abseil-cpp/20230802.0/MODULE.bazel": "d253ae36a8bd9ee3c5955384096ccb6baf16a1b1e93e858370da0a3b94f77c16",
    "https://bcr.bazel.build/modules/abseil-cpp/20230802.1/MODULE.bazel": "fa92e2eb41a04df73cdabeec37107316f7e5272650f81d6cc096418fe647b915",
    "https://bcr.bazel.build/modules/abseil-cpp/20240116.1/MODULE.bazel": "37bcdb4440fbb61df6a1c296ae01b327f19e9bb521f9b8e26ec854b6f97309ed",
-    "https://bcr.bazel.build/modules/abseil-cpp/20240116.1/source.json": "9be551b8d4e3ef76875c0d744b5d6a504a27e3ae67bc6b28f46415fd2d2957da",
+    "https://bcr.bazel.build/modules/abseil-cpp/20240116.2/MODULE.bazel": "73939767a4686cd9a520d16af5ab440071ed75cec1a876bf2fcfaf1f71987a16",
+    "https://bcr.bazel.build/modules/abseil-cpp/20250127.1/MODULE.bazel": "c4a89e7ceb9bf1e25cf84a9f830ff6b817b72874088bf5141b314726e46a57c1",
+    "https://bcr.bazel.build/modules/abseil-cpp/20250512.1/MODULE.bazel": "d209fdb6f36ffaf61c509fcc81b19e81b411a999a934a032e10cd009a0226215",
+    "https://bcr.bazel.build/modules/abseil-cpp/20250814.1/MODULE.bazel": "51f2312901470cdab0dbdf3b88c40cd21c62a7ed58a3de45b365ddc5b11bcab2",
+    "https://bcr.bazel.build/modules/abseil-cpp/20250814.1/source.json": "cea3901d7e299da7320700abbaafe57a65d039f10d0d7ea601c4a66938ea4b0c",
+    "https://bcr.bazel.build/modules/apple_support/1.11.1/MODULE.bazel": "1843d7cd8a58369a444fc6000e7304425fba600ff641592161d9f15b179fb896",
+    "https://bcr.bazel.build/modules/apple_support/1.15.1/MODULE.bazel": "a0556fefca0b1bb2de8567b8827518f94db6a6e7e7d632b4c48dc5f865bc7c85",
+    "https://bcr.bazel.build/modules/apple_support/1.21.0/MODULE.bazel": "ac1824ed5edf17dee2fdd4927ada30c9f8c3b520be1b5fd02a5da15bc10bff3e",
+    "https://bcr.bazel.build/modules/apple_support/1.21.1/MODULE.bazel": "5809fa3efab15d1f3c3c635af6974044bac8a4919c62238cce06acee8a8c11f1",
    "https://bcr.bazel.build/modules/apple_support/1.23.0/MODULE.bazel": "317d47e3f65b580e7fb4221c160797fda48e32f07d2dfff63d754ef2316dcd25",
-    "https://bcr.bazel.build/modules/apple_support/1.23.1/MODULE.bazel": "53763fed456a968cf919b3240427cf3a9d5481ec5466abc9d5dc51bc70087442",
    "https://bcr.bazel.build/modules/apple_support/1.24.1/MODULE.bazel": "f46e8ddad60aef170ee92b2f3d00ef66c147ceafea68b6877cb45bd91737f5f8",
-    "https://bcr.bazel.build/modules/apple_support/1.24.1/source.json": "cf725267cbacc5f028ef13bb77e7f2c2e0066923a4dab1025e4a0511b1ed258a",
+    "https://bcr.bazel.build/modules/apple_support/1.24.2/MODULE.bazel": "0e62471818affb9f0b26f128831d5c40b074d32e6dda5a0d3852847215a41ca4",
+    "https://bcr.bazel.build/modules/apple_support/1.24.2/source.json": "2c22c9827093250406c5568da6c54e6fdf0ef06238def3d99c71b12feb057a8d",
    "https://bcr.bazel.build/modules/aspect_bazel_lib/2.14.0/MODULE.bazel": "2b31ffcc9bdc8295b2167e07a757dbbc9ac8906e7028e5170a3708cecaac119f",
    "https://bcr.bazel.build/modules/aspect_bazel_lib/2.19.3/MODULE.bazel": "253d739ba126f62a5767d832765b12b59e9f8d2bc88cc1572f4a73e46eb298ca",
    "https://bcr.bazel.build/modules/aspect_bazel_lib/2.19.3/source.json": "ffab9254c65ba945f8369297ad97ca0dec213d3adc6e07877e23a48624a8b456",
@@ -21,16 +29,21 @@
    "https://bcr.bazel.build/modules/aspect_tools_telemetry/0.3.2/MODULE.bazel": "598e7fe3b54f5fa64fdbeead1027653963a359cc23561d43680006f3b463d5a4",
    "https://bcr.bazel.build/modules/aspect_tools_telemetry/0.3.2/source.json": "c6f5c39e6f32eb395f8fdaea63031a233bbe96d49a3bfb9f75f6fce9b74bec6c",
    "https://bcr.bazel.build/modules/bazel_features/1.1.1/MODULE.bazel": "27b8c79ef57efe08efccbd9dd6ef70d61b4798320b8d3c134fd571f78963dbcd",
+    "https://bcr.bazel.build/modules/bazel_features/1.10.0/MODULE.bazel": "f75e8807570484a99be90abcd52b5e1f390362c258bcb73106f4544957a48101",
    "https://bcr.bazel.build/modules/bazel_features/1.11.0/MODULE.bazel": "f9382337dd5a474c3b7d334c2f83e50b6eaedc284253334cf823044a26de03e8",
    "https://bcr.bazel.build/modules/bazel_features/1.15.0/MODULE.bazel": "d38ff6e517149dc509406aca0db3ad1efdd890a85e049585b7234d04238e2a4d",
    "https://bcr.bazel.build/modules/bazel_features/1.17.0/MODULE.bazel": "039de32d21b816b47bd42c778e0454217e9c9caac4a3cf8e15c7231ee3ddee4d",
    "https://bcr.bazel.build/modules/bazel_features/1.18.0/MODULE.bazel": "1be0ae2557ab3a72a57aeb31b29be347bcdc5d2b1eb1e70f39e3851a7e97041a",
    "https://bcr.bazel.build/modules/bazel_features/1.19.0/MODULE.bazel": "59adcdf28230d220f0067b1f435b8537dd033bfff8db21335ef9217919c7fb58",
+    "https://bcr.bazel.build/modules/bazel_features/1.21.0/MODULE.bazel": "675642261665d8eea09989aa3b8afb5c37627f1be178382c320d1b46afba5e3b",
+    "https://bcr.bazel.build/modules/bazel_features/1.23.0/MODULE.bazel": "fd1ac84bc4e97a5a0816b7fd7d4d4f6d837b0047cf4cbd81652d616af3a6591a",
    "https://bcr.bazel.build/modules/bazel_features/1.24.0/MODULE.bazel": "4796b4c25b47053e9bbffa792b3792d07e228ff66cd0405faef56a978708acd4",
    "https://bcr.bazel.build/modules/bazel_features/1.27.0/MODULE.bazel": "621eeee06c4458a9121d1f104efb80f39d34deff4984e778359c60eaf1a8cb65",
    "https://bcr.bazel.build/modules/bazel_features/1.28.0/MODULE.bazel": "4b4200e6cbf8fa335b2c3f43e1d6ef3e240319c33d43d60cc0fbd4b87ece299d",
+    "https://bcr.bazel.build/modules/bazel_features/1.3.0/MODULE.bazel": "cdcafe83ec318cda34e02948e81d790aab8df7a929cec6f6969f13a489ccecd9",
    "https://bcr.bazel.build/modules/bazel_features/1.30.0/MODULE.bazel": "a14b62d05969a293b80257e72e597c2da7f717e1e69fa8b339703ed6731bec87",
    "https://bcr.bazel.build/modules/bazel_features/1.32.0/MODULE.bazel": "095d67022a58cb20f7e20e1aefecfa65257a222c18a938e2914fd257b5f1ccdc",
+    "https://bcr.bazel.build/modules/bazel_features/1.33.0/MODULE.bazel": "8b8dc9d2a4c88609409c3191165bccec0e4cb044cd7a72ccbe826583303459f6",
    "https://bcr.bazel.build/modules/bazel_features/1.34.0/MODULE.bazel": "e8475ad7c8965542e0c7aac8af68eb48c4af904be3d614b6aa6274c092c2ea1e",
    "https://bcr.bazel.build/modules/bazel_features/1.34.0/source.json": "dfa5c4b01110313153b484a735764d247fee5624bbab63d25289e43b151a657a",
    "https://bcr.bazel.build/modules/bazel_features/1.4.1/MODULE.bazel": "e45b6bb2350aff3e442ae1111c555e27eac1d915e77775f6fdc4b351b758b5d7",
@@ -52,20 +65,25 @@
    "https://bcr.bazel.build/modules/bazel_skylib/1.8.1/MODULE.bazel": "88ade7293becda963e0e3ea33e7d54d3425127e0a326e0d17da085a5f1f03ff6",
    "https://bcr.bazel.build/modules/bazel_skylib/1.8.2/MODULE.bazel": "69ad6927098316848b34a9142bcc975e018ba27f08c4ff403f50c1b6e646ca67",
    "https://bcr.bazel.build/modules/bazel_skylib/1.8.2/source.json": "34a3c8bcf233b835eb74be9d628899bb32999d3e0eadef1947a0a562a2b16ffb",
-    "https://bcr.bazel.build/modules/buildozer/7.1.2/MODULE.bazel": "2e8dd40ede9c454042645fd8d8d0cd1527966aa5c919de86661e62953cd73d84",
-    "https://bcr.bazel.build/modules/buildozer/7.1.2/source.json": "c9028a501d2db85793a6996205c8de120944f50a0d570438fcae0457a5f9d1f8",
+    "https://bcr.bazel.build/modules/buildozer/8.2.1/MODULE.bazel": "61e9433c574c2bd9519cad7fa66b9c1d2b8e8d5f3ae5d6528a2c2d26e68d874d",
+    "https://bcr.bazel.build/modules/buildozer/8.2.1/source.json": "7c33f6a26ee0216f85544b4bca5e9044579e0219b6898dd653f5fb449cf2e484",
    "https://bcr.bazel.build/modules/gawk/5.3.2.bcr.1/MODULE.bazel": "cdf8cbe5ee750db04b78878c9633cc76e80dcf4416cbe982ac3a9222f80713c8",
    "https://bcr.bazel.build/modules/gawk/5.3.2.bcr.1/source.json": "fa7b512dfcb5eafd90ce3959cf42a2a6fe96144ebbb4b3b3928054895f2afac2",
    "https://bcr.bazel.build/modules/google_benchmark/1.8.2/MODULE.bazel": "a70cf1bba851000ba93b58ae2f6d76490a9feb74192e57ab8e8ff13c34ec50cb",
    "https://bcr.bazel.build/modules/googletest/1.11.0/MODULE.bazel": "3a83f095183f66345ca86aa13c58b59f9f94a2f81999c093d4eeaa2d262d12f4",
    "https://bcr.bazel.build/modules/googletest/1.14.0.bcr.1/MODULE.bazel": "22c31a561553727960057361aa33bf20fb2e98584bc4fec007906e27053f80c6",
-    "https://bcr.bazel.build/modules/googletest/1.14.0.bcr.1/source.json": "41e9e129f80d8c8bf103a7acc337b76e54fad1214ac0a7084bf24f4cd924b8b4",
    "https://bcr.bazel.build/modules/googletest/1.14.0/MODULE.bazel": "cfbcbf3e6eac06ef9d85900f64424708cc08687d1b527f0ef65aa7517af8118f",
+    "https://bcr.bazel.build/modules/googletest/1.15.2/MODULE.bazel": "6de1edc1d26cafb0ea1a6ab3f4d4192d91a312fd2d360b63adaa213cd00b2108",
+    "https://bcr.bazel.build/modules/googletest/1.17.0/MODULE.bazel": "dbec758171594a705933a29fcf69293d2468c49ec1f2ebca65c36f504d72df46",
+    "https://bcr.bazel.build/modules/googletest/1.17.0/source.json": "38e4454b25fc30f15439c0378e57909ab1fd0a443158aa35aec685da727cd713",
    "https://bcr.bazel.build/modules/jq.bzl/0.1.0/MODULE.bazel": "2ce69b1af49952cd4121a9c3055faa679e748ce774c7f1fda9657f936cae902f",
    "https://bcr.bazel.build/modules/jq.bzl/0.1.0/source.json": "746bf13cac0860f091df5e4911d0c593971cd8796b5ad4e809b2f8e133eee3d5",
    "https://bcr.bazel.build/modules/jsoncpp/1.9.5/MODULE.bazel": "31271aedc59e815656f5736f282bb7509a97c7ecb43e927ac1a37966e0578075",
-    "https://bcr.bazel.build/modules/jsoncpp/1.9.5/source.json": "4108ee5085dd2885a341c7fab149429db457b3169b86eb081fa245eadf69169d",
+    "https://bcr.bazel.build/modules/jsoncpp/1.9.6/MODULE.bazel": "2f8d20d3b7d54143213c4dfc3d98225c42de7d666011528dc8fe91591e2e17b0",
+    "https://bcr.bazel.build/modules/jsoncpp/1.9.6/source.json": "a04756d367a2126c3541682864ecec52f92cdee80a35735a3cb249ce015ca000",
    "https://bcr.bazel.build/modules/libpfm/4.11.0/MODULE.bazel": "45061ff025b301940f1e30d2c16bea596c25b176c8b6b3087e92615adbd52902",
+    "https://bcr.bazel.build/modules/nlohmann_json/3.6.1/MODULE.bazel": "6f7b417dcc794d9add9e556673ad25cb3ba835224290f4f848f8e2db1e1fca74",
+    "https://bcr.bazel.build/modules/nlohmann_json/3.6.1/source.json": "f448c6e8963fdfa7eb831457df83ad63d3d6355018f6574fb017e8169deb43a9",
    "https://bcr.bazel.build/modules/openssl/3.5.4.bcr.0/MODULE.bazel": "0f6b8f20b192b9ff0781406256150bcd46f19e66d807dcb0c540548439d6fc35",
    "https://bcr.bazel.build/modules/openssl/3.5.4.bcr.0/source.json": "543ed7627cc18e6460b9c1ae4a1b6b1debc5a5e0aca878b00f7531c7186b73da",
    "https://bcr.bazel.build/modules/package_metadata/0.0.2/MODULE.bazel": "fb8d25550742674d63d7b250063d4580ca530499f045d70748b1b142081ebb92",
@@ -83,21 +101,28 @@
    "https://bcr.bazel.build/modules/platforms/1.0.0/source.json": "f4ff1fd412e0246fd38c82328eb209130ead81d62dcd5a9e40910f867f733d96",
    "https://bcr.bazel.build/modules/protobuf/21.7/MODULE.bazel": "a5a29bb89544f9b97edce05642fac225a808b5b7be74038ea3640fae2f8e66a7",
    "https://bcr.bazel.build/modules/protobuf/27.0/MODULE.bazel": "7873b60be88844a0a1d8f80b9d5d20cfbd8495a689b8763e76c6372998d3f64c",
-    "https://bcr.bazel.build/modules/protobuf/27.1/MODULE.bazel": "703a7b614728bb06647f965264967a8ef1c39e09e8f167b3ca0bb1fd80449c0d",
    "https://bcr.bazel.build/modules/protobuf/29.0-rc2/MODULE.bazel": "6241d35983510143049943fc0d57937937122baf1b287862f9dc8590fc4c37df",
-    "https://bcr.bazel.build/modules/protobuf/29.0/MODULE.bazel": "319dc8bf4c679ff87e71b1ccfb5a6e90a6dbc4693501d471f48662ac46d04e4e",
-    "https://bcr.bazel.build/modules/protobuf/29.0/source.json": "b857f93c796750eef95f0d61ee378f3420d00ee1dd38627b27193aa482f4f981",
+    "https://bcr.bazel.build/modules/protobuf/29.0-rc3/MODULE.bazel": "33c2dfa286578573afc55a7acaea3cada4122b9631007c594bf0729f41c8de92",
+    "https://bcr.bazel.build/modules/protobuf/29.1/MODULE.bazel": "557c3457560ff49e122ed76c0bc3397a64af9574691cb8201b4e46d4ab2ecb95",
    "https://bcr.bazel.build/modules/protobuf/3.19.0/MODULE.bazel": "6b5fbb433f760a99a22b18b6850ed5784ef0e9928a72668b66e4d7ccd47db9b0",
+    "https://bcr.bazel.build/modules/protobuf/32.1/MODULE.bazel": "89cd2866a9cb07fee9ff74c41ceace11554f32e0d849de4e23ac55515cfada4d",
+    "https://bcr.bazel.build/modules/protobuf/33.4/MODULE.bazel": "114775b816b38b6d0ca620450d6b02550c60ceedfdc8d9a229833b34a223dc42",
+    "https://bcr.bazel.build/modules/protobuf/33.4/source.json": "555f8686b4c7d6b5ba731fbea13bf656b4bfd9a7ff629c1d9d3f6e1d6155de79",
    "https://bcr.bazel.build/modules/pybind11_bazel/2.11.1/MODULE.bazel": "88af1c246226d87e65be78ed49ecd1e6f5e98648558c14ce99176da041dc378e",
-    "https://bcr.bazel.build/modules/pybind11_bazel/2.11.1/source.json": "be4789e951dd5301282729fe3d4938995dc4c1a81c2ff150afc9f1b0504c6022",
+    "https://bcr.bazel.build/modules/pybind11_bazel/2.12.0/MODULE.bazel": "e6f4c20442eaa7c90d7190d8dc539d0ab422f95c65a57cc59562170c58ae3d34",
+    "https://bcr.bazel.build/modules/pybind11_bazel/2.12.0/source.json": "6900fdc8a9e95866b8c0d4ad4aba4d4236317b5c1cd04c502df3f0d33afed680",
    "https://bcr.bazel.build/modules/re2/2023-09-01/MODULE.bazel": "cb3d511531b16cfc78a225a9e2136007a48cf8a677e4264baeab57fe78a80206",
-    "https://bcr.bazel.build/modules/re2/2023-09-01/source.json": "e044ce89c2883cd957a2969a43e79f7752f9656f6b20050b62f90ede21ec6eb4",
+    "https://bcr.bazel.build/modules/re2/2024-07-02.bcr.1/MODULE.bazel": "b4963dda9b31080be1905ef085ecd7dd6cd47c05c79b9cdf83ade83ab2ab271a",
+    "https://bcr.bazel.build/modules/re2/2024-07-02.bcr.1/source.json": "2ff292be6ef3340325ce8a045ecc326e92cbfab47c7cbab4bd85d28971b97ac4",
+    "https://bcr.bazel.build/modules/re2/2024-07-02/MODULE.bazel": "0eadc4395959969297cbcf31a249ff457f2f1d456228c67719480205aa306daa",
    "https://bcr.bazel.build/modules/rules_android/0.1.1/MODULE.bazel": "48809ab0091b07ad0182defb787c4c5328bd3a278938415c00a7b69b50c4d3a8",
    "https://bcr.bazel.build/modules/rules_android/0.1.1/source.json": "e6986b41626ee10bdc864937ffb6d6bf275bb5b9c65120e6137d56e6331f089e",
+    "https://bcr.bazel.build/modules/rules_apple/3.16.0/MODULE.bazel": "0d1caf0b8375942ce98ea944be754a18874041e4e0459401d925577624d3a54a",
+    "https://bcr.bazel.build/modules/rules_apple/4.1.0/MODULE.bazel": "76e10fd4a48038d3fc7c5dc6e63b7063bbf5304a2e3bd42edda6ec660eebea68",
+    "https://bcr.bazel.build/modules/rules_apple/4.1.0/source.json": "8ee81e1708756f81b343a5eb2b2f0b953f1d25c4ab3d4a68dc02754872e80715",
    "https://bcr.bazel.build/modules/rules_cc/0.0.1/MODULE.bazel": "cb2aa0747f84c6c3a78dad4e2049c154f08ab9d166b1273835a8174940365647",
    "https://bcr.bazel.build/modules/rules_cc/0.0.10/MODULE.bazel": "ec1705118f7eaedd6e118508d3d26deba2a4e76476ada7e0e3965211be012002",
    "https://bcr.bazel.build/modules/rules_cc/0.0.13/MODULE.bazel": "0e8529ed7b323dad0775ff924d2ae5af7640b23553dfcd4d34344c7e7a867191",
-    "https://bcr.bazel.build/modules/rules_cc/0.0.14/MODULE.bazel": "5e343a3aac88b8d7af3b1b6d2093b55c347b8eefc2e7d1442f7a02dc8fea48ac",
    "https://bcr.bazel.build/modules/rules_cc/0.0.15/MODULE.bazel": "6704c35f7b4a72502ee81f61bf88706b54f06b3cbe5558ac17e2e14666cd5dcc",
    "https://bcr.bazel.build/modules/rules_cc/0.0.16/MODULE.bazel": "7661303b8fc1b4d7f532e54e9d6565771fea666fbdf839e0a86affcd02defe87",
    "https://bcr.bazel.build/modules/rules_cc/0.0.17/MODULE.bazel": "2ae1d8f4238ec67d7185d8861cb0a2cdf4bc608697c331b95bf990e69b62e64a",
@@ -106,35 +131,37 @@
    "https://bcr.bazel.build/modules/rules_cc/0.0.8/MODULE.bazel": "964c85c82cfeb6f3855e6a07054fdb159aced38e99a5eecf7bce9d53990afa3e",
    "https://bcr.bazel.build/modules/rules_cc/0.0.9/MODULE.bazel": "836e76439f354b89afe6a911a7adf59a6b2518fafb174483ad78a2a2fde7b1c5",
    "https://bcr.bazel.build/modules/rules_cc/0.1.1/MODULE.bazel": "2f0222a6f229f0bf44cd711dc13c858dad98c62d52bd51d8fc3a764a83125513",
+    "https://bcr.bazel.build/modules/rules_cc/0.1.2/MODULE.bazel": "557ddc3a96858ec0d465a87c0a931054d7dcfd6583af2c7ed3baf494407fd8d0",
+    "https://bcr.bazel.build/modules/rules_cc/0.1.5/MODULE.bazel": "88dfc9361e8b5ae1008ac38f7cdfd45ad738e4fa676a3ad67d19204f045a1fd8",
+    "https://bcr.bazel.build/modules/rules_cc/0.2.0/MODULE.bazel": "b5c17f90458caae90d2ccd114c81970062946f49f355610ed89bebf954f5783c",
+    "https://bcr.bazel.build/modules/rules_cc/0.2.13/MODULE.bazel": "eecdd666eda6be16a8d9dc15e44b5c75133405e820f620a234acc4b1fdc5aa37",
+    "https://bcr.bazel.build/modules/rules_cc/0.2.14/MODULE.bazel": "353c99ed148887ee89c54a17d4100ae7e7e436593d104b668476019023b58df8",
    "https://bcr.bazel.build/modules/rules_cc/0.2.16/MODULE.bazel": "9242fa89f950c6ef7702801ab53922e99c69b02310c39fb6e62b2bd30df2a1d4",
    "https://bcr.bazel.build/modules/rules_cc/0.2.16/source.json": "d03d5cde49376d87e14ec14b666c56075e5e3926930327fd5d0484a1ff2ac1cc",
    "https://bcr.bazel.build/modules/rules_cc/0.2.4/MODULE.bazel": "1ff1223dfd24f3ecf8f028446d4a27608aa43c3f41e346d22838a4223980b8cc",
    "https://bcr.bazel.build/modules/rules_cc/0.2.8/MODULE.bazel": "f1df20f0bf22c28192a794f29b501ee2018fa37a3862a1a2132ae2940a23a642",
    "https://bcr.bazel.build/modules/rules_foreign_cc/0.9.0/MODULE.bazel": "c9e8c682bf75b0e7c704166d79b599f93b72cfca5ad7477df596947891feeef6",
    "https://bcr.bazel.build/modules/rules_fuzzing/0.5.2/MODULE.bazel": "40c97d1144356f52905566c55811f13b299453a14ac7769dfba2ac38192337a8",
-    "https://bcr.bazel.build/modules/rules_fuzzing/0.5.2/source.json": "c8b1e2c717646f1702290959a3302a178fb639d987ab61d548105019f11e527e",
    "https://bcr.bazel.build/modules/rules_java/4.0.0/MODULE.bazel": "5a78a7ae82cd1a33cef56dc578c7d2a46ed0dca12643ee45edbb8417899e6f74",
    "https://bcr.bazel.build/modules/rules_java/5.3.5/MODULE.bazel": "a4ec4f2db570171e3e5eb753276ee4b389bae16b96207e9d3230895c99644b86",
-    "https://bcr.bazel.build/modules/rules_java/6.0.0/MODULE.bazel": "8a43b7df601a7ec1af61d79345c17b31ea1fedc6711fd4abfd013ea612978e39",
    "https://bcr.bazel.build/modules/rules_java/6.3.0/MODULE.bazel": "a97c7678c19f236a956ad260d59c86e10a463badb7eb2eda787490f4c969b963",
-    "https://bcr.bazel.build/modules/rules_java/6.4.0/MODULE.bazel": "e986a9fe25aeaa84ac17ca093ef13a4637f6107375f64667a15999f77db6c8f6",
    "https://bcr.bazel.build/modules/rules_java/6.5.2/MODULE.bazel": "1d440d262d0e08453fa0c4d8f699ba81609ed0e9a9a0f02cd10b3e7942e61e31",
    "https://bcr.bazel.build/modules/rules_java/7.10.0/MODULE.bazel": "530c3beb3067e870561739f1144329a21c851ff771cd752a49e06e3dc9c2e71a",
    "https://bcr.bazel.build/modules/rules_java/7.12.2/MODULE.bazel": "579c505165ee757a4280ef83cda0150eea193eed3bef50b1004ba88b99da6de6",
    "https://bcr.bazel.build/modules/rules_java/7.2.0/MODULE.bazel": "06c0334c9be61e6cef2c8c84a7800cef502063269a5af25ceb100b192453d4ab",
-    "https://bcr.bazel.build/modules/rules_java/7.3.2/MODULE.bazel": "50dece891cfdf1741ea230d001aa9c14398062f2b7c066470accace78e412bc2",
    "https://bcr.bazel.build/modules/rules_java/7.6.1/MODULE.bazel": "2f14b7e8a1aa2f67ae92bc69d1ec0fa8d9f827c4e17ff5e5f02e91caa3b2d0fe",
-    "https://bcr.bazel.build/modules/rules_java/8.14.0/MODULE.bazel": "717717ed40cc69994596a45aec6ea78135ea434b8402fb91b009b9151dd65615",
-    "https://bcr.bazel.build/modules/rules_java/8.14.0/source.json": "8a88c4ca9e8759da53cddc88123880565c520503321e2566b4e33d0287a3d4bc",
+    "https://bcr.bazel.build/modules/rules_java/8.3.2/MODULE.bazel": "7336d5511ad5af0b8615fdc7477535a2e4e723a357b6713af439fe8cf0195017",
+    "https://bcr.bazel.build/modules/rules_java/8.5.1/MODULE.bazel": "d8a9e38cc5228881f7055a6079f6f7821a073df3744d441978e7a43e20226939",
    "https://bcr.bazel.build/modules/rules_java/8.6.0/MODULE.bazel": "9c064c434606d75a086f15ade5edb514308cccd1544c2b2a89bbac4310e41c71",
+    "https://bcr.bazel.build/modules/rules_java/8.6.1/MODULE.bazel": "f4808e2ab5b0197f094cabce9f4b006a27766beb6a9975931da07099560ca9c2",
+    "https://bcr.bazel.build/modules/rules_java/9.0.3/MODULE.bazel": "1f98ed015f7e744a745e0df6e898a7c5e83562d6b759dfd475c76456dda5ccea",
+    "https://bcr.bazel.build/modules/rules_java/9.0.3/source.json": "b038c0c07e12e658135bbc32cc1a2ded6e33785105c9d41958014c592de4593e",
    "https://bcr.bazel.build/modules/rules_jvm_external/4.4.2/MODULE.bazel": "a56b85e418c83eb1839819f0b515c431010160383306d13ec21959ac412d2fe7",
    "https://bcr.bazel.build/modules/rules_jvm_external/5.1/MODULE.bazel": "33f6f999e03183f7d088c9be518a63467dfd0be94a11d0055fe2d210f89aa909",
    "https://bcr.bazel.build/modules/rules_jvm_external/5.2/MODULE.bazel": "d9351ba35217ad0de03816ef3ed63f89d411349353077348a45348b096615036",
-    "https://bcr.bazel.build/modules/rules_jvm_external/5.3/MODULE.bazel": "bf93870767689637164657731849fb887ad086739bd5d360d90007a581d5527d",
-    "https://bcr.bazel.build/modules/rules_jvm_external/6.1/MODULE.bazel": "75b5fec090dbd46cf9b7d8ea08cf84a0472d92ba3585b476f44c326eda8059c4",
    "https://bcr.bazel.build/modules/rules_jvm_external/6.3/MODULE.bazel": "c998e060b85f71e00de5ec552019347c8bca255062c990ac02d051bb80a38df0",
-    "https://bcr.bazel.build/modules/rules_jvm_external/6.3/source.json": "6f5f5a5a4419ae4e37c35a5bb0a6ae657ed40b7abc5a5189111b47fcebe43197",
-    "https://bcr.bazel.build/modules/rules_kotlin/1.9.0/MODULE.bazel": "ef85697305025e5a61f395d4eaede272a5393cee479ace6686dba707de804d59",
+    "https://bcr.bazel.build/modules/rules_jvm_external/6.7/MODULE.bazel": "e717beabc4d091ecb2c803c2d341b88590e9116b8bf7947915eeb33aab4f96dd",
+    "https://bcr.bazel.build/modules/rules_jvm_external/6.7/source.json": "5426f412d0a7fc6b611643376c7e4a82dec991491b9ce5cb1cfdd25fe2e92be4",
    "https://bcr.bazel.build/modules/rules_kotlin/1.9.6/MODULE.bazel": "d269a01a18ee74d0335450b10f62c9ed81f2321d7958a2934e44272fe82dcef3",
    "https://bcr.bazel.build/modules/rules_kotlin/1.9.6/source.json": "2faa4794364282db7c06600b7e5e34867a564ae91bda7cae7c29c64e9466b7d5",
    "https://bcr.bazel.build/modules/rules_license/0.0.3/MODULE.bazel": "627e9ab0247f7d1e05736b59dbb1b6871373de5ad31c3011880b4133cafd4bd0",
@@ -150,34 +177,47 @@
    "https://bcr.bazel.build/modules/rules_platform/0.1.0/source.json": "98becf9569572719b65f639133510633eb3527fb37d347d7ef08447f3ebcf1c9",
    "https://bcr.bazel.build/modules/rules_proto/4.0.0/MODULE.bazel": "a7a7b6ce9bee418c1a760b3d84f83a299ad6952f9903c67f19e4edd964894e06",
    "https://bcr.bazel.build/modules/rules_proto/5.3.0-21.7/MODULE.bazel": "e8dff86b0971688790ae75528fe1813f71809b5afd57facb44dad9e8eca631b7",
+    "https://bcr.bazel.build/modules/rules_proto/6.0.0-rc1/MODULE.bazel": "1e5b502e2e1a9e825eef74476a5a1ee524a92297085015a052510b09a1a09483",
    "https://bcr.bazel.build/modules/rules_proto/6.0.2/MODULE.bazel": "ce916b775a62b90b61888052a416ccdda405212b6aaeb39522f7dc53431a5e73",
-    "https://bcr.bazel.build/modules/rules_proto/7.0.2/MODULE.bazel": "bf81793bd6d2ad89a37a40693e56c61b0ee30f7a7fdbaf3eabbf5f39de47dea2",
-    "https://bcr.bazel.build/modules/rules_proto/7.0.2/source.json": "1e5e7260ae32ef4f2b52fd1d0de8d03b606a44c91b694d2f1afb1d3b28a48ce1",
+    "https://bcr.bazel.build/modules/rules_proto/7.1.0/MODULE.bazel": "002d62d9108f75bb807cd56245d45648f38275cb3a99dcd45dfb864c5d74cb96",
+    "https://bcr.bazel.build/modules/rules_proto/7.1.0/source.json": "39f89066c12c24097854e8f57ab8558929f9c8d474d34b2c00ac04630ad8940e",
    "https://bcr.bazel.build/modules/rules_python/0.10.2/MODULE.bazel": "cc82bc96f2997baa545ab3ce73f196d040ffb8756fd2d66125a530031cd90e5f",
    "https://bcr.bazel.build/modules/rules_python/0.23.1/MODULE.bazel": "49ffccf0511cb8414de28321f5fcf2a31312b47c40cc21577144b7447f2bf300",
    "https://bcr.bazel.build/modules/rules_python/0.25.0/MODULE.bazel": "72f1506841c920a1afec76975b35312410eea3aa7b63267436bfb1dd91d2d382",
    "https://bcr.bazel.build/modules/rules_python/0.28.0/MODULE.bazel": "cba2573d870babc976664a912539b320cbaa7114cd3e8f053c720171cde331ed",
    "https://bcr.bazel.build/modules/rules_python/0.31.0/MODULE.bazel": "93a43dc47ee570e6ec9f5779b2e64c1476a6ce921c48cc9a1678a91dd5f8fd58",
+    "https://bcr.bazel.build/modules/rules_python/0.33.2/MODULE.bazel": "3e036c4ad8d804a4dad897d333d8dce200d943df4827cb849840055be8d2e937",
    "https://bcr.bazel.build/modules/rules_python/0.4.0/MODULE.bazel": "9208ee05fd48bf09ac60ed269791cf17fb343db56c8226a720fbb1cdf467166c",
-    "https://bcr.bazel.build/modules/rules_python/0.40.0/MODULE.bazel": "9d1a3cd88ed7d8e39583d9ffe56ae8a244f67783ae89b60caafc9f5cf318ada7",
-    "https://bcr.bazel.build/modules/rules_python/0.40.0/source.json": "939d4bd2e3110f27bfb360292986bb79fd8dcefb874358ccd6cdaa7bda029320",
+    "https://bcr.bazel.build/modules/rules_python/1.3.0/MODULE.bazel": "8361d57eafb67c09b75bf4bbe6be360e1b8f4f18118ab48037f2bd50aa2ccb13",
+    "https://bcr.bazel.build/modules/rules_python/1.4.1/MODULE.bazel": "8991ad45bdc25018301d6b7e1d3626afc3c8af8aaf4bc04f23d0b99c938b73a6",
+    "https://bcr.bazel.build/modules/rules_python/1.6.0/MODULE.bazel": "7e04ad8f8d5bea40451cf80b1bd8262552aa73f841415d20db96b7241bd027d8",
+    "https://bcr.bazel.build/modules/rules_python/1.7.0/MODULE.bazel": "d01f995ecd137abf30238ad9ce97f8fc3ac57289c8b24bd0bf53324d937a14f8",
+    "https://bcr.bazel.build/modules/rules_python/1.7.0/source.json": "028a084b65dcf8f4dc4f82f8778dbe65df133f234b316828a82e060d81bdce32",
    "https://bcr.bazel.build/modules/rules_rs/0.0.23/MODULE.bazel": "2e7ae2044105b1873a451c628713329d6746493f677b371f9d8063fd06a00937",
    "https://bcr.bazel.build/modules/rules_rs/0.0.23/source.json": "1149e7f599f2e41e9e9de457f9c4deb3d219a4fec967cea30557d02ede88037e",
    "https://bcr.bazel.build/modules/rules_rust/0.66.0/MODULE.bazel": "86ef763a582f4739a27029bdcc6c562258ed0ea6f8d58294b049e215ceb251b3",
    "https://bcr.bazel.build/modules/rules_rust/0.68.1/MODULE.bazel": "8d3332ef4079673385eb81f8bd68b012decc04ac00c9d5a01a40eff90301732c",
    "https://bcr.bazel.build/modules/rules_rust/0.68.1/source.json": "3378e746f81b62457fdfd37391244fa8ff075ba85c05931ee4f3a20ac1efe963",
    "https://bcr.bazel.build/modules/rules_shell/0.2.0/MODULE.bazel": "fda8a652ab3c7d8fee214de05e7a9916d8b28082234e8d2c0094505c5268ed3c",
+    "https://bcr.bazel.build/modules/rules_shell/0.3.0/MODULE.bazel": "de4402cd12f4cc8fda2354fce179fdb068c0b9ca1ec2d2b17b3e21b24c1a937b",
    "https://bcr.bazel.build/modules/rules_shell/0.4.0/MODULE.bazel": "0f8f11bb3cd11755f0b48c1de0bbcf62b4b34421023aa41a2fc74ef68d9584f0",
    "https://bcr.bazel.build/modules/rules_shell/0.4.1/MODULE.bazel": "00e501db01bbf4e3e1dd1595959092c2fadf2087b2852d3f553b5370f5633592",
    "https://bcr.bazel.build/modules/rules_shell/0.6.1/MODULE.bazel": "72e76b0eea4e81611ef5452aa82b3da34caca0c8b7b5c0c9584338aa93bae26b",
    "https://bcr.bazel.build/modules/rules_shell/0.6.1/source.json": "20ec05cd5e592055e214b2da8ccb283c7f2a421ea0dc2acbf1aa792e11c03d0c",
+    "https://bcr.bazel.build/modules/rules_swift/1.16.0/MODULE.bazel": "4a09f199545a60d09895e8281362b1ff3bb08bbde69c6fc87aff5b92fcc916ca",
+    "https://bcr.bazel.build/modules/rules_swift/2.1.1/MODULE.bazel": "494900a80f944fc7aa61500c2073d9729dff0b764f0e89b824eb746959bc1046",
+    "https://bcr.bazel.build/modules/rules_swift/2.4.0/MODULE.bazel": "1639617eb1ede28d774d967a738b4a68b0accb40650beadb57c21846beab5efd",
+    "https://bcr.bazel.build/modules/rules_swift/3.1.2/MODULE.bazel": "72c8f5cf9d26427cee6c76c8e3853eb46ce6b0412a081b2b6db6e8ad56267400",
+    "https://bcr.bazel.build/modules/rules_swift/3.1.2/source.json": "e85761f3098a6faf40b8187695e3de6d97944e98abd0d8ce579cb2daf6319a66",
    "https://bcr.bazel.build/modules/stardoc/0.5.1/MODULE.bazel": "1a05d92974d0c122f5ccf09291442580317cdd859f07a8655f1db9a60374f9f8",
    "https://bcr.bazel.build/modules/stardoc/0.5.3/MODULE.bazel": "c7f6948dae6999bf0db32c1858ae345f112cacf98f174c7a8bb707e41b974f1c",
-    "https://bcr.bazel.build/modules/stardoc/0.5.6/MODULE.bazel": "c43dabc564990eeab55e25ed61c07a1aadafe9ece96a4efabb3f8bf9063b71ef",
    "https://bcr.bazel.build/modules/stardoc/0.6.2/MODULE.bazel": "7060193196395f5dd668eda046ccbeacebfd98efc77fed418dbe2b82ffaa39fd",
    "https://bcr.bazel.build/modules/stardoc/0.7.0/MODULE.bazel": "05e3d6d30c099b6770e97da986c53bd31844d7f13d41412480ea265ac9e8079c",
-    "https://bcr.bazel.build/modules/stardoc/0.7.1/MODULE.bazel": "3548faea4ee5dda5580f9af150e79d0f6aea934fc60c1cc50f4efdd9420759e7",
-    "https://bcr.bazel.build/modules/stardoc/0.7.1/source.json": "b6500ffcd7b48cd72c29bb67bcac781e12701cc0d6d55d266a652583cfcdab01",
+    "https://bcr.bazel.build/modules/stardoc/0.7.2/MODULE.bazel": "fc152419aa2ea0f51c29583fab1e8c99ddefd5b3778421845606ee628629e0e5",
+    "https://bcr.bazel.build/modules/stardoc/0.7.2/source.json": "58b029e5e901d6802967754adf0a9056747e8176f017cfe3607c0851f4d42216",
+    "https://bcr.bazel.build/modules/swift_argument_parser/1.3.1.1/MODULE.bazel": "5e463fbfba7b1701d957555ed45097d7f984211330106ccd1352c6e0af0dcf91",
+    "https://bcr.bazel.build/modules/swift_argument_parser/1.3.1.2/MODULE.bazel": "75aab2373a4bbe2a1260b9bf2a1ebbdbf872d3bd36f80bff058dccd82e89422f",
+    "https://bcr.bazel.build/modules/swift_argument_parser/1.3.1.2/source.json": "5fba48bbe0ba48761f9e9f75f92876cafb5d07c0ce059cc7a8027416de94a05b",
    "https://bcr.bazel.build/modules/tar.bzl/0.2.1/MODULE.bazel": "52d1c00a80a8cc67acbd01649e83d8dd6a9dc426a6c0b754a04fe8c219c76468",
    "https://bcr.bazel.build/modules/tar.bzl/0.6.0/MODULE.bazel": "a3584b4edcfafcabd9b0ef9819808f05b372957bbdff41601429d5fd0aac2e7c",
    "https://bcr.bazel.build/modules/tar.bzl/0.6.0/source.json": "4a620381df075a16cb3a7ed57bd1d05f7480222394c64a20fa51bdb636fda658",
@@ -197,9 +237,10 @@
      "general": {
        "bzlTransitiveDigest": "dnnhvKMf9MIXMulhbhHBblZdDAfAkiSVjApIXpUz9Y8=",
        "usagesDigest": "dPuxg6asjUidjHZi+xFfMiW+r9RawVYGjTZnOeP+fLI=",
-        "recordedFileInputs": {},
-        "recordedDirentsInputs": {},
-        "envVariables": {},
+        "recordedInputs": [
+          "REPO_MAPPING:aspect_tools_telemetry+,bazel_lib bazel_lib+",
+          "REPO_MAPPING:aspect_tools_telemetry+,bazel_skylib bazel_skylib+"
+        ],
        "generatedRepoSpecs": {
          "aspect_tools_telemetry_report": {
            "repoRuleId": "@@aspect_tools_telemetry+//:extension.bzl%tel_repository",
@@ -246,83 +287,7 @@
              }
            }
          }
-        },
-        "recordedRepoMappingEntries": [
-          [
-            "aspect_tools_telemetry+",
-            "bazel_lib",
-            "bazel_lib+"
-          ],
-          [
-            "aspect_tools_telemetry+",
-            "bazel_skylib",
-            "bazel_skylib+"
-          ]
-        ]
-      }
-    },
-    "@@rules_kotlin+//src/main/starlark/core/repositories:bzlmod_setup.bzl%rules_kotlin_extensions": {
-      "general": {
-        "bzlTransitiveDigest": "rL/34P1aFDq2GqVC2zCFgQ8nTuOC6ziogocpvG50Qz8=",
-        "usagesDigest": "QI2z8ZUR+mqtbwsf2fLqYdJAkPOHdOV+tF2yVAUgRzw=",
-        "recordedFileInputs": {},
-        "recordedDirentsInputs": {},
-        "envVariables": {},
-        "generatedRepoSpecs": {
-          "com_github_jetbrains_kotlin_git": {
-            "repoRuleId": "@@rules_kotlin+//src/main/starlark/core/repositories:compiler.bzl%kotlin_compiler_git_repository",
-            "attributes": {
-              "urls": [
-                "https://github.com/JetBrains/kotlin/releases/download/v1.9.23/kotlin-compiler-1.9.23.zip"
-              ],
-              "sha256": "93137d3aab9afa9b27cb06a824c2324195c6b6f6179d8a8653f440f5bd58be88"
-            }
-          },
-          "com_github_jetbrains_kotlin": {
-            "repoRuleId": "@@rules_kotlin+//src/main/starlark/core/repositories:compiler.bzl%kotlin_capabilities_repository",
-            "attributes": {
-              "git_repository_name": "com_github_jetbrains_kotlin_git",
-              "compiler_version": "1.9.23"
-            }
-          },
-          "com_github_google_ksp": {
-            "repoRuleId": "@@rules_kotlin+//src/main/starlark/core/repositories:ksp.bzl%ksp_compiler_plugin_repository",
-            "attributes": {
-              "urls": [
-                "https://github.com/google/ksp/releases/download/1.9.23-1.0.20/artifacts.zip"
-              ],
-              "sha256": "ee0618755913ef7fd6511288a232e8fad24838b9af6ea73972a76e81053c8c2d",
-              "strip_version": "1.9.23-1.0.20"
-            }
-          },
-          "com_github_pinterest_ktlint": {
-            "repoRuleId": "@@bazel_tools//tools/build_defs/repo:http.bzl%http_file",
-            "attributes": {
-              "sha256": "01b2e0ef893383a50dbeb13970fe7fa3be36ca3e83259e01649945b09d736985",
-              "urls": [
-                "https://github.com/pinterest/ktlint/releases/download/1.3.0/ktlint"
-              ],
-              "executable": true
-            }
-          },
-          "rules_android": {
-            "repoRuleId": "@@bazel_tools//tools/build_defs/repo:http.bzl%http_archive",
-            "attributes": {
-              "sha256": "cd06d15dd8bb59926e4d65f9003bfc20f9da4b2519985c27e190cddc8b7a7806",
-              "strip_prefix": "rules_android-0.1.1",
-              "urls": [
-                "https://github.com/bazelbuild/rules_android/archive/v0.1.1.zip"
-              ]
-            }
-          }
-        },
-        "recordedRepoMappingEntries": [
-          [
-            "rules_kotlin+",
-            "bazel_tools",
-            "bazel_tools"
-          ]
-        ]
+        }
      }
    }
  },
--- a/codex-rs/core/config.schema.json
+++ b/codex-rs/core/config.schema.json
@@ -4,6 +4,14 @@
  "description": "Base config deserialized from ~/.codex/config.toml.",
  "type": "object",
  "properties": {
+    "agents": {
+      "description": "Agent-related settings (thread limits, etc.).",
+      "allOf": [
+        {
+          "$ref": "#/definitions/AgentsToml"
+        }
+      ]
+    },
    "analytics": {
      "description": "When `false`, disables analytics across Codex product surfaces in this machine. Defaults to `true`.",
      "allOf": [
@@ -436,6 +444,18 @@
      "description": "A path that is guaranteed to be absolute and normalized (though it is not guaranteed to be canonicalized or exist on the filesystem).\n\nIMPORTANT: When deserializing an `AbsolutePathBuf`, a base path must be set using [AbsolutePathBufGuard::new]. If no base path is set, the deserialization will fail unless the path being deserialized is already absolute.",
      "type": "string"
    },
+    "AgentsToml": {
+      "type": "object",
+      "properties": {
+        "max_threads": {
+          "description": "Maximum number of agent threads that can be open concurrently. When unset, no limit is enforced.",
+          "type": "integer",
+          "format": "uint",
+          "minimum": 1.0
+        }
+      },
+      "additionalProperties": false
+    },
    "AltScreenMode": {
      "description": "Controls whether the TUI uses the terminal's alternate screen buffer.\n\n**Background:** The alternate screen buffer provides a cleaner fullscreen experience without polluting the terminal's scrollback history. However, it conflicts with terminal multiplexers like Zellij that strictly follow the xterm specification, which defines that alternate screen buffers should not have scrollback.\n\n**Zellij's behavior:** Zellij intentionally disables scrollback in alternate screen mode (see https://github.com/zellij-org/zellij/pull/1032) to comply with the xterm spec. This is by design and not configurable in Zellij—there is no option to enable scrollback in alternate screen mode.\n\n**Solution:** This setting provides a pragmatic workaround: - `auto` (default): Automatically detect the terminal multiplexer. If running in Zellij, disable alternate screen to preserve scrollback. Enable it everywhere else. - `always`: Always use alternate screen mode (original behavior before this fix). - `never`: Never use alternate screen mode. Runs in inline mode, preserving scrollback in all multiplexers.\n\nThe CLI flag `--no-alt-screen` can override this setting at runtime.",
      "oneOf": [
--- a/codex-rs/core/src/agent/control.rs
+++ b/codex-rs/core/src/agent/control.rs
@@ -1,4 +1,5 @@
 use crate::agent::AgentStatus;
+use crate::agent::guards::Guards;
 use crate::error::CodexErr;
 use crate::error::Result as CodexResult;
 use crate::thread_manager::ThreadManagerState;
@@ -12,18 +13,25 @@ use tokio::sync::watch;
 /// Control-plane handle for multi-agent operations.
 /// `AgentControl` is held by each session (via `SessionServices`). It provides capability to
 /// spawn new agents and the inter-agent communication layer.
+/// An `AgentControl` instance is shared per "user session" which means the same `AgentControl`
+/// is used for every sub-agent spawned by Codex. By doing so, we make sure the guards are
+/// scoped to a user session.
 #[derive(Clone, Default)]
 pub(crate) struct AgentControl {
    /// Weak handle back to the global thread registry/state.
    /// This is `Weak` to avoid reference cycles and shadow persistence of the form
    /// `ThreadManagerState -> CodexThread -> Session -> SessionServices -> ThreadManagerState`.
    manager: Weak<ThreadManagerState>,
+    state: Arc<Guards>,
 }

 impl AgentControl {
    /// Construct a new `AgentControl` that can spawn/message agents via the given manager state.
    pub(crate) fn new(manager: Weak<ThreadManagerState>) -> Self {
-        Self { manager }
+        Self {
+            manager,
+            ..Default::default()
+        }
    }

    /// Spawn a new agent thread and submit the initial prompt.
@@ -33,7 +41,11 @@ impl AgentControl {
        prompt: String,
    ) -> CodexResult<ThreadId> {
        let state = self.upgrade()?;
+        let reservation = self.state.reserve_spawn_slot(config.agent_max_threads)?;
+
+        // The same `AgentControl` is sent to spawn the thread.
        let new_thread = state.spawn_new_thread(config, self.clone()).await?;
+        reservation.commit(new_thread.thread_id);

        // Notify a new thread has been created. This notification will be processed by clients
        // to subscribe or drain this newly created thread.
@@ -67,6 +79,7 @@ impl AgentControl {
            .await;
        if matches!(result, Err(CodexErr::InternalAgentDied)) {
            let _ = state.remove_thread(&agent_id).await;
+            self.state.release_spawned_thread(agent_id);
        }
        result
    }
@@ -82,6 +95,7 @@ impl AgentControl {
        let state = self.upgrade()?;
        let result = state.send_op(agent_id, Op::Shutdown {}).await;
        let _ = state.remove_thread(&agent_id).await;
+        self.state.release_spawned_thread(agent_id);
        result
    }

@@ -132,17 +146,25 @@ mod tests {
    use codex_protocol::protocol::TurnStartedEvent;
    use pretty_assertions::assert_eq;
    use tempfile::TempDir;
+    use toml::Value as TomlValue;

-    async fn test_config() -> (TempDir, Config) {
+    async fn test_config_with_cli_overrides(
+        cli_overrides: Vec<(String, TomlValue)>,
+    ) -> (TempDir, Config) {
        let home = TempDir::new().expect("create temp dir");
        let config = ConfigBuilder::default()
            .codex_home(home.path().to_path_buf())
+            .cli_overrides(cli_overrides)
            .build()
            .await
            .expect("load default test config");
        (home, config)
    }

+    async fn test_config() -> (TempDir, Config) {
+        test_config_with_cli_overrides(Vec::new()).await
+    }
+
    struct AgentControlHarness {
        _home: TempDir,
        config: Config,
@@ -373,4 +395,117 @@ mod tests {
            .find(|entry| *entry == expected);
        assert_eq!(captured, Some(expected));
    }
+
+    #[tokio::test]
+    async fn spawn_agent_respects_max_threads_limit() {
+        let max_threads = 1usize;
+        let (_home, config) = test_config_with_cli_overrides(vec![(
+            "agents.max_threads".to_string(),
+            TomlValue::Integer(max_threads as i64),
+        )])
+        .await;
+        let manager = ThreadManager::with_models_provider_and_home(
+            CodexAuth::from_api_key("dummy"),
+            config.model_provider.clone(),
+            config.codex_home.clone(),
+        );
+        let control = manager.agent_control();
+
+        let _ = manager
+            .start_thread(config.clone())
+            .await
+            .expect("start thread");
+
+        let first_agent_id = control
+            .spawn_agent(config.clone(), "hello".to_string())
+            .await
+            .expect("spawn_agent should succeed");
+
+        let err = control
+            .spawn_agent(config, "hello again".to_string())
+            .await
+            .expect_err("spawn_agent should respect max threads");
+        let CodexErr::AgentLimitReached {
+            max_threads: seen_max_threads,
+        } = err
+        else {
+            panic!("expected CodexErr::AgentLimitReached");
+        };
+        assert_eq!(seen_max_threads, max_threads);
+
+        let _ = control
+            .shutdown_agent(first_agent_id)
+            .await
+            .expect("shutdown agent");
+    }
+
+    #[tokio::test]
+    async fn spawn_agent_releases_slot_after_shutdown() {
+        let max_threads = 1usize;
+        let (_home, config) = test_config_with_cli_overrides(vec![(
+            "agents.max_threads".to_string(),
+            TomlValue::Integer(max_threads as i64),
+        )])
+        .await;
+        let manager = ThreadManager::with_models_provider_and_home(
+            CodexAuth::from_api_key("dummy"),
+            config.model_provider.clone(),
+            config.codex_home.clone(),
+        );
+        let control = manager.agent_control();
+
+        let first_agent_id = control
+            .spawn_agent(config.clone(), "hello".to_string())
+            .await
+            .expect("spawn_agent should succeed");
+        let _ = control
+            .shutdown_agent(first_agent_id)
+            .await
+            .expect("shutdown agent");
+
+        let second_agent_id = control
+            .spawn_agent(config.clone(), "hello again".to_string())
+            .await
+            .expect("spawn_agent should succeed after shutdown");
+        let _ = control
+            .shutdown_agent(second_agent_id)
+            .await
+            .expect("shutdown agent");
+    }
+
+    #[tokio::test]
+    async fn spawn_agent_limit_shared_across_clones() {
+        let max_threads = 1usize;
+        let (_home, config) = test_config_with_cli_overrides(vec![(
+            "agents.max_threads".to_string(),
+            TomlValue::Integer(max_threads as i64),
+        )])
+        .await;
+        let manager = ThreadManager::with_models_provider_and_home(
+            CodexAuth::from_api_key("dummy"),
+            config.model_provider.clone(),
+            config.codex_home.clone(),
+        );
+        let control = manager.agent_control();
+        let cloned = control.clone();
+
+        let first_agent_id = cloned
+            .spawn_agent(config.clone(), "hello".to_string())
+            .await
+            .expect("spawn_agent should succeed");
+
+        let err = control
+            .spawn_agent(config, "hello again".to_string())
+            .await
+            .expect_err("spawn_agent should respect shared guard");
+        let CodexErr::AgentLimitReached { max_threads } = err else {
+            panic!("expected CodexErr::AgentLimitReached");
+        };
+        assert_eq!(max_threads, 1);
+
+        let _ = control
+            .shutdown_agent(first_agent_id)
+            .await
+            .expect("shutdown agent");
+    }
 }
--- a/codex-rs/core/src/agent/guards.rs
+++ b/codex-rs/core/src/agent/guards.rs
@@ -0,0 +1,193 @@
+use crate::error::CodexErr;
+use crate::error::Result;
+use codex_protocol::ThreadId;
+use std::collections::HashSet;
+use std::sync::Arc;
+use std::sync::Mutex;
+use std::sync::atomic::AtomicUsize;
+use std::sync::atomic::Ordering;
+
+/// This structure is used to add some limits on the multi-agent capabilities for Codex. In
+/// the current implementation, it limits:
+/// * Total number of sub-agents (i.e. threads) per user session
+///
+/// This structure is shared by all agents in the same user session (because the `AgentControl`
+/// is).
+#[derive(Default)]
+pub(crate) struct Guards {
+    threads_set: Mutex<HashSet<ThreadId>>,
+    total_count: AtomicUsize,
+}
+
+impl Guards {
+    pub(crate) fn reserve_spawn_slot(
+        self: &Arc<Self>,
+        max_threads: Option<usize>,
+    ) -> Result<SpawnReservation> {
+        if let Some(max_threads) = max_threads {
+            if !self.try_increment_spawned(max_threads) {
+                return Err(CodexErr::AgentLimitReached { max_threads });
+            }
+        } else {
+            self.total_count.fetch_add(1, Ordering::AcqRel);
+        }
+        Ok(SpawnReservation {
+            state: Arc::clone(self),
+            active: true,
+        })
+    }
+
+    pub(crate) fn release_spawned_thread(&self, thread_id: ThreadId) {
+        let removed = {
+            let mut threads = self
+                .threads_set
+                .lock()
+                .unwrap_or_else(std::sync::PoisonError::into_inner);
+            threads.remove(&thread_id)
+        };
+        if removed {
+            self.total_count.fetch_sub(1, Ordering::AcqRel);
+        }
+    }
+
+    fn register_spawned_thread(&self, thread_id: ThreadId) {
+        let mut threads = self
+            .threads_set
+            .lock()
+            .unwrap_or_else(std::sync::PoisonError::into_inner);
+        threads.insert(thread_id);
+    }
+
+    fn try_increment_spawned(&self, max_threads: usize) -> bool {
+        let mut current = self.total_count.load(Ordering::Acquire);
+        loop {
+            if current >= max_threads {
+                return false;
+            }
+            match self.total_count.compare_exchange_weak(
+                current,
+                current + 1,
+                Ordering::AcqRel,
+                Ordering::Acquire,
+            ) {
+                Ok(_) => return true,
+                Err(updated) => current = updated,
+            }
+        }
+    }
+}
+
+pub(crate) struct SpawnReservation {
+    state: Arc<Guards>,
+    active: bool,
+}
+
+impl SpawnReservation {
+    pub(crate) fn commit(mut self, thread_id: ThreadId) {
+        self.state.register_spawned_thread(thread_id);
+        self.active = false;
+    }
+}
+
+impl Drop for SpawnReservation {
+    fn drop(&mut self) {
+        if self.active {
+            self.state.total_count.fetch_sub(1, Ordering::AcqRel);
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use pretty_assertions::assert_eq;
+
+    #[test]
+    fn reservation_drop_releases_slot() {
+        let guards = Arc::new(Guards::default());
+        let reservation = guards.reserve_spawn_slot(Some(1)).expect("reserve slot");
+        drop(reservation);
+
+        let reservation = guards.reserve_spawn_slot(Some(1)).expect("slot released");
+        drop(reservation);
+    }
+
+    #[test]
+    fn commit_holds_slot_until_release() {
+        let guards = Arc::new(Guards::default());
+        let reservation = guards.reserve_spawn_slot(Some(1)).expect("reserve slot");
+        let thread_id = ThreadId::new();
+        reservation.commit(thread_id);
+
+        let err = match guards.reserve_spawn_slot(Some(1)) {
+            Ok(_) => panic!("limit should be enforced"),
+            Err(err) => err,
+        };
+        let CodexErr::AgentLimitReached { max_threads } = err else {
+            panic!("expected CodexErr::AgentLimitReached");
+        };
+        assert_eq!(max_threads, 1);
+
+        guards.release_spawned_thread(thread_id);
+        let reservation = guards
+            .reserve_spawn_slot(Some(1))
+            .expect("slot released after thread removal");
+        drop(reservation);
+    }
+
+    #[test]
+    fn release_ignores_unknown_thread_id() {
+        let guards = Arc::new(Guards::default());
+        let reservation = guards.reserve_spawn_slot(Some(1)).expect("reserve slot");
+        let thread_id = ThreadId::new();
+        reservation.commit(thread_id);
+
+        guards.release_spawned_thread(ThreadId::new());
+
+        let err = match guards.reserve_spawn_slot(Some(1)) {
+            Ok(_) => panic!("limit should still be enforced"),
+            Err(err) => err,
+        };
+        let CodexErr::AgentLimitReached { max_threads } = err else {
+            panic!("expected CodexErr::AgentLimitReached");
+        };
+        assert_eq!(max_threads, 1);
+
+        guards.release_spawned_thread(thread_id);
+        let reservation = guards
+            .reserve_spawn_slot(Some(1))
+            .expect("slot released after real thread removal");
+        drop(reservation);
+    }
+
+    #[test]
+    fn release_is_idempotent_for_registered_threads() {
+        let guards = Arc::new(Guards::default());
+        let reservation = guards.reserve_spawn_slot(Some(1)).expect("reserve slot");
+        let first_id = ThreadId::new();
+        reservation.commit(first_id);
+
+        guards.release_spawned_thread(first_id);
+
+        let reservation = guards.reserve_spawn_slot(Some(1)).expect("slot reused");
+        let second_id = ThreadId::new();
+        reservation.commit(second_id);
+
+        guards.release_spawned_thread(first_id);
+
+        let err = match guards.reserve_spawn_slot(Some(1)) {
+            Ok(_) => panic!("limit should still be enforced"),
+            Err(err) => err,
+        };
+        let CodexErr::AgentLimitReached { max_threads } = err else {
+            panic!("expected CodexErr::AgentLimitReached");
+        };
+        assert_eq!(max_threads, 1);
+
+        guards.release_spawned_thread(second_id);
+        let reservation = guards
+            .reserve_spawn_slot(Some(1))
+            .expect("slot released after second thread removal");
+        drop(reservation);
+    }
+}
--- a/codex-rs/core/src/agent/mod.rs
+++ b/codex-rs/core/src/agent/mod.rs
@@ -1,4 +1,6 @@
 pub(crate) mod control;
+// Do not put in `pub` or `pub(crate)`. This code should not be used somewhere else.
+mod guards;
 pub(crate) mod role;
 pub(crate) mod status;

--- a/codex-rs/core/src/codex.rs
+++ b/codex-rs/core/src/codex.rs
@@ -723,18 +723,12 @@ impl Session {
        let mut default_shell = shell::default_user_shell();
        // Create the mutable state for the Session.
        if config.features.enabled(Feature::ShellSnapshot) {
-            let timer = otel_manager.start_timer("codex.shell_snapshot.duration_ms", &[]);
-            default_shell.shell_snapshot =
-                ShellSnapshot::try_new(&config.codex_home, conversation_id, &default_shell)
-                    .await
-                    .map(Arc::new);
-            let success = if default_shell.shell_snapshot.is_some() {
-                "true"
-            } else {
-                "false"
-            };
-            let _ = timer.map(|timer| timer.record(&[("success", success)]));
-            otel_manager.counter("codex.shell_snapshot", 1, &[("success", success)])
+            ShellSnapshot::start_snapshotting(
+                config.codex_home.clone(),
+                conversation_id,
+                &mut default_shell,
+                otel_manager.clone(),
+            );
        }
        let state = SessionState::new(session_configuration.clone());

@@ -2576,7 +2570,7 @@ mod handlers {
            .filter(|item| is_user_turn_boundary(item))
            .count();
        sess.services.otel_manager.counter(
-            "conversation.turn.count",
+            "codex.conversation.turn.count",
            i64::try_from(turn_count).unwrap_or(0),
            &[],
        );
--- a/codex-rs/core/src/config/mod.rs
+++ b/codex-rs/core/src/config/mod.rs
@@ -89,6 +89,7 @@ pub use codex_git::GhostSnapshotConfig;
 /// files are *silently truncated* to this size so we do not take up too much of
 /// the context window.
 pub(crate) const PROJECT_DOC_MAX_BYTES: usize = 32 * 1024; // 32 KiB
+pub(crate) const DEFAULT_AGENT_MAX_THREADS: Option<usize> = None;

 pub const CONFIG_TOML_FILE: &str = "config.toml";

@@ -299,6 +300,9 @@ pub struct Config {
    /// Token budget applied when storing tool/function outputs in the context manager.
    pub tool_output_token_limit: Option<usize>,

+    /// Maximum number of agent threads that can be open concurrently.
+    pub agent_max_threads: Option<usize>,
+
    /// Directory containing all Codex state (defaults to `~/.codex` but can be
    /// overridden by the `CODEX_HOME` environment variable).
    pub codex_home: PathBuf,
@@ -924,6 +928,9 @@ pub struct ConfigToml {
    /// Nested tools section for feature toggles
    pub tools: Option<ToolsToml>,

+    /// Agent-related settings (thread limits, etc.).
+    pub agents: Option<AgentsToml>,
+
    /// User-level skill config entries keyed by SKILL.md path.
    pub skills: Option<SkillsConfig>,

@@ -1033,6 +1040,15 @@ pub struct ToolsToml {
    pub view_image: Option<bool>,
 }

+#[derive(Serialize, Deserialize, Debug, Clone, Default, PartialEq, Eq, JsonSchema)]
+#[schemars(deny_unknown_fields)]
+pub struct AgentsToml {
+    /// Maximum number of agent threads that can be open concurrently.
+    /// When unset, no limit is enforced.
+    #[schemars(range(min = 1))]
+    pub max_threads: Option<usize>,
+}
+
 impl From<ToolsToml> for Tools {
    fn from(tools_toml: ToolsToml) -> Self {
        Self {
@@ -1392,6 +1408,18 @@ impl Config {

        let history = cfg.history.unwrap_or_default();

+        let agent_max_threads = cfg
+            .agents
+            .as_ref()
+            .and_then(|agents| agents.max_threads)
+            .or(DEFAULT_AGENT_MAX_THREADS);
+        if agent_max_threads == Some(0) {
+            return Err(std::io::Error::new(
+                std::io::ErrorKind::InvalidInput,
+                "agents.max_threads must be at least 1",
+            ));
+        }
+
        let ghost_snapshot = {
            let mut config = GhostSnapshotConfig::default();
            if let Some(ghost_snapshot) = cfg.ghost_snapshot.as_ref()
@@ -1530,6 +1558,7 @@ impl Config {
                })
                .collect(),
            tool_output_token_limit: cfg.tool_output_token_limit,
+            agent_max_threads,
            codex_home,
            config_layer_stack,
            history,
@@ -2508,11 +2537,19 @@ profile = "project"
        )?;

        assert!(config.features.enabled(Feature::ApplyPatchFreeform));
-        assert!(config.features.enabled(Feature::UnifiedExec));
+        if cfg!(target_os = "windows") {
+            assert!(!config.features.enabled(Feature::UnifiedExec));
+        } else {
+            assert!(config.features.enabled(Feature::UnifiedExec));
+        }

        assert!(config.include_apply_patch_tool);

-        assert!(config.use_experimental_unified_exec_tool);
+        if cfg!(target_os = "windows") {
+            assert!(!config.use_experimental_unified_exec_tool);
+        } else {
+            assert!(config.use_experimental_unified_exec_tool);
+        }

        Ok(())
    }
@@ -3718,6 +3755,7 @@ model_verbosity = "high"
                project_doc_max_bytes: PROJECT_DOC_MAX_BYTES,
                project_doc_fallback_filenames: Vec::new(),
                tool_output_token_limit: None,
+                agent_max_threads: None,
                codex_home: fixture.codex_home(),
                config_layer_stack: Default::default(),
                history: History::default(),
@@ -3806,6 +3844,7 @@ model_verbosity = "high"
            project_doc_max_bytes: PROJECT_DOC_MAX_BYTES,
            project_doc_fallback_filenames: Vec::new(),
            tool_output_token_limit: None,
+            agent_max_threads: None,
            codex_home: fixture.codex_home(),
            config_layer_stack: Default::default(),
            history: History::default(),
@@ -3909,6 +3948,7 @@ model_verbosity = "high"
            project_doc_max_bytes: PROJECT_DOC_MAX_BYTES,
            project_doc_fallback_filenames: Vec::new(),
            tool_output_token_limit: None,
+            agent_max_threads: None,
            codex_home: fixture.codex_home(),
            config_layer_stack: Default::default(),
            history: History::default(),
@@ -3998,6 +4038,7 @@ model_verbosity = "high"
            project_doc_max_bytes: PROJECT_DOC_MAX_BYTES,
            project_doc_fallback_filenames: Vec::new(),
            tool_output_token_limit: None,
+            agent_max_threads: None,
            codex_home: fixture.codex_home(),
            config_layer_stack: Default::default(),
            history: History::default(),
--- a/codex-rs/core/src/environment_context.rs
+++ b/codex-rs/core/src/environment_context.rs
@@ -95,7 +95,7 @@ mod tests {
        Shell {
            shell_type: ShellType::Bash,
            shell_path: PathBuf::from("/bin/bash"),
-            shell_snapshot: None,
+            shell_snapshot: crate::shell::empty_shell_snapshot_receiver(),
        }
    }

@@ -189,7 +189,7 @@ mod tests {
            Shell {
                shell_type: ShellType::Bash,
                shell_path: "/bin/bash".into(),
-                shell_snapshot: None,
+                shell_snapshot: crate::shell::empty_shell_snapshot_receiver(),
            },
        );
        let context2 = EnvironmentContext::new(
@@ -197,7 +197,7 @@ mod tests {
            Shell {
                shell_type: ShellType::Zsh,
                shell_path: "/bin/zsh".into(),
-                shell_snapshot: None,
+                shell_snapshot: crate::shell::empty_shell_snapshot_receiver(),
            },
        );

--- a/codex-rs/core/src/error.rs
+++ b/codex-rs/core/src/error.rs
@@ -78,6 +78,9 @@ pub enum CodexErr {
    #[error("no thread with id: {0}")]
    ThreadNotFound(ThreadId),

+    #[error("agent thread limit reached (max {max_threads})")]
+    AgentLimitReached { max_threads: usize },
+
    #[error("session configured event was not the first event in the stream")]
    SessionConfiguredNotFirstEvent,

@@ -199,6 +202,7 @@ impl CodexErr {
            | CodexErr::RetryLimit(_)
            | CodexErr::ContextWindowExceeded
            | CodexErr::ThreadNotFound(_)
+            | CodexErr::AgentLimitReached { .. }
            | CodexErr::Spawn
            | CodexErr::SessionConfiguredNotFirstEvent
            | CodexErr::UsageLimitReached(_) => false,
@@ -497,9 +501,9 @@ impl CodexErr {
            CodexErr::SessionConfiguredNotFirstEvent
            | CodexErr::InternalServerError
            | CodexErr::InternalAgentDied => CodexErrorInfo::InternalServerError,
-            CodexErr::UnsupportedOperation(_) | CodexErr::ThreadNotFound(_) => {
-                CodexErrorInfo::BadRequest
-            }
+            CodexErr::UnsupportedOperation(_)
+            | CodexErr::ThreadNotFound(_)
+            | CodexErr::AgentLimitReached { .. } => CodexErrorInfo::BadRequest,
            CodexErr::Sandbox(_) => CodexErrorInfo::SandboxError,
            _ => CodexErrorInfo::Other,
        }
--- a/codex-rs/core/src/features.rs
+++ b/codex-rs/core/src/features.rs
@@ -182,6 +182,9 @@ impl Features {
    }

    pub fn enable(&mut self, f: Feature) -> &mut Self {
+        if cfg!(target_os = "windows") && f == Feature::UnifiedExec {
+            return self;
+        }
        self.enabled.insert(f);
        self
    }
--- a/codex-rs/core/src/shell.rs
+++ b/codex-rs/core/src/shell.rs
@@ -1,9 +1,9 @@
+use crate::shell_snapshot::ShellSnapshot;
 use serde::Deserialize;
 use serde::Serialize;
 use std::path::PathBuf;
 use std::sync::Arc;
-
-use crate::shell_snapshot::ShellSnapshot;
+use tokio::sync::watch;

 #[derive(Debug, PartialEq, Eq, Clone, Serialize, Deserialize)]
 pub enum ShellType {
@@ -14,12 +14,16 @@ pub enum ShellType {
    Cmd,
 }

-#[derive(Debug, PartialEq, Eq, Clone, Serialize, Deserialize)]
+#[derive(Debug, Clone, Serialize, Deserialize)]
 pub struct Shell {
    pub(crate) shell_type: ShellType,
    pub(crate) shell_path: PathBuf,
-    #[serde(skip_serializing, skip_deserializing, default)]
-    pub(crate) shell_snapshot: Option<Arc<ShellSnapshot>>,
+    #[serde(
+        skip_serializing,
+        skip_deserializing,
+        default = "empty_shell_snapshot_receiver"
+    )]
+    pub(crate) shell_snapshot: watch::Receiver<Option<Arc<ShellSnapshot>>>,
 }

 impl Shell {
@@ -63,8 +67,26 @@ impl Shell {
            }
        }
    }
+
+    /// Return the shell snapshot if existing.
+    pub fn shell_snapshot(&self) -> Option<Arc<ShellSnapshot>> {
+        self.shell_snapshot.borrow().clone()
+    }
 }

+pub(crate) fn empty_shell_snapshot_receiver() -> watch::Receiver<Option<Arc<ShellSnapshot>>> {
+    let (_tx, rx) = watch::channel(None);
+    rx
+}
+
+impl PartialEq for Shell {
+    fn eq(&self, other: &Self) -> bool {
+        self.shell_type == other.shell_type && self.shell_path == other.shell_path
+    }
+}
+
+impl Eq for Shell {}
+
 #[cfg(unix)]
 fn get_user_shell_path() -> Option<PathBuf> {
    use libc::getpwuid;
@@ -139,7 +161,7 @@ fn get_zsh_shell(path: Option<&PathBuf>) -> Option<Shell> {
    shell_path.map(|shell_path| Shell {
        shell_type: ShellType::Zsh,
        shell_path,
-        shell_snapshot: None,
+        shell_snapshot: empty_shell_snapshot_receiver(),
    })
 }

@@ -149,7 +171,7 @@ fn get_bash_shell(path: Option<&PathBuf>) -> Option<Shell> {
    shell_path.map(|shell_path| Shell {
        shell_type: ShellType::Bash,
        shell_path,
-        shell_snapshot: None,
+        shell_snapshot: empty_shell_snapshot_receiver(),
    })
 }

@@ -159,7 +181,7 @@ fn get_sh_shell(path: Option<&PathBuf>) -> Option<Shell> {
    shell_path.map(|shell_path| Shell {
        shell_type: ShellType::Sh,
        shell_path,
-        shell_snapshot: None,
+        shell_snapshot: empty_shell_snapshot_receiver(),
    })
 }

@@ -175,7 +197,7 @@ fn get_powershell_shell(path: Option<&PathBuf>) -> Option<Shell> {
    shell_path.map(|shell_path| Shell {
        shell_type: ShellType::PowerShell,
        shell_path,
-        shell_snapshot: None,
+        shell_snapshot: empty_shell_snapshot_receiver(),
    })
 }

@@ -185,7 +207,7 @@ fn get_cmd_shell(path: Option<&PathBuf>) -> Option<Shell> {
    shell_path.map(|shell_path| Shell {
        shell_type: ShellType::Cmd,
        shell_path,
-        shell_snapshot: None,
+        shell_snapshot: empty_shell_snapshot_receiver(),
    })
 }

@@ -194,13 +216,13 @@ fn ultimate_fallback_shell() -> Shell {
        Shell {
            shell_type: ShellType::Cmd,
            shell_path: PathBuf::from("cmd.exe"),
-            shell_snapshot: None,
+            shell_snapshot: empty_shell_snapshot_receiver(),
        }
    } else {
        Shell {
            shell_type: ShellType::Sh,
            shell_path: PathBuf::from("/bin/sh"),
-            shell_snapshot: None,
+            shell_snapshot: empty_shell_snapshot_receiver(),
        }
    }
 }
@@ -426,7 +448,7 @@ mod tests {
        let test_bash_shell = Shell {
            shell_type: ShellType::Bash,
            shell_path: PathBuf::from("/bin/bash"),
-            shell_snapshot: None,
+            shell_snapshot: empty_shell_snapshot_receiver(),
        };
        assert_eq!(
            test_bash_shell.derive_exec_args("echo hello", false),
@@ -440,7 +462,7 @@ mod tests {
        let test_zsh_shell = Shell {
            shell_type: ShellType::Zsh,
            shell_path: PathBuf::from("/bin/zsh"),
-            shell_snapshot: None,
+            shell_snapshot: empty_shell_snapshot_receiver(),
        };
        assert_eq!(
            test_zsh_shell.derive_exec_args("echo hello", false),
@@ -454,7 +476,7 @@ mod tests {
        let test_powershell_shell = Shell {
            shell_type: ShellType::PowerShell,
            shell_path: PathBuf::from("pwsh.exe"),
-            shell_snapshot: None,
+            shell_snapshot: empty_shell_snapshot_receiver(),
        };
        assert_eq!(
            test_powershell_shell.derive_exec_args("echo hello", false),
@@ -481,7 +503,7 @@ mod tests {
                Shell {
                    shell_type: ShellType::Zsh,
                    shell_path: PathBuf::from(shell_path),
-                    shell_snapshot: None,
+                    shell_snapshot: empty_shell_snapshot_receiver(),
                }
            );
        }
--- a/codex-rs/core/src/shell_snapshot.rs
+++ b/codex-rs/core/src/shell_snapshot.rs
@@ -1,6 +1,7 @@
 use std::io::ErrorKind;
 use std::path::Path;
 use std::path::PathBuf;
+use std::sync::Arc;
 use std::time::Duration;
 use std::time::SystemTime;

@@ -12,9 +13,11 @@ use anyhow::Context;
 use anyhow::Result;
 use anyhow::anyhow;
 use anyhow::bail;
+use codex_otel::OtelManager;
 use codex_protocol::ThreadId;
 use tokio::fs;
 use tokio::process::Command;
+use tokio::sync::watch;
 use tokio::time::timeout;

 #[derive(Clone, Debug, PartialEq, Eq)]
@@ -27,7 +30,31 @@ const SNAPSHOT_RETENTION: Duration = Duration::from_secs(60 * 60 * 24 * 7); // 7
 const SNAPSHOT_DIR: &str = "shell_snapshots";

 impl ShellSnapshot {
-    pub async fn try_new(codex_home: &Path, session_id: ThreadId, shell: &Shell) -> Option<Self> {
+    pub fn start_snapshotting(
+        codex_home: PathBuf,
+        session_id: ThreadId,
+        shell: &mut Shell,
+        otel_manager: OtelManager,
+    ) {
+        let (shell_snapshot_tx, shell_snapshot_rx) = watch::channel(None);
+        shell.shell_snapshot = shell_snapshot_rx;
+
+        let snapshot_shell = shell.clone();
+        let snapshot_session_id = session_id;
+        tokio::spawn(async move {
+            let timer = otel_manager.start_timer("codex.shell_snapshot.duration_ms", &[]);
+            let snapshot =
+                ShellSnapshot::try_new(&codex_home, snapshot_session_id, &snapshot_shell)
+                    .await
+                    .map(Arc::new);
+            let success = if snapshot.is_some() { "true" } else { "false" };
+            let _ = timer.map(|timer| timer.record(&[("success", success)]));
+            otel_manager.counter("codex.shell_snapshot", 1, &[("success", success)]);
+            let _ = shell_snapshot_tx.send(snapshot);
+        });
+    }
+
+    async fn try_new(codex_home: &Path, session_id: ThreadId, shell: &Shell) -> Option<Self> {
        // File to store the snapshot
        let extension = match shell.shell_type {
            ShellType::PowerShell => "ps1",
@@ -74,7 +101,7 @@ impl Drop for ShellSnapshot {
    }
 }

-pub async fn write_shell_snapshot(shell_type: ShellType, output_path: &Path) -> Result<PathBuf> {
+async fn write_shell_snapshot(shell_type: ShellType, output_path: &Path) -> Result<PathBuf> {
    if shell_type == ShellType::PowerShell || shell_type == ShellType::Cmd {
        bail!("Shell snapshot not supported yet for {shell_type:?}");
    }
@@ -407,7 +434,7 @@ mod tests {
        let shell = Shell {
            shell_type: ShellType::Bash,
            shell_path: PathBuf::from("/bin/bash"),
-            shell_snapshot: None,
+            shell_snapshot: crate::shell::empty_shell_snapshot_receiver(),
        };

        let snapshot = ShellSnapshot::try_new(dir.path(), ThreadId::new(), &shell)
@@ -449,7 +476,7 @@ mod tests {
        let shell = Shell {
            shell_type: ShellType::Sh,
            shell_path,
-            shell_snapshot: None,
+            shell_snapshot: crate::shell::empty_shell_snapshot_receiver(),
        };

        let err = run_shell_script_with_timeout(&shell, "ignored", Duration::from_millis(500))
--- a/codex-rs/core/src/tasks/user_shell.rs
+++ b/codex-rs/core/src/tasks/user_shell.rs
@@ -76,14 +76,15 @@ impl SessionTask for UserShellCommandTask {
        // We do not source rc files or otherwise reformat the script.
        let use_login_shell = true;
        let session_shell = session.user_shell();
-        let command = session_shell.derive_exec_args(&self.command, use_login_shell);
-        let command = maybe_wrap_shell_lc_with_snapshot(&command, session_shell.as_ref());
+        let display_command = session_shell.derive_exec_args(&self.command, use_login_shell);
+        let exec_command =
+            maybe_wrap_shell_lc_with_snapshot(&display_command, session_shell.as_ref());

        let call_id = Uuid::new_v4().to_string();
        let raw_command = self.command.clone();
        let cwd = turn_context.cwd.clone();

-        let parsed_cmd = parse_command(&command);
+        let parsed_cmd = parse_command(&display_command);
        session
            .send_event(
                turn_context.as_ref(),
@@ -91,7 +92,7 @@ impl SessionTask for UserShellCommandTask {
                    call_id: call_id.clone(),
                    process_id: None,
                    turn_id: turn_context.sub_id.clone(),
-                    command: command.clone(),
+                    command: display_command.clone(),
                    cwd: cwd.clone(),
                    parsed_cmd: parsed_cmd.clone(),
                    source: ExecCommandSource::UserShell,
@@ -101,7 +102,7 @@ impl SessionTask for UserShellCommandTask {
            .await;

        let exec_env = ExecEnv {
-            command: command.clone(),
+            command: exec_command.clone(),
            cwd: cwd.clone(),
            env: create_env(&turn_context.shell_environment_policy),
            // TODO(zhao-oai): Now that we have ExecExpiration::Cancellation, we
@@ -150,7 +151,7 @@ impl SessionTask for UserShellCommandTask {
                            call_id,
                            process_id: None,
                            turn_id: turn_context.sub_id.clone(),
-                            command: command.clone(),
+                            command: display_command.clone(),
                            cwd: cwd.clone(),
                            parsed_cmd: parsed_cmd.clone(),
                            source: ExecCommandSource::UserShell,
@@ -173,7 +174,7 @@ impl SessionTask for UserShellCommandTask {
                            call_id: call_id.clone(),
                            process_id: None,
                            turn_id: turn_context.sub_id.clone(),
-                            command: command.clone(),
+                            command: display_command.clone(),
                            cwd: cwd.clone(),
                            parsed_cmd: parsed_cmd.clone(),
                            source: ExecCommandSource::UserShell,
@@ -218,7 +219,7 @@ impl SessionTask for UserShellCommandTask {
                            call_id,
                            process_id: None,
                            turn_id: turn_context.sub_id.clone(),
-                            command,
+                            command: display_command,
                            cwd,
                            parsed_cmd,
                            source: ExecCommandSource::UserShell,
--- a/codex-rs/core/src/thread_manager.rs
+++ b/codex-rs/core/src/thread_manager.rs
@@ -366,7 +366,8 @@ impl ThreadManagerState {
            codex,
            session_configured.rollout_path.clone(),
        ));
-        self.threads.write().await.insert(thread_id, thread.clone());
+        let mut threads = self.threads.write().await;
+        threads.insert(thread_id, thread.clone());

        Ok(NewThread {
            thread_id,
--- a/codex-rs/core/src/tools/handlers/shell.rs
+++ b/codex-rs/core/src/tools/handlers/shell.rs
@@ -305,6 +305,7 @@ mod tests {
    use crate::shell::ShellType;
    use crate::shell_snapshot::ShellSnapshot;
    use crate::tools::handlers::ShellCommandHandler;
+    use tokio::sync::watch;

    /// The logic for is_known_safe_command() has heuristics for known shells,
    /// so we must ensure the commands generated by [ShellCommandHandler] can be
@@ -314,14 +315,14 @@ mod tests {
        let bash_shell = Shell {
            shell_type: ShellType::Bash,
            shell_path: PathBuf::from("/bin/bash"),
-            shell_snapshot: None,
+            shell_snapshot: crate::shell::empty_shell_snapshot_receiver(),
        };
        assert_safe(&bash_shell, "ls -la");

        let zsh_shell = Shell {
            shell_type: ShellType::Zsh,
            shell_path: PathBuf::from("/bin/zsh"),
-            shell_snapshot: None,
+            shell_snapshot: crate::shell::empty_shell_snapshot_receiver(),
        };
        assert_safe(&zsh_shell, "ls -la");

@@ -329,7 +330,7 @@ mod tests {
            let powershell = Shell {
                shell_type: ShellType::PowerShell,
                shell_path: path.to_path_buf(),
-                shell_snapshot: None,
+                shell_snapshot: crate::shell::empty_shell_snapshot_receiver(),
            };
            assert_safe(&powershell, "ls -Name");
        }
@@ -338,7 +339,7 @@ mod tests {
            let pwsh = Shell {
                shell_type: ShellType::PowerShell,
                shell_path: path.to_path_buf(),
-                shell_snapshot: None,
+                shell_snapshot: crate::shell::empty_shell_snapshot_receiver(),
            };
            assert_safe(&pwsh, "ls -Name");
        }
@@ -391,12 +392,13 @@ mod tests {

    #[test]
    fn shell_command_handler_respects_explicit_login_flag() {
+        let (_tx, shell_snapshot) = watch::channel(Some(Arc::new(ShellSnapshot {
+            path: PathBuf::from("/tmp/snapshot.sh"),
+        })));
        let shell = Shell {
            shell_type: ShellType::Bash,
            shell_path: PathBuf::from("/bin/bash"),
-            shell_snapshot: Some(Arc::new(ShellSnapshot {
-                path: PathBuf::from("/tmp/snapshot.sh"),
-            })),
+            shell_snapshot,
        };

        let login_command =
--- a/codex-rs/core/src/tools/handlers/unified_exec.rs
+++ b/codex-rs/core/src/tools/handlers/unified_exec.rs
@@ -236,7 +236,7 @@ impl ToolHandler for UnifiedExecHandler {
 fn get_command(args: &ExecCommandArgs, session_shell: Arc<Shell>) -> Vec<String> {
    let model_shell = args.shell.as_ref().map(|shell_str| {
        let mut shell = get_shell_by_model_provided_path(&PathBuf::from(shell_str));
-        shell.shell_snapshot = None;
+        shell.shell_snapshot = crate::shell::empty_shell_snapshot_receiver();
        shell
    });

--- a/codex-rs/core/src/tools/runtimes/mod.rs
+++ b/codex-rs/core/src/tools/runtimes/mod.rs
@@ -54,7 +54,7 @@ pub(crate) fn maybe_wrap_shell_lc_with_snapshot(
    command: &[String],
    session_shell: &Shell,
 ) -> Vec<String> {
-    let Some(snapshot) = &session_shell.shell_snapshot else {
+    let Some(snapshot) = session_shell.shell_snapshot() else {
        return command.to_vec();
    };

--- a/codex-rs/core/tests/suite/shell_snapshot.rs
+++ b/codex-rs/core/tests/suite/shell_snapshot.rs
@@ -20,9 +20,11 @@ use core_test_support::wait_for_event;
 use core_test_support::wait_for_event_match;
 use pretty_assertions::assert_eq;
 use serde_json::json;
+use std::path::Path;
 use std::path::PathBuf;
 use tokio::fs;
 use tokio::time::Duration;
+use tokio::time::Instant;
 use tokio::time::sleep;

 #[derive(Debug)]
@@ -34,6 +36,24 @@ struct SnapshotRun {
    codex_home: PathBuf,
 }

+async fn wait_for_snapshot(codex_home: &Path) -> Result<PathBuf> {
+    let snapshot_dir = codex_home.join("shell_snapshots");
+    let deadline = Instant::now() + Duration::from_secs(5);
+    loop {
+        if let Ok(mut entries) = fs::read_dir(&snapshot_dir).await
+            && let Some(entry) = entries.next_entry().await?
+        {
+            return Ok(entry.path());
+        }
+
+        if Instant::now() >= deadline {
+            anyhow::bail!("timed out waiting for shell snapshot");
+        }
+
+        sleep(Duration::from_millis(25)).await;
+    }
+}
+
 #[allow(clippy::expect_used)]
 async fn run_snapshot_command(command: &str) -> Result<SnapshotRun> {
    let builder = test_codex().with_config(|config| {
@@ -89,12 +109,7 @@ async fn run_snapshot_command(command: &str) -> Result<SnapshotRun> {
        _ => None,
    })
    .await;
-    let mut entries = fs::read_dir(codex_home.join("shell_snapshots")).await?;
-    let snapshot_path = entries
-        .next_entry()
-        .await?
-        .map(|entry| entry.path())
-        .expect("shell snapshot created");
+    let snapshot_path = wait_for_snapshot(&codex_home).await?;
    let snapshot_content = fs::read_to_string(&snapshot_path).await?;

    let end = wait_for_event_match(&codex, |ev| match ev {
@@ -167,12 +182,7 @@ async fn run_shell_command_snapshot(command: &str) -> Result<SnapshotRun> {
        _ => None,
    })
    .await;
-    let mut entries = fs::read_dir(codex_home.join("shell_snapshots")).await?;
-    let snapshot_path = entries
-        .next_entry()
-        .await?
-        .map(|entry| entry.path())
-        .expect("shell snapshot created");
+    let snapshot_path = wait_for_snapshot(&codex_home).await?;
    let snapshot_content = fs::read_to_string(&snapshot_path).await?;

    let end = wait_for_event_match(&codex, |ev| match ev {
@@ -305,12 +315,7 @@ async fn shell_command_snapshot_still_intercepts_apply_patch() -> Result<()> {

    assert_eq!(fs::read_to_string(&target).await?, "hello from snapshot\n");

-    let mut entries = fs::read_dir(codex_home.join("shell_snapshots")).await?;
-    let snapshot_path = entries
-        .next_entry()
-        .await?
-        .map(|entry| entry.path())
-        .expect("shell snapshot created");
+    let snapshot_path = wait_for_snapshot(&codex_home).await?;
    let snapshot_content = fs::read_to_string(&snapshot_path).await?;
    assert_posix_snapshot_sections(&snapshot_content);

@@ -328,12 +333,7 @@ async fn shell_snapshot_deleted_after_shutdown_with_skills() -> Result<()> {
    let codex_home = home.path().to_path_buf();
    let codex = harness.test().codex.clone();

-    let mut entries = fs::read_dir(codex_home.join("shell_snapshots")).await?;
-    let snapshot_path = entries
-        .next_entry()
-        .await?
-        .map(|entry| entry.path())
-        .expect("shell snapshot created");
+    let snapshot_path = wait_for_snapshot(&codex_home).await?;
    assert!(snapshot_path.exists());

    codex.submit(Op::Shutdown {}).await?;
--- a/codex-rs/tui/src/app.rs
+++ b/codex-rs/tui/src/app.rs
@@ -961,6 +961,24 @@ impl App {
                            .submit_op(Op::PatchApproval { id, decision });
                    }
                }
+                Op::UserInputAnswer { id, response } => {
+                    if let Some((thread_id, original_id)) =
+                        self.external_approval_routes.remove(&id)
+                    {
+                        self.forward_external_op(
+                            thread_id,
+                            Op::UserInputAnswer {
+                                id: original_id,
+                                response,
+                            },
+                        )
+                        .await;
+                        self.finish_external_approval();
+                    } else {
+                        self.chat_widget
+                            .submit_op(Op::UserInputAnswer { id, response });
+                    }
+                }
                // Standard path where this is not an external approval response.
                _ => self.chat_widget.submit_op(op),
            },
@@ -1465,6 +1483,14 @@ impl App {
    /// can be routed back to the correct thread.
    fn handle_external_approval_request(&mut self, thread_id: ThreadId, mut event: Event) {
        match &mut event.msg {
+            EventMsg::RequestUserInput(ev) => {
+                let original_id = ev.turn_id.clone();
+                let routing_id = format!("{thread_id}:{original_id}");
+                self.external_approval_routes
+                    .insert(routing_id.clone(), (thread_id, original_id));
+                ev.turn_id = routing_id.clone();
+                event.id = routing_id;
+            }
            EventMsg::ExecApprovalRequest(_) | EventMsg::ApplyPatchApprovalRequest(_) => {
                let original_id = event.id.clone();
                let routing_id = format!("{thread_id}:{original_id}");
@@ -1517,7 +1543,9 @@ impl App {
                    }
                };
                match event.msg {
-                    EventMsg::ExecApprovalRequest(_) | EventMsg::ApplyPatchApprovalRequest(_) => {
+                    EventMsg::ExecApprovalRequest(_)
+                    | EventMsg::ApplyPatchApprovalRequest(_)
+                    | EventMsg::RequestUserInput(_) => {
                        app_event_tx.send(AppEvent::ExternalApprovalRequest { thread_id, event });
                    }
                    _ => {}
--- a/codex-rs/tui/src/bottom_pane/bottom_pane_view.rs
+++ b/codex-rs/tui/src/bottom_pane/bottom_pane_view.rs
@@ -1,5 +1,6 @@
 use crate::bottom_pane::ApprovalRequest;
 use crate::render::renderable::Renderable;
+use codex_protocol::request_user_input::RequestUserInputEvent;
 use crossterm::event::KeyEvent;

 use super::CancellationEvent;
@@ -34,4 +35,13 @@ pub(crate) trait BottomPaneView: Renderable {
    ) -> Option<ApprovalRequest> {
        Some(request)
    }
+
+    /// Try to handle request_user_input; return the original value if not
+    /// consumed.
+    fn try_consume_user_input_request(
+        &mut self,
+        request: RequestUserInputEvent,
+    ) -> Option<RequestUserInputEvent> {
+        Some(request)
+    }
 }
--- a/codex-rs/tui/src/bottom_pane/mod.rs
+++ b/codex-rs/tui/src/bottom_pane/mod.rs
@@ -28,6 +28,7 @@ use bottom_pane_view::BottomPaneView;
 use codex_core::features::Features;
 use codex_core::skills::model::SkillMetadata;
 use codex_file_search::FileMatch;
+use codex_protocol::request_user_input::RequestUserInputEvent;
 use codex_protocol::user_input::TextElement;
 use crossterm::event::KeyCode;
 use crossterm::event::KeyEvent;
@@ -37,8 +38,10 @@ use ratatui::text::Line;
 use std::time::Duration;

 mod approval_overlay;
+mod request_user_input;
 pub(crate) use approval_overlay::ApprovalOverlay;
 pub(crate) use approval_overlay::ApprovalRequest;
+pub(crate) use request_user_input::RequestUserInputOverlay;
 mod bottom_pane_view;

 #[derive(Clone, Debug, PartialEq, Eq)]
@@ -612,8 +615,32 @@ impl BottomPane {
        self.push_view(Box::new(modal));
    }

+    /// Called when the agent requests user input.
+    pub fn push_user_input_request(&mut self, request: RequestUserInputEvent) {
+        let request = if let Some(view) = self.view_stack.last_mut() {
+            match view.try_consume_user_input_request(request) {
+                Some(request) => request,
+                None => {
+                    self.request_redraw();
+                    return;
+                }
+            }
+        } else {
+            request
+        };
+
+        let modal = RequestUserInputOverlay::new(request, self.app_event_tx.clone());
+        self.pause_status_timer_for_modal();
+        self.set_composer_input_enabled(
+            false,
+            Some("Answer the questions to continue.".to_string()),
+        );
+        self.push_view(Box::new(modal));
+    }
+
    fn on_active_view_complete(&mut self) {
        self.resume_status_timer_after_modal();
+        self.set_composer_input_enabled(true, None);
    }

    fn pause_status_timer_for_modal(&mut self) {
--- a/codex-rs/tui/src/bottom_pane/request_user_input/layout.rs
+++ b/codex-rs/tui/src/bottom_pane/request_user_input/layout.rs
@@ -0,0 +1,151 @@
+use ratatui::layout::Rect;
+
+use super::RequestUserInputOverlay;
+
+pub(super) struct LayoutSections {
+    pub(super) progress_area: Rect,
+    pub(super) header_area: Rect,
+    pub(super) question_area: Rect,
+    pub(super) answer_title_area: Rect,
+    // Wrapped question text lines to render in the question area.
+    pub(super) question_lines: Vec<String>,
+    pub(super) options_area: Rect,
+    pub(super) notes_title_area: Rect,
+    pub(super) notes_area: Rect,
+    // Number of footer rows (status + hints).
+    pub(super) footer_lines: u16,
+}
+
+impl RequestUserInputOverlay {
+    /// Compute layout sections, collapsing notes and hints as space shrinks.
+    pub(super) fn layout_sections(&self, area: Rect) -> LayoutSections {
+        let question_lines = self
+            .current_question()
+            .map(|q| {
+                textwrap::wrap(&q.question, area.width.max(1) as usize)
+                    .into_iter()
+                    .map(|line| line.to_string())
+                    .collect::<Vec<_>>()
+            })
+            .unwrap_or_default();
+        let question_text_height = question_lines.len() as u16;
+        let has_options = self.has_options();
+        let mut notes_input_height = self.notes_input_height(area.width);
+        // Keep the question + options visible first; notes and hints collapse as space shrinks.
+        let footer_lines = if self.unanswered_count() > 0 { 2 } else { 1 };
+        let mut notes_title_height = if has_options { 1 } else { 0 };
+
+        let mut cursor_y = area.y;
+        let progress_area = Rect {
+            x: area.x,
+            y: cursor_y,
+            width: area.width,
+            height: 1,
+        };
+        cursor_y = cursor_y.saturating_add(1);
+        let header_area = Rect {
+            x: area.x,
+            y: cursor_y,
+            width: area.width,
+            height: 1,
+        };
+        cursor_y = cursor_y.saturating_add(1);
+        let question_area = Rect {
+            x: area.x,
+            y: cursor_y,
+            width: area.width,
+            height: question_text_height,
+        };
+        cursor_y = cursor_y.saturating_add(question_text_height);
+        // Remaining height after progress/header/question areas.
+        let remaining = area.height.saturating_sub(cursor_y.saturating_sub(area.y));
+        let mut answer_title_height = if has_options { 1 } else { 0 };
+        let mut options_height = 0;
+        if has_options {
+            let remaining_content = remaining.saturating_sub(footer_lines);
+            let options_len = self.options_len() as u16;
+            if remaining_content == 0 {
+                answer_title_height = 0;
+                notes_title_height = 0;
+                notes_input_height = 0;
+                options_height = 0;
+            } else {
+                let min_notes = 1u16;
+                let full_notes = 3u16;
+                // Prefer to keep all options visible, then allocate notes height.
+                if remaining_content
+                    >= options_len + answer_title_height + notes_title_height + full_notes
+                {
+                    let max_notes = remaining_content
+                        .saturating_sub(options_len)
+                        .saturating_sub(answer_title_height)
+                        .saturating_sub(notes_title_height);
+                    notes_input_height = notes_input_height.min(max_notes).max(full_notes);
+                } else if remaining_content > options_len + answer_title_height + min_notes {
+                    notes_title_height = 0;
+                    notes_input_height = min_notes;
+                } else {
+                    // Tight layout: hide section titles and shrink notes to one line.
+                    answer_title_height = 0;
+                    notes_title_height = 0;
+                    notes_input_height = min_notes;
+                }
+
+                // Reserve notes/answer title area so options are scrollable if needed.
+                let reserved = answer_title_height
+                    .saturating_add(notes_title_height)
+                    .saturating_add(notes_input_height);
+                options_height = remaining_content.saturating_sub(reserved);
+            }
+        } else {
+            let max_notes = remaining.saturating_sub(footer_lines);
+            if max_notes == 0 {
+                notes_input_height = 0;
+            } else {
+                // When no options exist, notes are the primary input.
+                notes_input_height = notes_input_height.min(max_notes).max(3.min(max_notes));
+            }
+        }
+
+        let answer_title_area = Rect {
+            x: area.x,
+            y: cursor_y,
+            width: area.width,
+            height: answer_title_height,
+        };
+        cursor_y = cursor_y.saturating_add(answer_title_height);
+        let options_area = Rect {
+            x: area.x,
+            y: cursor_y,
+            width: area.width,
+            height: options_height,
+        };
+        cursor_y = cursor_y.saturating_add(options_height);
+
+        let notes_title_area = Rect {
+            x: area.x,
+            y: cursor_y,
+            width: area.width,
+            height: notes_title_height,
+        };
+        cursor_y = cursor_y.saturating_add(notes_title_height);
+        let notes_area = Rect {
+            x: area.x,
+            y: cursor_y,
+            width: area.width,
+            height: notes_input_height,
+        };
+
+        LayoutSections {
+            progress_area,
+            header_area,
+            question_area,
+            answer_title_area,
+            question_lines,
+            options_area,
+            notes_title_area,
+            notes_area,
+            footer_lines,
+        }
+    }
+}
--- a/codex-rs/tui/src/bottom_pane/request_user_input/mod.rs
+++ b/codex-rs/tui/src/bottom_pane/request_user_input/mod.rs
@@ -0,0 +1,770 @@
+//! Request-user-input overlay state machine.
+//!
+//! Core behaviors:
+//! - Each question can be answered by selecting one option and/or providing notes.
+//! - When options exist, notes are stored per selected option (notes become "other").
+//! - Typing while focused on options jumps into notes to keep freeform input fast.
+//! - Enter advances to the next question; the last question submits all answers.
+//! - Freeform-only questions submit "skipped" when empty.
+use std::cell::RefCell;
+use std::collections::HashMap;
+use std::collections::VecDeque;
+
+use crossterm::event::KeyCode;
+use crossterm::event::KeyEvent;
+use crossterm::event::KeyEventKind;
+mod layout;
+mod render;
+
+use crate::app_event::AppEvent;
+use crate::app_event_sender::AppEventSender;
+use crate::bottom_pane::CancellationEvent;
+use crate::bottom_pane::bottom_pane_view::BottomPaneView;
+use crate::bottom_pane::scroll_state::ScrollState;
+use crate::bottom_pane::textarea::TextArea;
+use crate::bottom_pane::textarea::TextAreaState;
+
+use codex_core::protocol::Op;
+use codex_protocol::request_user_input::RequestUserInputAnswer;
+use codex_protocol::request_user_input::RequestUserInputEvent;
+use codex_protocol::request_user_input::RequestUserInputResponse;
+
+const NOTES_PLACEHOLDER: &str = "Add notes (optional)";
+const ANSWER_PLACEHOLDER: &str = "Type your answer (optional)";
+const SELECT_OPTION_PLACEHOLDER: &str = "Select an option to add notes (optional)";
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+enum Focus {
+    Options,
+    Notes,
+}
+
+struct NotesEntry {
+    text: TextArea,
+    state: RefCell<TextAreaState>,
+}
+
+impl NotesEntry {
+    fn new() -> Self {
+        Self {
+            text: TextArea::new(),
+            state: RefCell::new(TextAreaState::default()),
+        }
+    }
+}
+
+struct AnswerState {
+    // Final selection for the question (always set for option questions).
+    selected: Option<usize>,
+    // Scrollable cursor state for option navigation/highlight.
+    option_state: ScrollState,
+    // Notes for freeform-only questions.
+    notes: NotesEntry,
+    // Per-option notes for option questions.
+    option_notes: Vec<NotesEntry>,
+}
+
+pub(crate) struct RequestUserInputOverlay {
+    app_event_tx: AppEventSender,
+    request: RequestUserInputEvent,
+    // Queue of incoming requests to process after the current one.
+    queue: VecDeque<RequestUserInputEvent>,
+    answers: Vec<AnswerState>,
+    current_idx: usize,
+    focus: Focus,
+    done: bool,
+}
+
+impl RequestUserInputOverlay {
+    pub(crate) fn new(request: RequestUserInputEvent, app_event_tx: AppEventSender) -> Self {
+        let mut overlay = Self {
+            app_event_tx,
+            request,
+            queue: VecDeque::new(),
+            answers: Vec::new(),
+            current_idx: 0,
+            focus: Focus::Options,
+            done: false,
+        };
+        overlay.reset_for_request();
+        overlay.ensure_focus_available();
+        overlay
+    }
+
+    fn current_index(&self) -> usize {
+        self.current_idx
+    }
+
+    fn current_question(
+        &self,
+    ) -> Option<&codex_protocol::request_user_input::RequestUserInputQuestion> {
+        self.request.questions.get(self.current_index())
+    }
+
+    fn current_answer_mut(&mut self) -> Option<&mut AnswerState> {
+        let idx = self.current_index();
+        self.answers.get_mut(idx)
+    }
+
+    fn current_answer(&self) -> Option<&AnswerState> {
+        let idx = self.current_index();
+        self.answers.get(idx)
+    }
+
+    fn question_count(&self) -> usize {
+        self.request.questions.len()
+    }
+
+    fn has_options(&self) -> bool {
+        self.current_question()
+            .and_then(|question| question.options.as_ref())
+            .is_some_and(|options| !options.is_empty())
+    }
+
+    fn options_len(&self) -> usize {
+        self.current_question()
+            .and_then(|question| question.options.as_ref())
+            .map(std::vec::Vec::len)
+            .unwrap_or(0)
+    }
+
+    fn selected_option_index(&self) -> Option<usize> {
+        if !self.has_options() {
+            return None;
+        }
+        self.current_answer()
+            .and_then(|answer| answer.selected.or(answer.option_state.selected_idx))
+    }
+
+    fn current_option_label(&self) -> Option<&str> {
+        let idx = self.selected_option_index()?;
+        self.current_question()
+            .and_then(|question| question.options.as_ref())
+            .and_then(|options| options.get(idx))
+            .map(|option| option.label.as_str())
+    }
+
+    fn current_notes_entry(&self) -> Option<&NotesEntry> {
+        let answer = self.current_answer()?;
+        if !self.has_options() {
+            return Some(&answer.notes);
+        }
+        let idx = self
+            .selected_option_index()
+            .or(answer.option_state.selected_idx)?;
+        answer.option_notes.get(idx)
+    }
+
+    fn current_notes_entry_mut(&mut self) -> Option<&mut NotesEntry> {
+        let has_options = self.has_options();
+        let answer = self.current_answer_mut()?;
+        if !has_options {
+            return Some(&mut answer.notes);
+        }
+        let idx = answer
+            .selected
+            .or(answer.option_state.selected_idx)
+            .or_else(|| answer.option_notes.is_empty().then_some(0))?;
+        answer.option_notes.get_mut(idx)
+    }
+
+    fn notes_placeholder(&self) -> &'static str {
+        if self.has_options()
+            && self
+                .current_answer()
+                .is_some_and(|answer| answer.selected.is_none())
+        {
+            SELECT_OPTION_PLACEHOLDER
+        } else if self.has_options() {
+            NOTES_PLACEHOLDER
+        } else {
+            ANSWER_PLACEHOLDER
+        }
+    }
+
+    /// Ensure the focus mode is valid for the current question.
+    fn ensure_focus_available(&mut self) {
+        if self.question_count() == 0 {
+            return;
+        }
+        if !self.has_options() {
+            self.focus = Focus::Notes;
+        }
+    }
+
+    /// Rebuild local answer state from the current request.
+    fn reset_for_request(&mut self) {
+        self.answers = self
+            .request
+            .questions
+            .iter()
+            .map(|question| {
+                let mut option_state = ScrollState::new();
+                let mut option_notes = Vec::new();
+                if let Some(options) = question.options.as_ref()
+                    && !options.is_empty()
+                {
+                    option_state.selected_idx = Some(0);
+                    option_notes = (0..options.len()).map(|_| NotesEntry::new()).collect();
+                }
+                AnswerState {
+                    selected: option_state.selected_idx,
+                    option_state,
+                    notes: NotesEntry::new(),
+                    option_notes,
+                }
+            })
+            .collect();
+
+        self.current_idx = 0;
+        self.focus = Focus::Options;
+    }
+
+    /// Move to the next/previous question, wrapping in either direction.
+    fn move_question(&mut self, next: bool) {
+        let len = self.question_count();
+        if len == 0 {
+            return;
+        }
+        let offset = if next { 1 } else { len.saturating_sub(1) };
+        self.current_idx = (self.current_idx + offset) % len;
+        self.ensure_focus_available();
+    }
+
+    /// Synchronize selection state to the currently focused option.
+    fn select_current_option(&mut self) {
+        if !self.has_options() {
+            return;
+        }
+        let options_len = self.options_len();
+        let Some(answer) = self.current_answer_mut() else {
+            return;
+        };
+        answer.option_state.clamp_selection(options_len);
+        answer.selected = answer.option_state.selected_idx;
+    }
+
+    /// Ensure there is a selection before allowing notes entry.
+    fn ensure_selected_for_notes(&mut self) {
+        if self.has_options()
+            && self
+                .current_answer()
+                .is_some_and(|answer| answer.selected.is_none())
+        {
+            self.select_current_option();
+        }
+    }
+
+    /// Advance to next question, or submit when on the last one.
+    fn go_next_or_submit(&mut self) {
+        if self.current_index() + 1 >= self.question_count() {
+            self.submit_answers();
+        } else {
+            self.move_question(true);
+        }
+    }
+
+    /// Build the response payload and dispatch it to the app.
+    fn submit_answers(&mut self) {
+        let mut answers = HashMap::new();
+        for (idx, question) in self.request.questions.iter().enumerate() {
+            let answer_state = &self.answers[idx];
+            let options = question.options.as_ref();
+            // For option questions we always produce a selection.
+            let selected_idx = if options.is_some_and(|opts| !opts.is_empty()) {
+                answer_state
+                    .selected
+                    .or(answer_state.option_state.selected_idx)
+            } else {
+                answer_state.selected
+            };
+            // Notes map to "other". When options exist, notes are per selected option.
+            let notes = if options.is_some_and(|opts| !opts.is_empty()) {
+                selected_idx
+                    .and_then(|selected| answer_state.option_notes.get(selected))
+                    .map(|entry| entry.text.text().trim().to_string())
+                    .unwrap_or_default()
+            } else {
+                answer_state.notes.text.text().trim().to_string()
+            };
+            let selected_label = selected_idx.and_then(|selected_idx| {
+                question
+                    .options
+                    .as_ref()
+                    .and_then(|opts| opts.get(selected_idx))
+                    .map(|opt| opt.label.clone())
+            });
+            let selected = selected_label.into_iter().collect::<Vec<_>>();
+            // For option questions, only send notes when present.
+            let other = if notes.is_empty() && options.is_some_and(|opts| !opts.is_empty()) {
+                None
+            } else if notes.is_empty() && selected.is_empty() {
+                Some("skipped".to_string())
+            } else {
+                Some(notes)
+            };
+            answers.insert(
+                question.id.clone(),
+                RequestUserInputAnswer { selected, other },
+            );
+        }
+        self.app_event_tx
+            .send(AppEvent::CodexOp(Op::UserInputAnswer {
+                id: self.request.turn_id.clone(),
+                response: RequestUserInputResponse { answers },
+            }));
+        if let Some(next) = self.queue.pop_front() {
+            self.request = next;
+            self.reset_for_request();
+            self.ensure_focus_available();
+        } else {
+            self.done = true;
+        }
+    }
+
+    /// Count freeform-only questions that have no notes.
+    fn unanswered_count(&self) -> usize {
+        self.request
+            .questions
+            .iter()
+            .enumerate()
+            .filter(|(idx, question)| {
+                let answer = &self.answers[*idx];
+                let options = question.options.as_ref();
+                if options.is_some_and(|opts| !opts.is_empty()) {
+                    false
+                } else {
+                    answer.notes.text.text().trim().is_empty()
+                }
+            })
+            .count()
+    }
+
+    /// Compute the preferred notes input height for the current question.
+    fn notes_input_height(&self, width: u16) -> u16 {
+        let Some(entry) = self.current_notes_entry() else {
+            return 3;
+        };
+        let usable_width = width.saturating_sub(2);
+        let text_height = entry.text.desired_height(usable_width).clamp(1, 6);
+        text_height.saturating_add(2).clamp(3, 8)
+    }
+}
+
+impl BottomPaneView for RequestUserInputOverlay {
+    fn handle_key_event(&mut self, key_event: KeyEvent) {
+        if key_event.kind == KeyEventKind::Release {
+            return;
+        }
+
+        if matches!(key_event.code, KeyCode::Esc) {
+            self.app_event_tx.send(AppEvent::CodexOp(Op::Interrupt));
+            self.done = true;
+            return;
+        }
+
+        // Question navigation is always available.
+        match key_event.code {
+            KeyCode::PageUp => {
+                self.move_question(false);
+                return;
+            }
+            KeyCode::PageDown => {
+                self.move_question(true);
+                return;
+            }
+            _ => {}
+        }
+
+        match self.focus {
+            Focus::Options => {
+                let options_len = self.options_len();
+                let Some(answer) = self.current_answer_mut() else {
+                    return;
+                };
+                // Keep selection synchronized as the user moves.
+                match key_event.code {
+                    KeyCode::Up => {
+                        answer.option_state.move_up_wrap(options_len);
+                        answer.selected = answer.option_state.selected_idx;
+                    }
+                    KeyCode::Down => {
+                        answer.option_state.move_down_wrap(options_len);
+                        answer.selected = answer.option_state.selected_idx;
+                    }
+                    KeyCode::Char(' ') => {
+                        self.select_current_option();
+                    }
+                    KeyCode::Enter => {
+                        self.select_current_option();
+                        self.go_next_or_submit();
+                    }
+                    KeyCode::Char(_) | KeyCode::Backspace | KeyCode::Delete => {
+                        // Any typing while in options switches to notes for fast freeform input.
+                        self.focus = Focus::Notes;
+                        self.ensure_selected_for_notes();
+                        if let Some(entry) = self.current_notes_entry_mut() {
+                            entry.text.input(key_event);
+                        }
+                    }
+                    _ => {}
+                }
+            }
+            Focus::Notes => {
+                if matches!(key_event.code, KeyCode::Enter) {
+                    self.go_next_or_submit();
+                    return;
+                }
+                if self.has_options() && matches!(key_event.code, KeyCode::Up | KeyCode::Down) {
+                    let options_len = self.options_len();
+                    let Some(answer) = self.current_answer_mut() else {
+                        return;
+                    };
+                    match key_event.code {
+                        KeyCode::Up => {
+                            answer.option_state.move_up_wrap(options_len);
+                            answer.selected = answer.option_state.selected_idx;
+                        }
+                        KeyCode::Down => {
+                            answer.option_state.move_down_wrap(options_len);
+                            answer.selected = answer.option_state.selected_idx;
+                        }
+                        _ => {}
+                    }
+                    return;
+                }
+                // Notes are per option when options exist.
+                self.ensure_selected_for_notes();
+                if let Some(entry) = self.current_notes_entry_mut() {
+                    entry.text.input(key_event);
+                }
+            }
+        }
+    }
+
+    fn on_ctrl_c(&mut self) -> CancellationEvent {
+        self.app_event_tx.send(AppEvent::CodexOp(Op::Interrupt));
+        self.done = true;
+        CancellationEvent::Handled
+    }
+
+    fn is_complete(&self) -> bool {
+        self.done
+    }
+
+    fn handle_paste(&mut self, pasted: String) -> bool {
+        if pasted.is_empty() {
+            return false;
+        }
+        if matches!(self.focus, Focus::Notes) {
+            self.ensure_selected_for_notes();
+            if let Some(entry) = self.current_notes_entry_mut() {
+                entry.text.insert_str(&pasted);
+                return true;
+            }
+            return true;
+        }
+        if matches!(self.focus, Focus::Options) {
+            // Treat pastes the same as typing: switch into notes.
+            self.focus = Focus::Notes;
+            self.ensure_selected_for_notes();
+            if let Some(entry) = self.current_notes_entry_mut() {
+                entry.text.insert_str(&pasted);
+                return true;
+            }
+            return true;
+        }
+        false
+    }
+
+    fn try_consume_user_input_request(
+        &mut self,
+        request: RequestUserInputEvent,
+    ) -> Option<RequestUserInputEvent> {
+        self.queue.push_back(request);
+        None
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::app_event::AppEvent;
+    use crate::render::renderable::Renderable;
+    use codex_protocol::request_user_input::RequestUserInputQuestion;
+    use codex_protocol::request_user_input::RequestUserInputQuestionOption;
+    use pretty_assertions::assert_eq;
+    use ratatui::buffer::Buffer;
+    use ratatui::layout::Rect;
+    use tokio::sync::mpsc::unbounded_channel;
+
+    fn test_sender() -> (
+        AppEventSender,
+        tokio::sync::mpsc::UnboundedReceiver<AppEvent>,
+    ) {
+        let (tx_raw, rx) = unbounded_channel::<AppEvent>();
+        (AppEventSender::new(tx_raw), rx)
+    }
+
+    fn question_with_options(id: &str, header: &str) -> RequestUserInputQuestion {
+        RequestUserInputQuestion {
+            id: id.to_string(),
+            header: header.to_string(),
+            question: "Choose an option.".to_string(),
+            options: Some(vec![
+                RequestUserInputQuestionOption {
+                    label: "Option 1".to_string(),
+                    description: "First choice.".to_string(),
+                },
+                RequestUserInputQuestionOption {
+                    label: "Option 2".to_string(),
+                    description: "Second choice.".to_string(),
+                },
+                RequestUserInputQuestionOption {
+                    label: "Option 3".to_string(),
+                    description: "Third choice.".to_string(),
+                },
+            ]),
+        }
+    }
+
+    fn question_without_options(id: &str, header: &str) -> RequestUserInputQuestion {
+        RequestUserInputQuestion {
+            id: id.to_string(),
+            header: header.to_string(),
+            question: "Share details.".to_string(),
+            options: None,
+        }
+    }
+
+    fn request_event(
+        turn_id: &str,
+        questions: Vec<RequestUserInputQuestion>,
+    ) -> RequestUserInputEvent {
+        RequestUserInputEvent {
+            call_id: "call-1".to_string(),
+            turn_id: turn_id.to_string(),
+            questions,
+        }
+    }
+
+    fn snapshot_buffer(buf: &Buffer) -> String {
+        let mut lines = Vec::new();
+        for y in 0..buf.area().height {
+            let mut row = String::new();
+            for x in 0..buf.area().width {
+                row.push(buf[(x, y)].symbol().chars().next().unwrap_or(' '));
+            }
+            lines.push(row);
+        }
+        lines.join("\n")
+    }
+
+    fn render_snapshot(overlay: &RequestUserInputOverlay, area: Rect) -> String {
+        let mut buf = Buffer::empty(area);
+        overlay.render(area, &mut buf);
+        snapshot_buffer(&buf)
+    }
+
+    #[test]
+    fn queued_requests_are_fifo() {
+        let (tx, _rx) = test_sender();
+        let mut overlay = RequestUserInputOverlay::new(
+            request_event("turn-1", vec![question_with_options("q1", "First")]),
+            tx,
+        );
+        overlay.try_consume_user_input_request(request_event(
+            "turn-2",
+            vec![question_with_options("q2", "Second")],
+        ));
+        overlay.try_consume_user_input_request(request_event(
+            "turn-3",
+            vec![question_with_options("q3", "Third")],
+        ));
+
+        overlay.submit_answers();
+        assert_eq!(overlay.request.turn_id, "turn-2");
+
+        overlay.submit_answers();
+        assert_eq!(overlay.request.turn_id, "turn-3");
+    }
+
+    #[test]
+    fn options_always_return_a_selection() {
+        let (tx, mut rx) = test_sender();
+        let mut overlay = RequestUserInputOverlay::new(
+            request_event("turn-1", vec![question_with_options("q1", "Pick one")]),
+            tx,
+        );
+
+        overlay.submit_answers();
+
+        let event = rx.try_recv().expect("expected AppEvent");
+        let AppEvent::CodexOp(Op::UserInputAnswer { id, response }) = event else {
+            panic!("expected UserInputAnswer");
+        };
+        assert_eq!(id, "turn-1");
+        let answer = response.answers.get("q1").expect("answer missing");
+        assert_eq!(answer.selected, vec!["Option 1".to_string()]);
+        assert_eq!(answer.other, None);
+    }
+
+    #[test]
+    fn freeform_questions_submit_skipped_when_empty() {
+        let (tx, mut rx) = test_sender();
+        let mut overlay = RequestUserInputOverlay::new(
+            request_event("turn-1", vec![question_without_options("q1", "Notes")]),
+            tx,
+        );
+
+        overlay.submit_answers();
+
+        let event = rx.try_recv().expect("expected AppEvent");
+        let AppEvent::CodexOp(Op::UserInputAnswer { response, .. }) = event else {
+            panic!("expected UserInputAnswer");
+        };
+        let answer = response.answers.get("q1").expect("answer missing");
+        assert_eq!(answer.selected, Vec::<String>::new());
+        assert_eq!(answer.other, Some("skipped".to_string()));
+    }
+
+    #[test]
+    fn notes_are_captured_for_selected_option() {
+        let (tx, mut rx) = test_sender();
+        let mut overlay = RequestUserInputOverlay::new(
+            request_event("turn-1", vec![question_with_options("q1", "Pick one")]),
+            tx,
+        );
+
+        {
+            let answer = overlay.current_answer_mut().expect("answer missing");
+            answer.option_state.selected_idx = Some(1);
+        }
+        overlay.select_current_option();
+        overlay
+            .current_notes_entry_mut()
+            .expect("notes entry missing")
+            .text
+            .insert_str("Notes for option 2");
+
+        overlay.submit_answers();
+
+        let event = rx.try_recv().expect("expected AppEvent");
+        let AppEvent::CodexOp(Op::UserInputAnswer { response, .. }) = event else {
+            panic!("expected UserInputAnswer");
+        };
+        let answer = response.answers.get("q1").expect("answer missing");
+        assert_eq!(answer.selected, vec!["Option 2".to_string()]);
+        assert_eq!(answer.other, Some("Notes for option 2".to_string()));
+    }
+
+    #[test]
+    fn request_user_input_options_snapshot() {
+        let (tx, _rx) = test_sender();
+        let overlay = RequestUserInputOverlay::new(
+            request_event("turn-1", vec![question_with_options("q1", "Area")]),
+            tx,
+        );
+        let area = Rect::new(0, 0, 64, 16);
+        insta::assert_snapshot!(
+            "request_user_input_options",
+            render_snapshot(&overlay, area)
+        );
+    }
+
+    #[test]
+    fn request_user_input_tight_height_snapshot() {
+        let (tx, _rx) = test_sender();
+        let overlay = RequestUserInputOverlay::new(
+            request_event("turn-1", vec![question_with_options("q1", "Area")]),
+            tx,
+        );
+        let area = Rect::new(0, 0, 60, 8);
+        insta::assert_snapshot!(
+            "request_user_input_tight_height",
+            render_snapshot(&overlay, area)
+        );
+    }
+
+    #[test]
+    fn request_user_input_scroll_options_snapshot() {
+        let (tx, _rx) = test_sender();
+        let mut overlay = RequestUserInputOverlay::new(
+            request_event(
+                "turn-1",
+                vec![RequestUserInputQuestion {
+                    id: "q1".to_string(),
+                    header: "Next Step".to_string(),
+                    question: "What would you like to do next?".to_string(),
+                    options: Some(vec![
+                        RequestUserInputQuestionOption {
+                            label: "Discuss a code change (Recommended)".to_string(),
+                            description: "Walk through a plan and edit code together.".to_string(),
+                        },
+                        RequestUserInputQuestionOption {
+                            label: "Run tests".to_string(),
+                            description: "Pick a crate and run its tests.".to_string(),
+                        },
+                        RequestUserInputQuestionOption {
+                            label: "Review a diff".to_string(),
+                            description: "Summarize or review current changes.".to_string(),
+                        },
+                        RequestUserInputQuestionOption {
+                            label: "Refactor".to_string(),
+                            description: "Tighten structure and remove dead code.".to_string(),
+                        },
+                        RequestUserInputQuestionOption {
+                            label: "Ship it".to_string(),
+                            description: "Finalize and open a PR.".to_string(),
+                        },
+                    ]),
+                }],
+            ),
+            tx,
+        );
+        {
+            let answer = overlay.current_answer_mut().expect("answer missing");
+            answer.option_state.selected_idx = Some(3);
+            answer.selected = Some(3);
+        }
+        let area = Rect::new(0, 0, 68, 10);
+        insta::assert_snapshot!(
+            "request_user_input_scrolling_options",
+            render_snapshot(&overlay, area)
+        );
+    }
+
+    #[test]
+    fn request_user_input_freeform_snapshot() {
+        let (tx, _rx) = test_sender();
+        let overlay = RequestUserInputOverlay::new(
+            request_event("turn-1", vec![question_without_options("q1", "Goal")]),
+            tx,
+        );
+        let area = Rect::new(0, 0, 64, 10);
+        insta::assert_snapshot!(
+            "request_user_input_freeform",
+            render_snapshot(&overlay, area)
+        );
+    }
+
+    #[test]
+    fn options_scroll_while_editing_notes() {
+        let (tx, _rx) = test_sender();
+        let mut overlay = RequestUserInputOverlay::new(
+            request_event("turn-1", vec![question_with_options("q1", "Pick one")]),
+            tx,
+        );
+        overlay.focus = Focus::Notes;
+        overlay
+            .current_notes_entry_mut()
+            .expect("notes entry missing")
+            .text
+            .insert_str("Notes");
+
+        overlay.handle_key_event(KeyEvent::from(KeyCode::Down));
+
+        let answer = overlay.current_answer().expect("answer missing");
+        assert_eq!(answer.selected, Some(1));
+    }
+}
--- a/codex-rs/tui/src/bottom_pane/request_user_input/render.rs
+++ b/codex-rs/tui/src/bottom_pane/request_user_input/render.rs
@@ -0,0 +1,375 @@
+use crossterm::event::KeyCode;
+use ratatui::buffer::Buffer;
+use ratatui::layout::Rect;
+use ratatui::style::Stylize;
+use ratatui::text::Line;
+use ratatui::widgets::Clear;
+use ratatui::widgets::Paragraph;
+use ratatui::widgets::StatefulWidgetRef;
+use ratatui::widgets::Widget;
+
+use crate::bottom_pane::selection_popup_common::GenericDisplayRow;
+use crate::bottom_pane::selection_popup_common::render_rows;
+use crate::key_hint;
+use crate::render::renderable::Renderable;
+
+use super::RequestUserInputOverlay;
+
+impl Renderable for RequestUserInputOverlay {
+    fn desired_height(&self, width: u16) -> u16 {
+        let sections = self.layout_sections(Rect::new(0, 0, width, u16::MAX));
+        let mut height = sections
+            .question_lines
+            .len()
+            .saturating_add(5)
+            .saturating_add(self.notes_input_height(width) as usize)
+            .saturating_add(sections.footer_lines as usize);
+        if self.has_options() {
+            height = height.saturating_add(2);
+        }
+        height = height.max(8);
+        height as u16
+    }
+
+    fn render(&self, area: Rect, buf: &mut Buffer) {
+        self.render_ui(area, buf);
+    }
+
+    fn cursor_pos(&self, area: Rect) -> Option<(u16, u16)> {
+        self.cursor_pos_impl(area)
+    }
+}
+
+impl RequestUserInputOverlay {
+    /// Render the full request-user-input overlay.
+    pub(super) fn render_ui(&self, area: Rect, buf: &mut Buffer) {
+        if area.width == 0 || area.height == 0 {
+            return;
+        }
+        let sections = self.layout_sections(area);
+
+        // Progress header keeps the user oriented across multiple questions.
+        let progress_line = if self.question_count() > 0 {
+            let idx = self.current_index() + 1;
+            let total = self.question_count();
+            Line::from(format!("Question {idx}/{total}").dim())
+        } else {
+            Line::from("No questions".dim())
+        };
+        Paragraph::new(progress_line).render(sections.progress_area, buf);
+
+        // Question title and wrapped prompt text.
+        let question_header = self.current_question().map(|q| q.header.clone());
+        let header_line = if let Some(header) = question_header {
+            Line::from(header.bold())
+        } else {
+            Line::from("No questions".dim())
+        };
+        Paragraph::new(header_line).render(sections.header_area, buf);
+
+        let question_y = sections.question_area.y;
+        for (offset, line) in sections.question_lines.iter().enumerate() {
+            if question_y.saturating_add(offset as u16)
+                >= sections.question_area.y + sections.question_area.height
+            {
+                break;
+            }
+            Paragraph::new(Line::from(line.clone())).render(
+                Rect {
+                    x: sections.question_area.x,
+                    y: question_y.saturating_add(offset as u16),
+                    width: sections.question_area.width,
+                    height: 1,
+                },
+                buf,
+            );
+        }
+
+        if sections.answer_title_area.height > 0 {
+            let answer_label = "Answer";
+            let answer_title = if self.focus_is_options() || self.focus_is_notes_without_options() {
+                answer_label.cyan().bold()
+            } else {
+                answer_label.dim()
+            };
+            Paragraph::new(Line::from(answer_title)).render(sections.answer_title_area, buf);
+        }
+
+        // Build rows with selection markers for the shared selection renderer.
+        let option_rows = self
+            .current_question()
+            .and_then(|question| question.options.as_ref())
+            .map(|options| {
+                options
+                    .iter()
+                    .enumerate()
+                    .map(|(idx, opt)| {
+                        let selected = self
+                            .current_answer()
+                            .and_then(|answer| answer.selected)
+                            .is_some_and(|sel| sel == idx);
+                        let prefix = if selected { "(x)" } else { "( )" };
+                        GenericDisplayRow {
+                            name: format!("{prefix} {}", opt.label),
+                            description: Some(opt.description.clone()),
+                            ..Default::default()
+                        }
+                    })
+                    .collect::<Vec<_>>()
+            })
+            .unwrap_or_default();
+
+        if self.has_options() {
+            let mut option_state = self
+                .current_answer()
+                .map(|answer| answer.option_state)
+                .unwrap_or_default();
+            if sections.options_area.height > 0 {
+                // Ensure the selected option is visible in the scroll window.
+                option_state
+                    .ensure_visible(option_rows.len(), sections.options_area.height as usize);
+                render_rows(
+                    sections.options_area,
+                    buf,
+                    &option_rows,
+                    &option_state,
+                    option_rows.len().max(1),
+                    "No options",
+                );
+            }
+        }
+
+        if sections.notes_title_area.height > 0 {
+            let notes_label = if self.has_options()
+                && self
+                    .current_answer()
+                    .is_some_and(|answer| answer.selected.is_some())
+            {
+                if let Some(label) = self.current_option_label() {
+                    format!("Notes for {label} (optional)")
+                } else {
+                    "Notes (optional)".to_string()
+                }
+            } else {
+                "Notes (optional)".to_string()
+            };
+            let notes_title = if self.focus_is_notes() {
+                notes_label.as_str().cyan().bold()
+            } else {
+                notes_label.as_str().dim()
+            };
+            Paragraph::new(Line::from(notes_title)).render(sections.notes_title_area, buf);
+        }
+
+        if sections.notes_area.height > 0 {
+            self.render_notes_input(sections.notes_area, buf);
+        }
+
+        let footer_y = sections
+            .notes_area
+            .y
+            .saturating_add(sections.notes_area.height);
+        if sections.footer_lines == 2 {
+            // Status line for unanswered count when any question is empty.
+            let warning = format!(
+                "Unanswered: {} | Will submit as skipped",
+                self.unanswered_count()
+            );
+            Paragraph::new(Line::from(warning.dim())).render(
+                Rect {
+                    x: area.x,
+                    y: footer_y,
+                    width: area.width,
+                    height: 1,
+                },
+                buf,
+            );
+        }
+        let hint_y = footer_y.saturating_add(sections.footer_lines.saturating_sub(1));
+        // Footer hints (selection index + navigation keys).
+        let mut hint_spans = Vec::new();
+        if self.has_options() {
+            let options_len = self.options_len();
+            let option_index = self.selected_option_index().map_or(0, |idx| idx + 1);
+            hint_spans.extend(vec![
+                format!("Option {option_index} of {options_len}").into(),
+                " | ".into(),
+            ]);
+        }
+        hint_spans.extend(vec![
+            key_hint::plain(KeyCode::Up).into(),
+            "/".into(),
+            key_hint::plain(KeyCode::Down).into(),
+            " scroll | ".into(),
+            key_hint::plain(KeyCode::Enter).into(),
+            " next question | ".into(),
+        ]);
+        if self.question_count() > 1 {
+            hint_spans.extend(vec![
+                key_hint::plain(KeyCode::PageUp).into(),
+                " prev | ".into(),
+                key_hint::plain(KeyCode::PageDown).into(),
+                " next | ".into(),
+            ]);
+        }
+        hint_spans.extend(vec![
+            key_hint::plain(KeyCode::Esc).into(),
+            " interrupt".into(),
+        ]);
+        Paragraph::new(Line::from(hint_spans).dim()).render(
+            Rect {
+                x: area.x,
+                y: hint_y,
+                width: area.width,
+                height: 1,
+            },
+            buf,
+        );
+    }
+
+    /// Return the cursor position when editing notes, if visible.
+    pub(super) fn cursor_pos_impl(&self, area: Rect) -> Option<(u16, u16)> {
+        if !self.focus_is_notes() {
+            return None;
+        }
+        let sections = self.layout_sections(area);
+        let entry = self.current_notes_entry()?;
+        let input_area = sections.notes_area;
+        if input_area.width <= 2 || input_area.height == 0 {
+            return None;
+        }
+        if input_area.height < 3 {
+            // Inline notes layout uses a prefix and a single-line text area.
+            let prefix = notes_prefix();
+            let prefix_width = prefix.len() as u16;
+            if input_area.width <= prefix_width {
+                return None;
+            }
+            let textarea_rect = Rect {
+                x: input_area.x.saturating_add(prefix_width),
+                y: input_area.y,
+                width: input_area.width.saturating_sub(prefix_width),
+                height: 1,
+            };
+            let state = *entry.state.borrow();
+            return entry.text.cursor_pos_with_state(textarea_rect, state);
+        }
+        let text_area_height = input_area.height.saturating_sub(2);
+        let textarea_rect = Rect {
+            x: input_area.x.saturating_add(1),
+            y: input_area.y.saturating_add(1),
+            width: input_area.width.saturating_sub(2),
+            height: text_area_height,
+        };
+        let state = *entry.state.borrow();
+        entry.text.cursor_pos_with_state(textarea_rect, state)
+    }
+
+    /// Render the notes input box or inline notes field.
+    fn render_notes_input(&self, area: Rect, buf: &mut Buffer) {
+        let Some(entry) = self.current_notes_entry() else {
+            return;
+        };
+        if area.width < 2 || area.height == 0 {
+            return;
+        }
+        if area.height < 3 {
+            // Inline notes field for tight layouts.
+            let prefix = notes_prefix();
+            let prefix_width = prefix.len() as u16;
+            if area.width <= prefix_width {
+                Paragraph::new(Line::from(prefix.dim())).render(area, buf);
+                return;
+            }
+            Paragraph::new(Line::from(prefix.dim())).render(
+                Rect {
+                    x: area.x,
+                    y: area.y,
+                    width: prefix_width,
+                    height: 1,
+                },
+                buf,
+            );
+            let textarea_rect = Rect {
+                x: area.x.saturating_add(prefix_width),
+                y: area.y,
+                width: area.width.saturating_sub(prefix_width),
+                height: 1,
+            };
+            let mut state = entry.state.borrow_mut();
+            Clear.render(textarea_rect, buf);
+            StatefulWidgetRef::render_ref(&(&entry.text), textarea_rect, buf, &mut state);
+            if entry.text.text().is_empty() {
+                Paragraph::new(Line::from(self.notes_placeholder().dim()))
+                    .render(textarea_rect, buf);
+            }
+            return;
+        }
+        // Draw a light ASCII frame around the notes area.
+        let top_border = format!("+{}+", "-".repeat(area.width.saturating_sub(2) as usize));
+        let bottom_border = top_border.clone();
+        Paragraph::new(Line::from(top_border)).render(
+            Rect {
+                x: area.x,
+                y: area.y,
+                width: area.width,
+                height: 1,
+            },
+            buf,
+        );
+        Paragraph::new(Line::from(bottom_border)).render(
+            Rect {
+                x: area.x,
+                y: area.y.saturating_add(area.height.saturating_sub(1)),
+                width: area.width,
+                height: 1,
+            },
+            buf,
+        );
+        for row in 1..area.height.saturating_sub(1) {
+            Line::from(vec![
+                "|".into(),
+                " ".repeat(area.width.saturating_sub(2) as usize).into(),
+                "|".into(),
+            ])
+            .render(
+                Rect {
+                    x: area.x,
+                    y: area.y.saturating_add(row),
+                    width: area.width,
+                    height: 1,
+                },
+                buf,
+            );
+        }
+        let text_area_height = area.height.saturating_sub(2);
+        let textarea_rect = Rect {
+            x: area.x.saturating_add(1),
+            y: area.y.saturating_add(1),
+            width: area.width.saturating_sub(2),
+            height: text_area_height,
+        };
+        let mut state = entry.state.borrow_mut();
+        Clear.render(textarea_rect, buf);
+        StatefulWidgetRef::render_ref(&(&entry.text), textarea_rect, buf, &mut state);
+        if entry.text.text().is_empty() {
+            Paragraph::new(Line::from(self.notes_placeholder().dim())).render(textarea_rect, buf);
+        }
+    }
+
+    fn focus_is_options(&self) -> bool {
+        matches!(self.focus, super::Focus::Options)
+    }
+
+    fn focus_is_notes(&self) -> bool {
+        matches!(self.focus, super::Focus::Notes)
+    }
+
+    fn focus_is_notes_without_options(&self) -> bool {
+        !self.has_options() && self.focus_is_notes()
+    }
+}
+
+fn notes_prefix() -> &'static str {
+    "Notes: "
+}
--- a/codex-rs/tui/src/bottom_pane/request_user_input/snapshots/codex_tui__bottom_pane__request_user_inputtestsrequest_user_input_freeform.snap
+++ b/codex-rs/tui/src/bottom_pane/request_user_input/snapshots/codex_tui__bottom_pane__request_user_inputtestsrequest_user_input_freeform.snap
@@ -0,0 +1,12 @@
+---
+source: tui/src/bottom_pane/request_user_input/mod.rs
+expression: "render_snapshot(&overlay, area)"
+---
+Question 1/1                                                    
+Goal                                                            
+Share details.                                                  
+--------------------------------------------------------------+
+|Type your answer (optional)                                   |
+--------------------------------------------------------------+
+Unanswered: 1 | Will submit as skipped                          
+↑/↓ scroll | enter next question | esc interrupt
--- a/codex-rs/tui/src/bottom_pane/request_user_input/snapshots/codex_tui__bottom_pane__request_user_inputtestsrequest_user_input_options.snap
+++ b/codex-rs/tui/src/bottom_pane/request_user_input/snapshots/codex_tui__bottom_pane__request_user_inputtestsrequest_user_input_options.snap
@@ -0,0 +1,20 @@
+---
+source: tui/src/bottom_pane/request_user_input/mod.rs
+expression: "render_snapshot(&overlay, area)"
+---
+Question 1/1                                                    
+Area                                                            
+Choose an option.                                               
+Answer                                                          
+(x) Option 1  First choice.                                     
+( ) Option 2  Second choice.                                    
+( ) Option 3  Third choice.                                     
+                                                                
+                                                                
+                                                                
+                                                                
+Notes for Option 1 (optional)                                   
+--------------------------------------------------------------+
+|Add notes (optional)                                          |
+--------------------------------------------------------------+
+Option 1 of 3 | ↑/↓ scroll | enter next question | esc interrupt
--- a/codex-rs/tui/src/bottom_pane/request_user_input/snapshots/codex_tui__bottom_pane__request_user_inputtestsrequest_user_input_scrolling_options.snap
+++ b/codex-rs/tui/src/bottom_pane/request_user_input/snapshots/codex_tui__bottom_pane__request_user_inputtestsrequest_user_input_scrolling_options.snap
@@ -0,0 +1,14 @@
+---
+source: tui/src/bottom_pane/request_user_input/mod.rs
+expression: "render_snapshot(&overlay, area)"
+---
+Question 1/1                                                        
+Next Step                                                           
+What would you like to do next?                                     
+( ) Discuss a code change (Recommended)  Walk through a plan and    
+                                         edit code together.        
+( ) Run tests                            Pick a crate and run its   
+                                         tests.                     
+( ) Review a diff                        Summarize or review current
+Notes: Add notes (optional)                                         
+Option 4 of 5 | ↑/↓ scroll | enter next question | esc interrupt
--- a/codex-rs/tui/src/bottom_pane/request_user_input/snapshots/codex_tui__bottom_pane__request_user_inputtestsrequest_user_input_tight_height.snap
+++ b/codex-rs/tui/src/bottom_pane/request_user_input/snapshots/codex_tui__bottom_pane__request_user_inputtestsrequest_user_input_tight_height.snap
@@ -0,0 +1,12 @@
+---
+source: tui/src/bottom_pane/request_user_input/mod.rs
+expression: "render_snapshot(&overlay, area)"
+---
+Question 1/1                                                
+Area                                                        
+Choose an option.                                           
+(x) Option 1  First choice.                                 
+( ) Option 2  Second choice.                                
+( ) Option 3  Third choice.                                 
+Notes: Add notes (optional)                                 
+Option 1 of 3 | ↑/↓ scroll | enter next question | esc inter
--- a/codex-rs/tui/src/chatwidget.rs
+++ b/codex-rs/tui/src/chatwidget.rs
@@ -96,6 +96,7 @@ use codex_protocol::config_types::CollaborationMode;
 use codex_protocol::config_types::Settings;
 use codex_protocol::models::local_image_label_text;
 use codex_protocol::parse_command::ParsedCommand;
+use codex_protocol::request_user_input::RequestUserInputEvent;
 use codex_protocol::user_input::TextElement;
 use codex_protocol::user_input::UserInput;
 use crossterm::event::KeyCode;
@@ -1009,6 +1010,7 @@ impl ChatWidget {
        self.running_commands.clear();
        self.suppressed_exec_calls.clear();
        self.last_unified_wait = None;
+        self.unified_exec_wait_streak = None;
        self.clear_unified_exec_processes();
        self.stream_controller = None;
        self.maybe_show_pending_rate_limit_prompt();
@@ -1209,6 +1211,14 @@ impl ChatWidget {
        );
    }

+    fn on_request_user_input(&mut self, ev: RequestUserInputEvent) {
+        let ev2 = ev.clone();
+        self.defer_or_handle(
+            |q| q.push_user_input(ev),
+            |s| s.handle_request_user_input_now(ev2),
+        );
+    }
+
    fn on_exec_command_begin(&mut self, ev: ExecCommandBeginEvent) {
        self.flush_answer_stream_with_separator();
        if is_unified_exec_source(ev.source) {
@@ -1519,6 +1529,7 @@ impl ChatWidget {
    #[inline]
    fn handle_streaming_delta(&mut self, delta: String) {
        // Before streaming agent content, flush any active exec cell group.
+        self.flush_unified_exec_wait_streak();
        self.flush_active_cell();

        if self.stream_controller.is_none() {
@@ -1676,6 +1687,12 @@ impl ChatWidget {
        self.request_redraw();
    }

+    pub(crate) fn handle_request_user_input_now(&mut self, ev: RequestUserInputEvent) {
+        self.flush_answer_stream_with_separator();
+        self.bottom_pane.push_user_input_request(ev);
+        self.request_redraw();
+    }
+
    pub(crate) fn handle_exec_begin_now(&mut self, ev: ExecCommandBeginEvent) {
        // Ensure the status indicator is visible while the command runs.
        self.running_commands.insert(
@@ -2674,6 +2691,9 @@ impl ChatWidget {
            EventMsg::ElicitationRequest(ev) => {
                self.on_elicitation_request(ev);
            }
+            EventMsg::RequestUserInput(ev) => {
+                self.on_request_user_input(ev);
+            }
            EventMsg::ExecCommandBegin(ev) => self.on_exec_command_begin(ev),
            EventMsg::TerminalInteraction(delta) => self.on_terminal_interaction(delta),
            EventMsg::ExecCommandOutputDelta(delta) => self.on_exec_command_output_delta(delta),
@@ -2734,8 +2754,7 @@ impl ChatWidget {
            | EventMsg::ItemCompleted(_)
            | EventMsg::AgentMessageContentDelta(_)
            | EventMsg::ReasoningContentDelta(_)
-            | EventMsg::ReasoningRawContentDelta(_)
-            | EventMsg::RequestUserInput(_) => {}
+            | EventMsg::ReasoningRawContentDelta(_) => {}
        }
    }

--- a/codex-rs/tui/src/chatwidget/interrupts.rs
+++ b/codex-rs/tui/src/chatwidget/interrupts.rs
@@ -8,6 +8,7 @@ use codex_core::protocol::McpToolCallBeginEvent;
 use codex_core::protocol::McpToolCallEndEvent;
 use codex_core::protocol::PatchApplyEndEvent;
 use codex_protocol::approvals::ElicitationRequestEvent;
+use codex_protocol::request_user_input::RequestUserInputEvent;

 use super::ChatWidget;

@@ -16,6 +17,7 @@ pub(crate) enum QueuedInterrupt {
    ExecApproval(String, ExecApprovalRequestEvent),
    ApplyPatchApproval(String, ApplyPatchApprovalRequestEvent),
    Elicitation(ElicitationRequestEvent),
+    RequestUserInput(RequestUserInputEvent),
    ExecBegin(ExecCommandBeginEvent),
    ExecEnd(ExecCommandEndEvent),
    McpBegin(McpToolCallBeginEvent),
@@ -57,6 +59,10 @@ impl InterruptManager {
        self.queue.push_back(QueuedInterrupt::Elicitation(ev));
    }

+    pub(crate) fn push_user_input(&mut self, ev: RequestUserInputEvent) {
+        self.queue.push_back(QueuedInterrupt::RequestUserInput(ev));
+    }
+
    pub(crate) fn push_exec_begin(&mut self, ev: ExecCommandBeginEvent) {
        self.queue.push_back(QueuedInterrupt::ExecBegin(ev));
    }
@@ -85,6 +91,7 @@ impl InterruptManager {
                    chat.handle_apply_patch_approval_now(id, ev)
                }
                QueuedInterrupt::Elicitation(ev) => chat.handle_elicitation_request_now(ev),
+                QueuedInterrupt::RequestUserInput(ev) => chat.handle_request_user_input_now(ev),
                QueuedInterrupt::ExecBegin(ev) => chat.handle_exec_begin_now(ev),
                QueuedInterrupt::ExecEnd(ev) => chat.handle_exec_end_now(ev),
                QueuedInterrupt::McpBegin(ev) => chat.handle_mcp_begin_now(ev),
--- a/codex-rs/tui/src/chatwidget/snapshots/codex_tuichatwidgettests__interrupt_clears_unified_exec_wait_streak.snap
+++ b/codex-rs/tui/src/chatwidget/snapshots/codex_tuichatwidgettests__interrupt_clears_unified_exec_wait_streak.snap
@@ -0,0 +1,6 @@
+---
+source: tui/src/chatwidget/tests.rs
+expression: snapshot
+---
+cells=1
+■ Conversation interrupted - tell the model what to do differently. Something went wrong? Hit `/feedback` to report the issue.
--- a/codex-rs/tui/src/chatwidget/snapshots/codex_tuichatwidgettests__unified_exec_wait_after_final_agent_message.snap
+++ b/codex-rs/tui/src/chatwidget/snapshots/codex_tuichatwidgettests__unified_exec_wait_after_final_agent_message.snap
@@ -0,0 +1,8 @@
+---
+source: tui/src/chatwidget/tests.rs
+expression: combined
+---
+↳ Interacted with background terminal · cargo test -p codex-core
+  └ (waited)
+
+• Final response.
--- a/codex-rs/tui/src/chatwidget/snapshots/codex_tuichatwidgettests__unified_exec_wait_before_streamed_agent_message.snap
+++ b/codex-rs/tui/src/chatwidget/snapshots/codex_tuichatwidgettests__unified_exec_wait_before_streamed_agent_message.snap
@@ -0,0 +1,8 @@
+---
+source: tui/src/chatwidget/tests.rs
+expression: combined
+---
+↳ Interacted with background terminal · cargo test -p codex-core
+  └ (waited)
+
+• Streaming response.
--- a/codex-rs/tui/src/chatwidget/tests.rs
+++ b/codex-rs/tui/src/chatwidget/tests.rs
@@ -1754,6 +1754,79 @@ async fn unified_exec_interaction_after_task_complete_is_suppressed() {
    );
 }

+#[tokio::test]
+async fn unified_exec_wait_after_final_agent_message_snapshot() {
+    let (mut chat, mut rx, _op_rx) = make_chatwidget_manual(None).await;
+    chat.handle_codex_event(Event {
+        id: "turn-1".into(),
+        msg: EventMsg::TurnStarted(TurnStartedEvent {
+            model_context_window: None,
+        }),
+    });
+
+    begin_unified_exec_startup(&mut chat, "call-wait", "proc-1", "cargo test -p codex-core");
+    terminal_interaction(&mut chat, "call-wait-stdin", "proc-1", "");
+
+    chat.handle_codex_event(Event {
+        id: "turn-1".into(),
+        msg: EventMsg::AgentMessage(AgentMessageEvent {
+            message: "Final response.".into(),
+        }),
+    });
+    chat.handle_codex_event(Event {
+        id: "turn-1".into(),
+        msg: EventMsg::TurnComplete(TurnCompleteEvent {
+            last_agent_message: Some("Final response.".into()),
+        }),
+    });
+
+    let cells = drain_insert_history(&mut rx);
+    let combined = cells
+        .iter()
+        .map(|lines| lines_to_single_string(lines))
+        .collect::<String>();
+    assert_snapshot!("unified_exec_wait_after_final_agent_message", combined);
+}
+
+#[tokio::test]
+async fn unified_exec_wait_before_streamed_agent_message_snapshot() {
+    let (mut chat, mut rx, _op_rx) = make_chatwidget_manual(None).await;
+    chat.handle_codex_event(Event {
+        id: "turn-1".into(),
+        msg: EventMsg::TurnStarted(TurnStartedEvent {
+            model_context_window: None,
+        }),
+    });
+
+    begin_unified_exec_startup(
+        &mut chat,
+        "call-wait-stream",
+        "proc-1",
+        "cargo test -p codex-core",
+    );
+    terminal_interaction(&mut chat, "call-wait-stream-stdin", "proc-1", "");
+
+    chat.handle_codex_event(Event {
+        id: "turn-1".into(),
+        msg: EventMsg::AgentMessageDelta(AgentMessageDeltaEvent {
+            delta: "Streaming response.".into(),
+        }),
+    });
+    chat.handle_codex_event(Event {
+        id: "turn-1".into(),
+        msg: EventMsg::TurnComplete(TurnCompleteEvent {
+            last_agent_message: None,
+        }),
+    });
+
+    let cells = drain_insert_history(&mut rx);
+    let combined = cells
+        .iter()
+        .map(|lines| lines_to_single_string(lines))
+        .collect::<String>();
+    assert_snapshot!("unified_exec_wait_before_streamed_agent_message", combined);
+}
+
 #[tokio::test]
 async fn unified_exec_wait_status_header_updates_on_late_command_display() {
    let (mut chat, _rx, _op_rx) = make_chatwidget_manual(None).await;
@@ -3320,6 +3393,38 @@ async fn interrupt_clears_unified_exec_processes() {
    let _ = drain_insert_history(&mut rx);
 }

+#[tokio::test]
+async fn interrupt_clears_unified_exec_wait_streak_snapshot() {
+    let (mut chat, mut rx, _op_rx) = make_chatwidget_manual(None).await;
+
+    chat.handle_codex_event(Event {
+        id: "turn-1".into(),
+        msg: EventMsg::TurnStarted(TurnStartedEvent {
+            model_context_window: None,
+        }),
+    });
+
+    let begin = begin_unified_exec_startup(&mut chat, "call-1", "process-1", "just fix");
+    terminal_interaction(&mut chat, "call-1a", "process-1", "");
+
+    chat.handle_codex_event(Event {
+        id: "turn-1".into(),
+        msg: EventMsg::TurnAborted(codex_core::protocol::TurnAbortedEvent {
+            reason: TurnAbortReason::Interrupted,
+        }),
+    });
+
+    end_exec(&mut chat, begin, "", "", 0);
+    let cells = drain_insert_history(&mut rx);
+    let combined = cells
+        .iter()
+        .map(|lines| lines_to_single_string(lines))
+        .collect::<Vec<_>>()
+        .join("\n");
+    let snapshot = format!("cells={}\n{combined}", cells.len());
+    assert_snapshot!("interrupt_clears_unified_exec_wait_streak", snapshot);
+}
+
 #[tokio::test]
 async fn turn_complete_clears_unified_exec_processes() {
    let (mut chat, mut rx, _op_rx) = make_chatwidget_manual(None).await;
--- a/codex-rs/tui/src/collab.rs
+++ b/codex-rs/tui/src/collab.rs
@@ -7,123 +7,122 @@ use codex_core::protocol::CollabAgentSpawnEndEvent;
 use codex_core::protocol::CollabCloseEndEvent;
 use codex_core::protocol::CollabWaitingBeginEvent;
 use codex_core::protocol::CollabWaitingEndEvent;
+use codex_protocol::ThreadId;
 use ratatui::style::Stylize;
 use ratatui::text::Line;
+use ratatui::text::Span;
+use std::collections::HashMap;

 const COLLAB_PROMPT_PREVIEW_GRAPHEMES: usize = 160;
+const COLLAB_AGENT_ERROR_PREVIEW_GRAPHEMES: usize = 160;
+const COLLAB_AGENT_RESPONSE_PREVIEW_GRAPHEMES: usize = 240;

 pub(crate) fn spawn_end(ev: CollabAgentSpawnEndEvent) -> PlainHistoryCell {
    let CollabAgentSpawnEndEvent {
        call_id,
-        sender_thread_id,
+        sender_thread_id: _,
        new_thread_id,
        prompt,
        status,
    } = ev;
    let new_agent = new_thread_id
-        .map(|id| id.to_string())
-        .unwrap_or_else(|| "none".to_string());
+        .map(|id| Span::from(id.to_string()))
+        .unwrap_or_else(|| Span::from("not created").dim());
    let mut details = vec![
        detail_line("call", call_id),
-        detail_line("sender", sender_thread_id),
-        detail_line("new_agent", new_agent),
+        detail_line("agent", new_agent),
        status_line(&status),
    ];
    if let Some(line) = prompt_line(&prompt) {
        details.push(line);
    }
-    collab_event("Collab spawn", details)
+    collab_event("Agent spawned", details)
 }

 pub(crate) fn interaction_end(ev: CollabAgentInteractionEndEvent) -> PlainHistoryCell {
    let CollabAgentInteractionEndEvent {
        call_id,
-        sender_thread_id,
+        sender_thread_id: _,
        receiver_thread_id,
        prompt,
        status,
    } = ev;
    let mut details = vec![
        detail_line("call", call_id),
-        detail_line("sender", sender_thread_id),
-        detail_line("receiver", receiver_thread_id),
+        detail_line("receiver", receiver_thread_id.to_string()),
        status_line(&status),
    ];
    if let Some(line) = prompt_line(&prompt) {
        details.push(line);
    }
-    collab_event("Collab send input", details)
+    collab_event("Input sent", details)
 }

 pub(crate) fn waiting_begin(ev: CollabWaitingBeginEvent) -> PlainHistoryCell {
    let CollabWaitingBeginEvent {
        call_id,
-        sender_thread_id,
+        sender_thread_id: _,
        receiver_thread_ids,
    } = ev;
    let details = vec![
        detail_line("call", call_id),
-        detail_line("sender", sender_thread_id),
-        detail_line("receiver", format!("{receiver_thread_ids:?}")),
+        detail_line("receivers", format_thread_ids(&receiver_thread_ids)),
    ];
-    collab_event("Collab wait begin", details)
+    collab_event("Waiting for agents", details)
 }

 pub(crate) fn waiting_end(ev: CollabWaitingEndEvent) -> PlainHistoryCell {
    let CollabWaitingEndEvent {
        call_id,
-        sender_thread_id,
+        sender_thread_id: _,
        statuses,
    } = ev;
-    let details = vec![
-        detail_line("call", call_id),
-        detail_line("sender", sender_thread_id),
-        detail_line("statuses", format!("{statuses:#?}")),
-    ];
-    collab_event("Collab wait end", details)
+    let mut details = vec![detail_line("call", call_id)];
+    details.extend(wait_complete_lines(&statuses));
+    collab_event("Wait complete", details)
 }

 pub(crate) fn close_end(ev: CollabCloseEndEvent) -> PlainHistoryCell {
    let CollabCloseEndEvent {
        call_id,
-        sender_thread_id,
+        sender_thread_id: _,
        receiver_thread_id,
        status,
    } = ev;
    let details = vec![
        detail_line("call", call_id),
-        detail_line("sender", sender_thread_id),
-        detail_line("receiver", receiver_thread_id),
+        detail_line("receiver", receiver_thread_id.to_string()),
        status_line(&status),
    ];
-    collab_event("Collab close", details)
+    collab_event("Agent closed", details)
 }

 fn collab_event(title: impl Into<String>, details: Vec<Line<'static>>) -> PlainHistoryCell {
    let title = title.into();
-    let mut lines: Vec<Line<'static>> = vec![vec!["• ".dim(), title.bold()].into()];
+    let mut lines: Vec<Line<'static>> =
+        vec![vec![Span::from("• ").dim(), Span::from(title).bold()].into()];
    if !details.is_empty() {
        lines.extend(prefix_lines(details, "  └ ".dim(), "    ".into()));
    }
    PlainHistoryCell::new(lines)
 }

-fn detail_line(label: &str, value: impl std::fmt::Display) -> Line<'static> {
-    Line::from(format!("{label}: {value}").dim())
+fn detail_line(label: &str, value: impl Into<Span<'static>>) -> Line<'static> {
+    vec![Span::from(format!("{label}: ")).dim(), value.into()].into()
 }

 fn status_line(status: &AgentStatus) -> Line<'static> {
-    Line::from(format!("status: {}", status_text(status)).dim())
+    detail_line("status", status_span(status))
 }

-fn status_text(status: &AgentStatus) -> &'static str {
+fn status_span(status: &AgentStatus) -> Span<'static> {
    match status {
-        AgentStatus::PendingInit => "pending_init",
-        AgentStatus::Running => "running",
-        AgentStatus::Completed(_) => "completed",
-        AgentStatus::Errored(_) => "errored",
-        AgentStatus::Shutdown => "shutdown",
-        AgentStatus::NotFound => "not_found",
+        AgentStatus::PendingInit => Span::from("pending init").dim(),
+        AgentStatus::Running => Span::from("running").cyan().bold(),
+        AgentStatus::Completed(_) => Span::from("completed").green(),
+        AgentStatus::Errored(_) => Span::from("errored").red(),
+        AgentStatus::Shutdown => Span::from("shutdown").dim(),
+        AgentStatus::NotFound => Span::from("not found").red(),
    }
 }

@@ -134,7 +133,133 @@ fn prompt_line(prompt: &str) -> Option<Line<'static>> {
    } else {
        Some(detail_line(
            "prompt",
-            truncate_text(trimmed, COLLAB_PROMPT_PREVIEW_GRAPHEMES),
+            Span::from(truncate_text(trimmed, COLLAB_PROMPT_PREVIEW_GRAPHEMES)).dim(),
        ))
    }
 }
+
+fn format_thread_ids(ids: &[ThreadId]) -> Span<'static> {
+    if ids.is_empty() {
+        return Span::from("none").dim();
+    }
+    let joined = ids
+        .iter()
+        .map(ToString::to_string)
+        .collect::<Vec<_>>()
+        .join(", ");
+    Span::from(joined)
+}
+
+fn wait_complete_lines(statuses: &HashMap<ThreadId, AgentStatus>) -> Vec<Line<'static>> {
+    if statuses.is_empty() {
+        return vec![detail_line("agents", Span::from("none").dim())];
+    }
+
+    let mut pending_init = 0usize;
+    let mut running = 0usize;
+    let mut completed = 0usize;
+    let mut errored = 0usize;
+    let mut shutdown = 0usize;
+    let mut not_found = 0usize;
+    for status in statuses.values() {
+        match status {
+            AgentStatus::PendingInit => pending_init += 1,
+            AgentStatus::Running => running += 1,
+            AgentStatus::Completed(_) => completed += 1,
+            AgentStatus::Errored(_) => errored += 1,
+            AgentStatus::Shutdown => shutdown += 1,
+            AgentStatus::NotFound => not_found += 1,
+        }
+    }
+
+    let mut summary = vec![Span::from(format!("{} total", statuses.len())).dim()];
+    push_status_count(
+        &mut summary,
+        pending_init,
+        "pending init",
+        ratatui::prelude::Stylize::dim,
+    );
+    push_status_count(&mut summary, running, "running", |span| span.cyan().bold());
+    push_status_count(
+        &mut summary,
+        completed,
+        "completed",
+        ratatui::prelude::Stylize::green,
+    );
+    push_status_count(
+        &mut summary,
+        errored,
+        "errored",
+        ratatui::prelude::Stylize::red,
+    );
+    push_status_count(
+        &mut summary,
+        shutdown,
+        "shutdown",
+        ratatui::prelude::Stylize::dim,
+    );
+    push_status_count(
+        &mut summary,
+        not_found,
+        "not found",
+        ratatui::prelude::Stylize::red,
+    );
+
+    let mut entries: Vec<(String, &AgentStatus)> = statuses
+        .iter()
+        .map(|(thread_id, status)| (thread_id.to_string(), status))
+        .collect();
+    entries.sort_by(|(left, _), (right, _)| left.cmp(right));
+
+    let mut lines = Vec::with_capacity(entries.len() + 1);
+    lines.push(detail_line_spans("agents", summary));
+    lines.extend(entries.into_iter().map(|(thread_id, status)| {
+        let mut spans = vec![
+            Span::from(thread_id).dim(),
+            Span::from(" ").dim(),
+            status_span(status),
+        ];
+        match status {
+            AgentStatus::Completed(Some(message)) => {
+                let message_preview = truncate_text(
+                    &message.split_whitespace().collect::<Vec<_>>().join(" "),
+                    COLLAB_AGENT_RESPONSE_PREVIEW_GRAPHEMES,
+                );
+                spans.push(Span::from(": ").dim());
+                spans.push(Span::from(message_preview));
+            }
+            AgentStatus::Errored(error) => {
+                let error_preview = truncate_text(
+                    &error.split_whitespace().collect::<Vec<_>>().join(" "),
+                    COLLAB_AGENT_ERROR_PREVIEW_GRAPHEMES,
+                );
+                spans.push(Span::from(": ").dim());
+                spans.push(Span::from(error_preview).dim());
+            }
+            _ => {}
+        }
+        spans.into()
+    }));
+    lines
+}
+
+fn push_status_count(
+    spans: &mut Vec<Span<'static>>,
+    count: usize,
+    label: &'static str,
+    style: impl FnOnce(Span<'static>) -> Span<'static>,
+) {
+    if count == 0 {
+        return;
+    }
+
+    spans.push(Span::from(" · ").dim());
+    spans.push(style(Span::from(format!("{count} {label}"))));
+}
+
+fn detail_line_spans(label: &str, mut value: Vec<Span<'static>>) -> Line<'static> {
+    let mut spans = Vec::with_capacity(value.len() + 1);
+    spans.push(Span::from(format!("{label}: ")).dim());
+    spans.append(&mut value);
+    spans.into()
+}
--- a/docs/tui-request-user-input.md
+++ b/docs/tui-request-user-input.md
@@ -0,0 +1,39 @@
+# Request user input overlay (TUI)
+
+This note documents the TUI overlay used to gather answers for
+`RequestUserInputEvent`.
+
+## Overview
+
+The overlay renders one question at a time and collects:
+
+- A single selected option (when options exist).
+- Freeform notes (always available).
+
+When options are present, notes are stored per selected option and the first
+option is selected by default, so every option question has an answer. If a
+question has no options and no notes are provided, the answer is submitted as
+`skipped`.
+
+## Focus and input routing
+
+The overlay tracks a small focus state:
+
+- **Options**: Up/Down move the selection and Space selects.
+- **Notes**: Text input edits notes for the currently selected option.
+
+Typing while focused on options switches into notes automatically to reduce
+friction for freeform input.
+
+## Navigation
+
+- Enter advances to the next question.
+- Enter on the last question submits all answers.
+- PageUp/PageDown navigate across questions (when multiple are present).
+- Esc interrupts the run.
+
+## Layout priorities
+
+The layout prefers to keep the question and all options visible. Notes and
+footer hints collapse as space shrinks, with notes falling back to a single-line
+"Notes: ..." input in tight terminals.
Author	SHA1	Message	Date
jif-oai	1a4ec06889	feat: disable unified_exec on windows	2026-01-21 17:59:40 +00:00
jif-oai	338f2d634b	nit: ui on interruption (#9606 )	2026-01-21 14:09:15 +00:00
zbarsky-openai	2338f99f58	[bazel] Upgrade to bazel9 (#9576 )	2026-01-21 13:25:36 +00:00
jif-oai	f1b6a43907	nit: better collab tui (#9551 ) <img width="478" height="304" alt="Screenshot 2026-01-21 at 11 53 50" src="https://github.com/user-attachments/assets/e2ef70de-2fff-44e0-a574-059177966ed2" />	2026-01-21 11:53:58 +00:00
jif-oai	13358fa131	fix: nit tui on terminal interactions (#9602 )	2026-01-21 11:30:34 +00:00
jif-oai	b75024c465	feat: async shell snapshot (#9600 )	2026-01-21 10:41:13 +00:00
Eric Traut	16b9380e99	Added "codex." prefix to "conversation.turn.count" metric name (#9594 ) All other metrics names start with "codex.", so I presume this was an unintended omission.	2026-01-21 10:00:47 +00:00
jif-oai	a22a61e678	feat: display raw command on user shell (#9598 )	2026-01-21 09:44:38 +00:00
jif-oai	f1c961d5f7	feat: max threads config (#9483 ) # External (non-OpenAI) Pull Request Requirements Before opening this Pull Request, please read the dedicated "Contributing" markdown file or your PR may be closed: https://github.com/openai/codex/blob/main/docs/contributing.md If your PR conforms to our contribution guidelines, replace this text with a detailed and high quality description of your changes. Include a link to a bug report or enhancement request.	2026-01-21 09:39:11 +00:00
Ahmed Ibrahim	6e9a31def1	fix going up and down on questions after writing notes (#9596 )	2026-01-21 09:37:37 +00:00
Ahmed Ibrahim	5f55ed666b	Add request-user-input overlay (#9585 ) - Add request-user-input overlay and routing in the TUI	2026-01-21 00:19:35 -08:00