diff --git a/20260416_wasm_appserver.md b/20260416_wasm_appserver.md
new file mode 100644
index 0000000000..6d8e537b94
--- /dev/null
+++ b/20260416_wasm_appserver.md
@@ -0,0 +1,427 @@
+# WASM Embedded App-Server Design
+
+## TL;DR
+
+The current browser harness wraps a single user submission by creating a thread, calling `thread.submit(Op::UserTurn { ... })`, and draining `thread.next_event()` until the turn completes. That path proved that the core harness can run in the browser, but it leaves the browser with a custom control surface that diverges from native app-server behavior and currently resets session state after every turn.
+
+This document proposes switching the browser integration to an embedded in-process app-server runtime. The browser would keep a long-lived app-server instance in wasm, communicate with it through the existing app-server request and event model, and reuse the native app-server boundary instead of maintaining a browser-specific harness API.
+
+## Objective
+
+Use the existing app-server boundary as the primary control plane for the browser runtime so that:
+
+- browser and native clients speak the same conceptual protocol
+- multi-turn behavior matches native behavior more closely
+- debugging and event inspection reuse existing app-server semantics
+- future features such as thread lifecycle, steering, approvals, and richer tooling do not require a second browser-specific orchestration layer
+
+## Background
+
+### Current Browser Design
+
+The current browser runtime is centered on `BrowserCodex` in `codex-rs/wasm-harness/src/browser.rs`.
+
+Its main flow is:
+
+1. `BrowserCodex.submit_turn(prompt, on_event)` creates a fresh `LocalSet`.
+2. It either reuses or creates a `BrowserSession`.
+3. It submits a turn directly to core with:
+
+   ```rust
+   session.thread.submit(Op::UserTurn { ... }).await
+   ```
+
+4. It loops on `session.thread.next_event().await` and forwards events to JS.
+5. When the turn finishes, it clears `self.session`.
+
+This is a thin wrapper around the core thread API. It is effectively a `UserSubmit`-style interface: the browser gives the harness a prompt, the harness starts one turn, then pushes turn events back to JS.
+
+The relevant behavior today is:
+
+- `submit_turn()` scopes execution to a per-turn `LocalSet`
+- the browser wrapper owns a `BrowserSession { config, thread, session_configured }`
+- the wrapper emits raw core events directly to JS
+- the wrapper explicitly drops the session after each turn
+
+### Why The Current Design Is Not Enough
+
+The current design was useful as a proof of feasibility, but it creates several product and maintenance problems.
+
+First, it is not actually aligned with the native client boundary. Native clients talk to app-server through requests, notifications, and streamed server events. The browser currently bypasses that layer and talks directly to `CodexThread`.
+
+Second, it currently loses continuity across turns. Because `submit_turn()` uses a fresh `LocalSet` and clears `self.session` after each submission, the browser prototype starts a new harness session for every turn. That is why follow-up prompts appear to lack memory of earlier prompts.
+
+Third, it forces the browser to maintain a separate orchestration contract. Any feature added at the app-server boundary has to be re-exposed or re-invented in the browser wrapper.
+
+Fourth, it weakens debugging. Native app-server already has a request model, notification model, server-request model, and thread/turn lifecycle semantics. The browser wrapper currently exposes only a narrower direct-thread view.
+
+## Why Switch To An Embedded App-Server
+
+The app-server boundary already solves the problems the browser needs:
+
+- request/response for typed client operations
+- notifications for fire-and-forget client messages
+- streamed server notifications for turn progress
+- server requests for approvals and similar interactive flows
+- explicit thread lifecycle APIs
+- a stable place to add future browser features without widening the direct core API
+
+The repository already includes an in-process embedding path in `codex-rs/app-server/src/in_process.rs`. That runtime preserves app-server semantics while replacing stdio/websocket transport with in-memory channels.
+
+That makes it a much better browser boundary than `BrowserCodex.submit_turn(...)`.
+
+## Goals
+
+- Preserve the existing app-server request and event model in the browser.
+- Keep a long-lived runtime alive across multiple browser turns.
+- Support multi-turn conversations without rebuilding browser-specific thread state each turn.
+- Reuse existing app-server features such as `thread/start`, `turn/start`, `turn/interrupt`, and server-driven approval requests.
+- Keep the wasm integration transport-local and in-process. The browser should not need to run a real socket server to use app-server semantics.
+
+## Non-Goals
+
+- This document does not require full native parity for browser tools, filesystem access, or sandboxing.
+- This document does not solve browser persistence by itself. State DB and rollout persistence still need separate wasm-capable implementations.
+- This document does not require reusing `run_main_with_transport(...)` directly. The proposal reuses the app-server boundary, not that exact native entrypoint.
+
+## Proposal
+
+### High-Level Design
+
+Replace the current direct-thread browser wrapper with a wasm-facing wrapper around an embedded in-process app-server runtime.
+
+This refactor should be a replacement, not an addition. We should remove the existing `BrowserCodex` implementation as part of the cleanup and move the current prototype onto the new app-server-based path.
+
+The new stack would look like:
+
+```text
+JS UI
+  -> wasm wrapper
+  -> in-process app-server runtime
+  -> MessageProcessor
+  -> ThreadManager / Codex core
+```
+
+Instead of calling `thread.submit(Op::UserTurn { ... })` directly, the browser would:
+
+- start one in-process app-server runtime for the browser session
+- send app-server client requests into that runtime
+- consume app-server server notifications and server requests from that runtime
+
+### Browser Boundary
+
+The wasm wrapper should expose an API shaped like the app-server protocol rather than the current `submit_turn(prompt, on_event)` helper.
+
+A minimal JS-facing API is:
+
+- `start(options) -> handle`
+- `request(request) -> Promise<response>`
+- `notify(notification) -> Promise<void>` or `void`
+- `nextEvent() -> Promise<event | null>`
+- `respondToServerRequest(requestId, result) -> Promise<void>`
+- `failServerRequest(requestId, error) -> Promise<void>`
+- `shutdown() -> Promise<void>`
+
+This mirrors the capabilities already present on `InProcessClientHandle`:
+
+- `request(...)`
+- `notify(...)`
+- `next_event()`
+- `respond_to_server_request(...)`
+- `fail_server_request(...)`
+- `shutdown()`
+
+### Runtime Lifecycle
+
+The browser should create one long-lived in-process app-server runtime and keep it alive until the browser session is reset or closed.
+
+Expected lifecycle:
+
+1. Browser constructs wasm wrapper.
+2. Wrapper builds `InProcessStartArgs`.
+3. Wrapper calls `codex_app_server::in_process::start(...)`.
+4. Wrapper keeps the returned handle alive across turns.
+5. JS sends requests such as `thread/start` and `turn/start`.
+6. JS drains streamed server events with `nextEvent()`.
+7. On shutdown or reset, wrapper calls `shutdown()`.
+
+This is the key change from the current design. The runtime is session-scoped, not turn-scoped.
+
+### Message Flow
+
+For a typical first turn:
+
+1. JS calls `request(thread/start { ... })`.
+2. The app-server returns a thread id.
+3. JS calls `request(turn/start { threadId, input, ... })`.
+4. The app-server returns an in-progress turn response.
+5. JS repeatedly calls `nextEvent()` or receives pushed events.
+6. The runtime emits `turn/started`, item deltas, tool events, and `turn/completed`.
+
+For later turns:
+
+1. JS reuses the existing thread id.
+2. JS calls `request(turn/start { threadId, input, ... })` again.
+3. The same app-server runtime and the same underlying thread/session continue processing.
+
+This aligns browser behavior with native behavior and removes the current per-turn session reset.
+
+### Event Model
+
+The browser should consume app-server events, not raw core `EventMsg` values.
+
+That gives the browser:
+
+- a stable protocol-shaped event stream
+- server notifications for turn lifecycle and content updates
+- server requests for approvals and other interactive flows
+- lag/backpressure signals already defined by the in-process embedding
+
+It also gives us a cleaner debugging surface because the browser can log:
+
+- outgoing client requests
+- client notifications
+- incoming server notifications
+- incoming server requests
+- responses to server requests
+
+### Why Use `in_process` Instead Of `run_main_with_transport`
+
+`run_main_with_transport(...)` is not the right wasm entrypoint.
+
+It hardcodes:
+
+- stdio or websocket transport startup
+- native signal handling
+- native logging and DB startup assumptions
+
+By contrast, `in_process.rs` already does the important part we want:
+
+- run `MessageProcessor`
+- keep the app-server request/notification/event contract
+- replace transport with in-memory channels
+
+So the design should reuse app-server semantics through `in_process`, not try to reuse the native transport bootstrap unchanged.
+
+## Detailed Design
+
+### 1. Replace `BrowserCodex` With A WASM App-Server Wrapper
+
+Add a new browser-facing wrapper that owns:
+
+- the long-lived in-process app-server handle
+- browser-specific runtime services such as the code executor bridge
+- browser session options needed to build config and initialize params
+
+This wrapper replaces `BrowserCodex` as the main orchestration entrypoint.
+
+As part of this refactor we should:
+
+- remove the existing direct-thread `BrowserCodex` implementation
+- remove `BrowserSession` as a browser-specific wrapper around `CodexThread`
+- update the current browser prototype to construct and use the new app-server-based wrapper instead
+
+We do not want to maintain two browser orchestration paths. The prototype should become the first consumer of the new design.
+
+### 2. Request Serialization
+
+The wrapper should accept JSON or `JsValue` payloads that correspond to app-server requests and notifications.
+
+At the wasm boundary:
+
+- JS passes a request object
+- wasm deserializes into `ClientRequest` or `ClientNotification`
+- `in_process` handles the request
+- wasm serializes responses and events back to JS
+
+This keeps the browser API close to the existing protocol and avoids introducing a second custom Rust-to-JS command language.
+
+### 3. Thread Ownership
+
+The browser should treat thread ids as app-server resources, not as direct `CodexThread` handles.
+
+That means:
+
+- creating threads through `thread/start`
+- reading state through `thread/read` and related APIs
+- starting turns through `turn/start`
+- steering or interrupting turns through existing turn APIs
+
+This is an important layering choice. The browser should stop owning direct thread runtime objects.
+
+### 4. Approval And Server Request Handling
+
+The browser must support app-server initiated requests back to the client.
+
+Examples include:
+
+- tool approval requests
+- user input requests
+- future browser-specific interactive flows
+
+When `nextEvent()` yields a `ServerRequest`, JS must either:
+
+- answer with `respondToServerRequest(...)`
+- or reject with `failServerRequest(...)`
+
+This is a capability the current direct-thread wrapper does not model cleanly.
+
+### 5. Debugging
+
+The browser wrapper should log the app-server boundary directly.
+
+Recommended browser-side logging:
+
+- every outgoing request with method and id
+- every request result
+- every incoming server notification
+- every incoming server request
+- every reply to a server request
+- backpressure or lag markers
+
+This is a better debugging surface than ad hoc logging around direct `submit()` and `next_event()` calls because it reflects the real control plane used by native clients.
+
+## Storage And Persistence
+
+This proposal improves the control plane, but it does not by itself provide browser persistence.
+
+There are two separate persistence problems:
+
+1. Core state DB
+   Core currently initializes session storage internally. On `wasm32`, the current state DB bridge is stubbed and returns `None`.
+
+2. Rollout persistence
+   The current wasm rollout recorder is also stubbed. Recording is effectively a no-op and history reload is unavailable.
+
+As a result, the embedded app-server design gives us:
+
+- live multi-turn continuity within a running browser session
+
+But it does not yet give us:
+
+- browser reload/resume
+- durable thread metadata
+- durable rollout history
+
+Those require follow-on work below the `in_process` layer.
+
+## Migration Plan
+
+### Milestone 1: Replace The Prototype Runtime With `in_process`
+
+Build the wasm wrapper on top of `codex_app_server::in_process` and migrate the existing prototype to use it.
+
+Scope:
+
+- long-lived runtime
+- request/notification/event API exposed to JS
+- thread and turn flow through app-server methods
+- browser code executor still supplied through existing wasm/runtime hooks
+- remove the direct `BrowserCodex` / `BrowserSession` path from `wasm-harness`
+
+Success criteria:
+
+- multi-turn browser session works without resetting runtime state between turns
+- browser logs show app-server request and event traffic
+- browser no longer calls `thread.submit(Op::UserTurn { ... })` directly
+- the existing browser prototype runs on the app-server-based implementation
+- there is only one supported browser runtime path in the codebase
+
+### Milestone 2: Align With `codex-app-server-client`
+
+Decide whether the wasm wrapper should sit directly on `in_process` or on a thinner variant of `codex-app-server-client`.
+
+The client facade is appealing because it already wraps:
+
+- in-process runtime startup
+- event forwarding
+- server-request resolution helpers
+- convergence with the remote app-server client shape
+
+This may reduce custom browser-side orchestration code.
+
+### Milestone 3: Browser Persistence
+
+Add real wasm-backed persistence for:
+
+- rollout history
+- thread metadata
+- any state DB-backed browser features we want to preserve across reloads
+
+This likely requires explicit storage seams below the app-server wrapper.
+
+## Alternatives Considered
+
+### Keep The Current `BrowserCodex` Model And Preserve Session State
+
+We could keep the current wrapper and only stop clearing `self.session`.
+
+That would likely fix the immediate memory bug, but it would not fix the larger architectural problem:
+
+- the browser would still use a custom direct-thread boundary
+- app-server APIs would still need browser-specific re-exposure
+- debugging would still happen at a less stable abstraction level
+
+This is a tactical fix, not the design we want to converge on.
+
+### Reuse `run_main_with_transport(...)` Directly
+
+We could try to add a custom wasm transport and plug it into `run_main_with_transport(...)`.
+
+This is not attractive because the function currently bundles:
+
+- transport startup
+- native shutdown handling
+- logging and telemetry bootstrap
+- native transport assumptions
+
+`in_process` is already a better split for embedding.
+
+## Risks
+
+- The browser protocol surface becomes closer to app-server, which may require slightly more client-side plumbing than the current `submit_turn(prompt)` helper.
+- Some app-server internals still assume native runtime pieces and may need additional injection points for wasm.
+- Storage is still unresolved. This design fixes control-plane drift first, not persistence.
+- If we expose raw JSON-RPC too literally to JS, the browser API may become awkward. We should keep the protocol shape while still providing small ergonomic helpers.
+
+## Open Questions
+
+1. Should the wasm wrapper expose raw JSON-RPC payloads, typed helper methods, or both?
+2. Should the browser wrap `in_process` directly, or should it reuse a slimmer `codex-app-server-client` facade?
+3. Which app-server methods do we want to support in browser v1 beyond `thread/start` and `turn/start`?
+4. Do we want server events delivered by pull (`nextEvent`) only, or also by JS callback subscription?
+5. What is the right storage abstraction for browser-backed rollout and state DB persistence?
+
+## Recommended Decisions For Implementation Start
+
+To begin implementation, we should make the following decisions explicit.
+
+- Browser API surface
+  Recommendation:
+  Expose a thin typed wrapper over the app-server protocol rather than raw JSON-RPC only. The JS API should provide ergonomic helpers such as `startThread`, `startTurn`, `interruptTurn`, `nextEvent`, and `respondToServerRequest`, while staying close to app-server request and event types under the hood.
+
+- `in_process` vs `codex-app-server-client`
+  Recommendation:
+  Start directly on `codex_app_server::in_process`. It is the simpler runtime dependency and gives us direct control in wasm. We should borrow the client facade's worker and event-forwarding patterns where useful, but avoid adding a second abstraction layer unless the wasm wrapper clearly grows into it.
+
+- Session lifecycle
+  Recommendation:
+  Create one long-lived embedded app-server runtime per browser session and keep it alive until explicit reset or shutdown. Runtime lifetime should be browser-session scoped, not turn scoped. Reset should happen only on explicit session teardown, configuration changes that require rebuild, or API key changes.
+
+- Event delivery model
+  Recommendation:
+  Use callback subscription as the primary browser-facing event model, while optionally retaining a polling escape hatch for tests or simple consumers. Internally we can still drain `next_event()`, but most browser UI code is simpler if events are pushed into JS callbacks.
+
+- Server request handling
+  Recommendation:
+  Treat server requests as first-class and require explicit client handling. The wrapper should surface every `ServerRequest` to JS and require the browser to answer or reject it. For unsupported request types in browser v1, reject them explicitly with a clear error rather than letting turns hang.
+
+- v1 app-server method set
+  Recommendation:
+  Support a narrow but complete thread and turn slice in browser v1: `thread/start`, `thread/read`, `turn/start`, `turn/interrupt`, and `turn/steer`. That is enough for a real multi-turn conversational product and debugging workflow without taking on the full app-server surface immediately.
+
+## Recommendation
+
+Move the browser runtime to an embedded in-process app-server boundary.
+
+That keeps the browser on the same architectural path as native clients, fixes the current per-turn session model, improves debugging, and creates a better long-term seam for browser-specific runtime and storage work.
diff --git a/codex-rs/Cargo.lock b/codex-rs/Cargo.lock
index 902c534da5..614816f8f4 100644
--- a/codex-rs/Cargo.lock
+++ b/codex-rs/Cargo.lock
@@ -2913,6 +2913,7 @@ name = "codex-wasm-harness"
 version = "0.0.0"
 dependencies = [
  "async-trait",
+ "codex-app-server-protocol",
  "codex-code-mode",
  "codex-core",
  "codex-exec-server",
diff --git a/codex-rs/core/src/codex.rs b/codex-rs/core/src/codex.rs
index 04f05139a6..2b35a6bd84 100644
--- a/codex-rs/core/src/codex.rs
+++ b/codex-rs/core/src/codex.rs
@@ -3234,6 +3234,12 @@ impl Session {
                 "Overwriting existing pending elicitation for server_name: {server_name}, request_id: {request_id}"
             );
         }
+        #[cfg(not(target_arch = "wasm32"))]
+        let id = match request_id.clone() {
+            RequestId::String(value) => codex_protocol::mcp::RequestId::String(value.to_string()),
+            RequestId::Number(value) => codex_protocol::mcp::RequestId::Integer(value),
+        };
+        #[cfg(target_arch = "wasm32")]
         let id = request_id.clone();
         let event = EventMsg::ElicitationRequest(ElicitationRequestEvent {
             turn_id: params.turn_id,
@@ -4644,6 +4650,8 @@ mod handlers {
     use codex_protocol::request_user_input::RequestUserInputResponse;
 
     use crate::context_manager::is_user_turn_boundary;
+    #[cfg(not(target_arch = "wasm32"))]
+    use crate::mcp_types::RequestId;
     use codex_protocol::config_types::CollaborationMode;
     use codex_protocol::config_types::ModeKind;
     use codex_protocol::config_types::Settings;
@@ -4836,6 +4844,12 @@ mod handlers {
             content,
             meta,
         };
+        #[cfg(not(target_arch = "wasm32"))]
+        let request_id = match request_id {
+            ProtocolRequestId::String(value) => RequestId::String(value.into()),
+            ProtocolRequestId::Integer(value) => RequestId::Number(value),
+        };
+        #[cfg(target_arch = "wasm32")]
         let request_id = request_id;
         if let Err(err) = sess
             .resolve_elicitation(server_name, request_id, response)
diff --git a/codex-rs/core/src/config/network_proxy_spec.rs b/codex-rs/core/src/config/network_proxy_spec.rs
index 59142c5e0f..2d36d7dfd4 100644
--- a/codex-rs/core/src/config/network_proxy_spec.rs
+++ b/codex-rs/core/src/config/network_proxy_spec.rs
@@ -137,7 +137,14 @@ impl NetworkProxySpec {
                 None => builder.policy_decider(|_request| async {
                     // In restricted sandbox modes, allowlist misses should ask for
                     // explicit network approval instead of hard-denying.
-                    Ok(NetworkDecision::ask("not_allowed"))
+                    #[cfg(not(target_arch = "wasm32"))]
+                    {
+                        NetworkDecision::ask("not_allowed")
+                    }
+                    #[cfg(target_arch = "wasm32")]
+                    {
+                        Ok(NetworkDecision::ask("not_allowed"))
+                    }
                 }),
             };
         }
diff --git a/codex-rs/core/src/mcp_tool_call.rs b/codex-rs/core/src/mcp_tool_call.rs
index 16c5e1194c..a8946ee545 100644
--- a/codex-rs/core/src/mcp_tool_call.rs
+++ b/codex-rs/core/src/mcp_tool_call.rs
@@ -794,7 +794,7 @@ async fn maybe_request_mcp_tool_approval(
         mcp_tool_approval_question_text(question.question, monitor_reason.as_deref());
     if tool_call_mcp_elicitation_enabled {
         let request_id =
-            RequestId::String(format!("{MCP_TOOL_APPROVAL_QUESTION_ID_PREFIX}_{call_id}"));
+            RequestId::String(format!("{MCP_TOOL_APPROVAL_QUESTION_ID_PREFIX}_{call_id}").into());
         let params = build_mcp_tool_approval_elicitation_request(
             sess.as_ref(),
             turn_context.as_ref(),
diff --git a/codex-rs/core/src/tools/network_approval.rs b/codex-rs/core/src/tools/network_approval.rs
index 27f19e677a..dadee60e50 100644
--- a/codex-rs/core/src/tools/network_approval.rs
+++ b/codex-rs/core/src/tools/network_approval.rs
@@ -545,11 +545,11 @@ pub(crate) fn build_network_policy_decider(
         let network_policy_decider_session = Arc::clone(&network_policy_decider_session);
         async move {
             let Some(session) = network_policy_decider_session.read().await.upgrade() else {
-                return Ok(NetworkDecision::ask("not_allowed"));
+                return NetworkDecision::ask("not_allowed");
             };
-            Ok(network_approval
+            network_approval
                 .handle_inline_policy_request(session, request)
-                .await)
+                .await
         }
     })
 }
diff --git a/codex-rs/wasm-harness/Cargo.toml b/codex-rs/wasm-harness/Cargo.toml
index d1bfefd7c6..208e15608b 100644
--- a/codex-rs/wasm-harness/Cargo.toml
+++ b/codex-rs/wasm-harness/Cargo.toml
@@ -14,6 +14,7 @@ workspace = true
 
 [dependencies]
 async-trait = { workspace = true }
+codex-app-server-protocol = { workspace = true }
 codex-code-mode = { workspace = true }
 codex-core = { workspace = true }
 codex-exec-server = { workspace = true }
@@ -22,7 +23,7 @@ codex-protocol = { workspace = true }
 js-sys = { workspace = true }
 serde = { workspace = true, features = ["derive"] }
 serde_json = { workspace = true }
-tokio = { workspace = true, features = ["rt"] }
+tokio = { workspace = true, features = ["rt", "sync"] }
 wasm-bindgen = { workspace = true }
 wasm-bindgen-futures = { workspace = true }
 web-sys = { workspace = true, features = [
diff --git a/codex-rs/wasm-harness/README.md b/codex-rs/wasm-harness/README.md
index 82970f51f1..be8acd4483 100644
--- a/codex-rs/wasm-harness/README.md
+++ b/codex-rs/wasm-harness/README.md
@@ -4,9 +4,11 @@ This crate is the first browser-facing seam for a Codex harness prototype.
 
 It exposes one browser-facing layer:
 
-- `BrowserCodex`: a `wasm_bindgen` adapter that starts a real
-  `codex-core::CodexThread`, calls `CodexThread::submit(Op::UserTurn { ... })`,
-  and streams real Codex protocol events back to JavaScript.
+- `BrowserAppServer`: a `wasm_bindgen` adapter that exposes an app-server-shaped
+  browser boundary. It keeps a live `codex-core::CodexThread` behind a
+  request/event interface, accepts app-server request envelopes such as
+  `thread/start` and `turn/start`, and streams notifications plus raw core
+  events back to JavaScript.
 
 The demo page passes the user's API key into the WASM facade so Rust can make
 browser `fetch` requests to the Responses API through the wasm-compatible
@@ -17,9 +19,12 @@ The API key field is for local prototype use only: it stores the key in browser
 integration should use a proxy or an ephemeral-token flow instead of persisting
 long-lived API keys in the page origin.
 
-The remaining work is to replace the current browser-only host shims with more
-complete browser implementations for persistence, richer tools, and other
-host-heavy services.
+This replaces the earlier `BrowserCodex.submit_turn(...)` prototype. The
+browser example now uses the same high-level control plane as native Codex:
+create or reuse a thread, start turns against it, and listen for async events.
+The remaining work is to swap the direct core bridge under this wrapper for a
+deeper reuse of the in-process app-server runtime once the storage/runtime
+dependencies are wasm-compatible.
 
 ## Library Boundary
 
@@ -27,7 +32,7 @@ The intended downstream integration point is the crate itself. Downstream
 webapps can:
 
 - depend on `codex-wasm-harness` from a Git branch or local path;
-- construct `BrowserCodex` from JavaScript or wrap the crate with their own
+- construct `BrowserAppServer` from JavaScript or wrap the crate with their own
   browser bindings;
 - provide session-scoped prompt inputs such as `cwd`, developer instructions,
   and user/project-doc instructions;
@@ -45,22 +50,39 @@ The intended boundary is:
 Example:
 
 ```js
-const codex = new BrowserCodex(apiKey);
-codex.setSessionOptions({
+const app = new BrowserAppServer(apiKey);
+app.setSessionOptions({
   cwd: "/workspace",
   instructions: {
     developer: "Code runs inside AppKernel. OPFS and network APIs are available.",
     user: "# AGENTS.md instructions for /workspace\n\n<INSTRUCTIONS>\n...\n</INSTRUCTIONS>",
   },
 });
+app.setEventHandler((event) => console.log(event));
+
+const thread = await app.request({
+  method: "thread/start",
+  id: 1,
+  params: {},
+});
+
+await app.request({
+  method: "turn/start",
+  id: 2,
+  params: {
+    threadId: thread.thread.id,
+    input: [{ type: "text", text: "Say hello." }],
+  },
+});
 ```
 
 ## Current Limitations
 
-This is a minimal browser port of the Codex turn loop, not full desktop Codex.
+This is a minimal browser port of the Codex app-server boundary, not full
+desktop Codex.
 
-- It uses the real `CodexThread` turn path, but many host-heavy services are
-  still compiled into degraded wasm implementations.
+- It keeps real Codex threads alive across turns, but many host-heavy services
+  are still compiled into degraded wasm implementations.
 - It currently relies on a single injected browser code executor for code mode.
 - Native shell, PTY, MCP, plugin runtime, and filesystem-backed persistence are
   not available in the browser prototype.
diff --git a/codex-rs/wasm-harness/examples/browser/index.html b/codex-rs/wasm-harness/examples/browser/index.html
index 9ea5d8970b..e51b178399 100644
--- a/codex-rs/wasm-harness/examples/browser/index.html
+++ b/codex-rs/wasm-harness/examples/browser/index.html
@@ -202,9 +202,11 @@
       <section id="events" aria-live="polite"></section>
     </main>
     <script type="module">
-      import init, { BrowserCodex } from "../pkg/codex_wasm_harness.js?v=20260414s";
+      import init, {
+        BrowserAppServer,
+      } from "../pkg/codex_wasm_harness.js?v=20260416a";
 
-      await init("../pkg/codex_wasm_harness_bg.wasm?v=20260414s");
+      await init("../pkg/codex_wasm_harness_bg.wasm?v=20260416a");
 
       const form = document.querySelector("#prompt-form");
       const input = document.querySelector("#prompt");
@@ -213,8 +215,10 @@
       const apiKeyStatus = document.querySelector("#api-key-status");
       const clearApiKeyButton = document.querySelector("#clear-api-key");
       const API_KEY_STORAGE_KEY = "codexWasmHarness.apiKey";
-      const codex = new BrowserCodex(readStoredApiKey());
+      const app = new BrowserAppServer(readStoredApiKey());
       const sandbox = createSandboxKernel();
+      let nextRequestId = 1;
+      let threadId = null;
       const browserSessionOptions = {
         cwd: "/workspace",
         instructions: {
@@ -235,23 +239,27 @@
 
       apiKeyInput.value = readStoredApiKey();
       updateApiKeyStatus();
-      codex.setSessionOptions(browserSessionOptions);
-      codex.set_code_executor(async (requestJson) =>
+      app.setSessionOptions(browserSessionOptions);
+      app.setEventHandler(handleServerEvent);
+      app.set_code_executor(async (requestJson) =>
         sandbox.execute(requestJson),
       );
+      await app.notify({ method: "initialized" });
       renderEvent({ type: "page_ready" });
 
       apiKeyInput.addEventListener("input", () => {
         const apiKey = apiKeyInput.value.trim();
         writeStoredApiKey(apiKey);
-        codex.set_api_key(apiKey);
+        threadId = null;
+        app.set_api_key(apiKey);
         updateApiKeyStatus();
       });
 
       clearApiKeyButton.addEventListener("click", () => {
         apiKeyInput.value = "";
         writeStoredApiKey("");
-        codex.set_api_key("");
+        threadId = null;
+        app.set_api_key("");
         updateApiKeyStatus();
       });
 
@@ -260,7 +268,11 @@
         events.replaceChildren();
         renderEvent({ type: "submit_clicked" });
         try {
-          await codex.submit_turn(input.value, renderEvent);
+          const currentThreadId = await ensureThread();
+          await request("turn/start", {
+            threadId: currentThreadId,
+            input: [{ type: "text", text: input.value }],
+          });
         } catch (error) {
           renderEvent({
             type: "page_error",
@@ -321,11 +333,35 @@
           : "No API key stored. Enter a key to run the real Codex harness.";
       }
 
+      async function ensureThread() {
+        if (threadId) {
+          return threadId;
+        }
+        const response = await request("thread/start", {});
+        threadId = response.thread.id;
+        return threadId;
+      }
+
+      async function request(method, params) {
+        const payload = { method, id: nextRequestId++, params };
+        renderEvent({ type: "client_request", payload });
+        const response = await app.request(payload);
+        renderEvent({ type: "client_response", method, response });
+        return response;
+      }
+
+      function handleServerEvent(event) {
+        if (event?.method === "thread/started") {
+          threadId = event.params?.thread?.id ?? threadId;
+        }
+        renderEvent(event);
+      }
+
       function renderEvent(event) {
         const card = document.createElement("article");
         card.className = "event";
         const title = document.createElement("strong");
-        title.textContent = event.type;
+        title.textContent = event.method ?? event.type ?? "event";
         const body = document.createElement("pre");
         body.textContent = JSON.stringify(event, null, 2);
         card.append(title, body);
diff --git a/codex-rs/wasm-harness/src/browser.rs b/codex-rs/wasm-harness/src/browser.rs
index 273b023f8a..4c5134667f 100644
--- a/codex-rs/wasm-harness/src/browser.rs
+++ b/codex-rs/wasm-harness/src/browser.rs
@@ -1,8 +1,29 @@
 use crate::HarnessError;
-use async_trait::async_trait;
+use codex_app_server_protocol::ApprovalsReviewer;
+use codex_app_server_protocol::AskForApproval;
+use codex_app_server_protocol::ClientNotification;
+use codex_app_server_protocol::ClientRequest;
+use codex_app_server_protocol::SandboxPolicy as AppSandboxPolicy;
+use codex_app_server_protocol::ServerNotification;
+use codex_app_server_protocol::SessionSource as AppSessionSource;
+use codex_app_server_protocol::Thread as AppThread;
+use codex_app_server_protocol::ThreadReadResponse;
+use codex_app_server_protocol::ThreadStartParams;
+use codex_app_server_protocol::ThreadStartResponse;
+use codex_app_server_protocol::ThreadStartedNotification;
+use codex_app_server_protocol::ThreadStatus;
+use codex_app_server_protocol::Turn as AppTurn;
+use codex_app_server_protocol::TurnCompletedNotification;
+use codex_app_server_protocol::TurnInterruptResponse;
+use codex_app_server_protocol::TurnStartParams;
+use codex_app_server_protocol::TurnStartResponse;
+use codex_app_server_protocol::TurnStartedNotification;
+use codex_app_server_protocol::TurnStatus;
+use codex_app_server_protocol::TurnSteerResponse;
 use codex_core::AuthManager;
 use codex_core::CodeModeRuntime;
 use codex_core::CodexAuth;
+use codex_core::CodexThread;
 use codex_core::ThreadManager;
 use codex_core::config::Config;
 use codex_core::models_manager::collaboration_mode_presets::CollaborationModesConfig;
@@ -11,18 +32,20 @@ use codex_features::Feature;
 use codex_protocol::protocol::Event;
 use codex_protocol::protocol::EventMsg;
 use codex_protocol::protocol::Op;
-use codex_protocol::protocol::SessionConfiguredEvent;
 use codex_protocol::protocol::SessionSource;
-use codex_protocol::user_input::UserInput;
 use js_sys::Function;
 use js_sys::Promise;
 use serde::Deserialize;
 use serde::Serialize;
 use serde_json::Value as JsonValue;
+use std::cell::RefCell;
 use std::collections::HashMap;
 use std::path::PathBuf;
+use std::rc::Rc;
 use std::sync::Arc;
 use std::sync::Mutex;
+use tokio::sync::mpsc;
+use tokio::sync::oneshot;
 use tokio::task::LocalSet;
 use wasm_bindgen::JsCast;
 use wasm_bindgen::prelude::*;
@@ -90,13 +113,62 @@ struct JsExecutorResponse {
     error_text: Option<String>,
 }
 
+#[derive(Serialize)]
+struct DebugEvent<'a> {
+    r#type: &'a str,
+    stage: &'a str,
+}
+
+#[derive(Serialize)]
+struct RawCoreEventEnvelope {
+    r#type: &'static str,
+    event: Event,
+}
+
+enum BrowserCommand {
+    SetApiKey(String),
+    SetSessionOptions(BrowserSessionOptions),
+    SetEventHandler(Option<JsFunctionHandle>),
+    SetCodeExecutor(Option<JsFunctionHandle>),
+    Request {
+        request: ClientRequest,
+        response_tx: oneshot::Sender<Result<JsonValue, HarnessError>>,
+    },
+    Notify {
+        notification: ClientNotification,
+        response_tx: oneshot::Sender<Result<(), HarnessError>>,
+    },
+    Shutdown {
+        response_tx: oneshot::Sender<Result<(), HarnessError>>,
+    },
+}
+
+struct BrowserWorkerState {
+    api_key: String,
+    session_options: BrowserSessionOptions,
+    runtime_state: Arc<BrowserRuntimeState>,
+    event_handler: Rc<RefCell<Option<JsFunctionHandle>>>,
+    threads: HashMap<String, BrowserThreadHandle>,
+}
+
+struct BrowserThreadHandle {
+    config: Config,
+    thread: Arc<CodexThread>,
+    state: Rc<RefCell<BrowserThreadState>>,
+}
+
+struct BrowserThreadState {
+    thread: AppThread,
+}
+
 impl BrowserCodeModeRuntime {
     fn new(state: Arc<BrowserRuntimeState>) -> Self {
         Self { state }
     }
 }
 
-#[async_trait(?Send)]
+#[cfg_attr(not(target_arch = "wasm32"), async_trait::async_trait)]
+#[cfg_attr(target_arch = "wasm32", async_trait::async_trait(?Send))]
 impl CodeModeRuntime for BrowserCodeModeRuntime {
     async fn stored_values(&self) -> HashMap<String, JsonValue> {
         self.state
@@ -118,6 +190,13 @@ impl CodeModeRuntime for BrowserCodeModeRuntime {
         &self,
         request: codex_code_mode::ExecuteRequest,
     ) -> Result<codex_code_mode::RuntimeResponse, String> {
+        #[cfg(not(target_arch = "wasm32"))]
+        {
+            let _ = request;
+            return Err("browser code mode execution is only supported on wasm32".to_string());
+        }
+
+        #[cfg(target_arch = "wasm32")]
         let executor_request = JsExecutorRequest {
             source: request.source,
             stored_values: request.stored_values,
@@ -130,8 +209,10 @@ impl CodeModeRuntime for BrowserCodeModeRuntime {
                 })
                 .collect(),
         };
+        #[cfg(target_arch = "wasm32")]
         let executor_input = serde_json::to_string(&executor_request)
             .map_err(|error| format!("failed to serialize browser exec request: {error}"))?;
+        #[cfg(target_arch = "wasm32")]
         let executor = self
             .state
             .executor
@@ -139,28 +220,38 @@ impl CodeModeRuntime for BrowserCodeModeRuntime {
             .expect("browser code executor mutex poisoned")
             .clone()
             .ok_or_else(|| "no browser code executor is registered".to_string())?;
+        #[cfg(target_arch = "wasm32")]
         let value = executor
             .0
             .call1(&JsValue::NULL, &JsValue::from_str(&executor_input))
             .map_err(|error| js_value_to_string_lossy(&error))?;
+        #[cfg(target_arch = "wasm32")]
         let value = await_possible_promise(value)
             .await
             .map_err(|err| err.to_string())?;
+        #[cfg(target_arch = "wasm32")]
         let response_json = js_value_to_string(value).map_err(|err| err.to_string())?;
+        #[cfg(target_arch = "wasm32")]
         let response: JsExecutorResponse = serde_json::from_str(&response_json)
             .map_err(|error| format!("failed to parse browser exec response: {error}"))?;
+        #[cfg(target_arch = "wasm32")]
         let text = response.output.unwrap_or_default();
+        #[cfg(target_arch = "wasm32")]
         let content_items = if text.is_empty() {
             Vec::new()
         } else {
             vec![codex_code_mode::FunctionCallOutputContentItem::InputText { text }]
         };
-        Ok(codex_code_mode::RuntimeResponse::Result {
+        #[cfg(target_arch = "wasm32")]
+        return Ok(codex_code_mode::RuntimeResponse::Result {
             cell_id: request.tool_call_id,
             content_items,
             stored_values: response.stored_values,
             error_text: response.error_text,
-        })
+        });
+
+        #[allow(unreachable_code)]
+        Err("browser code mode execution is unavailable".to_string())
     }
 
     async fn wait(
@@ -183,255 +274,655 @@ impl CodeModeRuntime for BrowserCodeModeRuntime {
     }
 }
 
-struct BrowserSession {
-    config: Config,
-    thread: Arc<codex_core::CodexThread>,
-    session_configured: SessionConfiguredEvent,
-}
-
-struct JsEventSink<'a> {
-    on_event: &'a Function,
-}
-
-impl JsEventSink<'_> {
-    fn emit_debug(&self, stage: &str) -> Result<(), HarnessError> {
-        let payload = serde_json::json!({
-            "type": "debug",
-            "stage": stage,
-        });
-        let value = js_sys::JSON::parse(&payload.to_string()).map_err(js_exception)?;
-        self.on_event
-            .call1(&JsValue::NULL, &value)
-            .map_err(js_exception)?;
-        Ok(())
-    }
-
-    fn emit_event(&self, event: &Event) -> Result<(), HarnessError> {
-        let json = serde_json::to_string(event)?;
-        let value = js_sys::JSON::parse(&json).map_err(js_exception)?;
-        self.on_event
-            .call1(&JsValue::NULL, &value)
-            .map_err(js_exception)?;
-        Ok(())
-    }
-
-    fn emit_msg(&self, msg: EventMsg) -> Result<(), HarnessError> {
-        self.emit_event(&Event {
-            id: String::new(),
-            msg,
-        })
-    }
-}
-
-/// Browser entrypoint for the wasm Codex harness.
+/// Browser entrypoint for the wasm Codex app-server-shaped prototype.
 #[wasm_bindgen]
-pub struct BrowserCodex {
-    api_key: String,
-    runtime_state: Arc<BrowserRuntimeState>,
-    session: Option<BrowserSession>,
-    session_options: BrowserSessionOptions,
+pub struct BrowserAppServer {
+    command_tx: mpsc::UnboundedSender<BrowserCommand>,
 }
 
 #[wasm_bindgen]
-impl BrowserCodex {
+impl BrowserAppServer {
     #[wasm_bindgen(constructor)]
     #[must_use]
     pub fn new(api_key: String) -> Self {
-        Self {
-            api_key,
-            runtime_state: Arc::new(BrowserRuntimeState::default()),
-            session: None,
-            session_options: BrowserSessionOptions::default(),
-        }
+        let runtime_state = Arc::new(BrowserRuntimeState::default());
+        let (command_tx, command_rx) = mpsc::unbounded_channel();
+        wasm_bindgen_futures::spawn_local(async move {
+            let local = LocalSet::new();
+            local
+                .run_until(browser_worker_loop(command_rx, api_key, runtime_state))
+                .await;
+        });
+        Self { command_tx }
     }
 
-    pub fn set_api_key(&mut self, api_key: String) {
-        self.api_key = api_key;
-        self.session = None;
+    pub fn set_api_key(&self, api_key: String) -> Result<(), JsValue> {
+        self.command_tx
+            .send(BrowserCommand::SetApiKey(api_key))
+            .map_err(|_| HarnessError::new("browser worker is unavailable"))
+            .map_err(harness_error_to_js)
     }
 
     #[wasm_bindgen(js_name = setSessionOptions)]
-    pub fn set_session_options(&mut self, options: JsValue) -> Result<(), JsValue> {
+    pub fn set_session_options(&self, options: JsValue) -> Result<(), JsValue> {
         let parsed = parse_browser_session_options(options).map_err(harness_error_to_js)?;
-        if self.session_options != parsed {
-            self.session = None;
-        }
-        self.session_options = parsed;
-        Ok(())
+        self.command_tx
+            .send(BrowserCommand::SetSessionOptions(parsed))
+            .map_err(|_| HarnessError::new("browser worker is unavailable"))
+            .map_err(harness_error_to_js)
     }
 
     #[wasm_bindgen(js_name = clearSessionOptions)]
-    pub fn clear_session_options(&mut self) {
-        self.session_options = BrowserSessionOptions::default();
-        self.session = None;
+    pub fn clear_session_options(&self) -> Result<(), JsValue> {
+        self.command_tx
+            .send(BrowserCommand::SetSessionOptions(
+                BrowserSessionOptions::default(),
+            ))
+            .map_err(|_| HarnessError::new("browser worker is unavailable"))
+            .map_err(harness_error_to_js)
     }
 
-    pub fn set_code_executor(&mut self, executor: Function) {
-        *self
-            .runtime_state
-            .executor
-            .lock()
-            .expect("browser code executor mutex poisoned") = Some(JsFunctionHandle(executor));
+    #[wasm_bindgen(js_name = setEventHandler)]
+    pub fn set_event_handler(&self, handler: Function) -> Result<(), JsValue> {
+        self.command_tx
+            .send(BrowserCommand::SetEventHandler(Some(JsFunctionHandle(
+                handler,
+            ))))
+            .map_err(|_| HarnessError::new("browser worker is unavailable"))
+            .map_err(harness_error_to_js)
     }
 
-    pub fn clear_code_executor(&mut self) {
-        *self
-            .runtime_state
-            .executor
-            .lock()
-            .expect("browser code executor mutex poisoned") = None;
+    #[wasm_bindgen(js_name = clearEventHandler)]
+    pub fn clear_event_handler(&self) -> Result<(), JsValue> {
+        self.command_tx
+            .send(BrowserCommand::SetEventHandler(None))
+            .map_err(|_| HarnessError::new("browser worker is unavailable"))
+            .map_err(harness_error_to_js)
     }
 
-    pub async fn submit_turn(
-        &mut self,
-        prompt: String,
-        on_event: Function,
-    ) -> Result<JsValue, JsValue> {
-        let local = LocalSet::new();
-        let result = local
-            .run_until(self.submit_turn_inner(prompt, on_event))
-            .await;
-        // Local tasks spawned for a turn are scoped to this LocalSet, so the
-        // browser prototype starts a fresh harness session for each submission.
-        self.session = None;
-        result
+    pub fn set_code_executor(&self, executor: Function) -> Result<(), JsValue> {
+        self.command_tx
+            .send(BrowserCommand::SetCodeExecutor(Some(JsFunctionHandle(
+                executor,
+            ))))
+            .map_err(|_| HarnessError::new("browser worker is unavailable"))
+            .map_err(harness_error_to_js)
+    }
+
+    pub fn clear_code_executor(&self) -> Result<(), JsValue> {
+        self.command_tx
+            .send(BrowserCommand::SetCodeExecutor(None))
+            .map_err(|_| HarnessError::new("browser worker is unavailable"))
+            .map_err(harness_error_to_js)
+    }
+
+    pub async fn request(&self, request: JsValue) -> Result<JsValue, JsValue> {
+        let request: ClientRequest = parse_json_value(request).map_err(harness_error_to_js)?;
+        let (response_tx, response_rx) = oneshot::channel();
+        self.command_tx
+            .send(BrowserCommand::Request {
+                request,
+                response_tx,
+            })
+            .map_err(|_| HarnessError::new("browser worker is unavailable"))
+            .map_err(harness_error_to_js)?;
+        let response = response_rx
+            .await
+            .map_err(|_| HarnessError::new("browser worker response channel closed"))
+            .map_err(harness_error_to_js)?;
+        let json = response.map_err(harness_error_to_js)?;
+        json_value_to_js(json).map_err(harness_error_to_js)
+    }
+
+    pub async fn notify(&self, notification: JsValue) -> Result<(), JsValue> {
+        let notification: ClientNotification =
+            parse_json_value(notification).map_err(harness_error_to_js)?;
+        let (response_tx, response_rx) = oneshot::channel();
+        self.command_tx
+            .send(BrowserCommand::Notify {
+                notification,
+                response_tx,
+            })
+            .map_err(|_| HarnessError::new("browser worker is unavailable"))
+            .map_err(harness_error_to_js)?;
+        response_rx
+            .await
+            .map_err(|_| HarnessError::new("browser worker response channel closed"))
+            .map_err(harness_error_to_js)?
+            .map_err(harness_error_to_js)
+    }
+
+    pub async fn shutdown(&self) -> Result<(), JsValue> {
+        let (response_tx, response_rx) = oneshot::channel();
+        self.command_tx
+            .send(BrowserCommand::Shutdown { response_tx })
+            .map_err(|_| HarnessError::new("browser worker is unavailable"))
+            .map_err(harness_error_to_js)?;
+        response_rx
+            .await
+            .map_err(|_| HarnessError::new("browser worker response channel closed"))
+            .map_err(harness_error_to_js)?
+            .map_err(harness_error_to_js)
     }
 }
 
-impl BrowserCodex {
-    async fn submit_turn_inner(
-        &mut self,
-        prompt: String,
-        on_event: Function,
-    ) -> Result<JsValue, JsValue> {
-        if self.api_key.trim().is_empty() {
-            return Err(harness_error_to_js(HarnessError::new(
-                "an OpenAI API key is required to run the real Codex harness",
-            )));
-        }
+async fn browser_worker_loop(
+    mut command_rx: mpsc::UnboundedReceiver<BrowserCommand>,
+    api_key: String,
+    runtime_state: Arc<BrowserRuntimeState>,
+) {
+    let event_handler = Rc::new(RefCell::new(None::<JsFunctionHandle>));
+    let mut state = BrowserWorkerState {
+        api_key,
+        session_options: BrowserSessionOptions::default(),
+        runtime_state,
+        event_handler,
+        threads: HashMap::new(),
+    };
+    emit_debug(&state.event_handler, "worker:ready");
 
-        let sink = JsEventSink {
-            on_event: &on_event,
-        };
-        sink.emit_debug("submit_turn:start")
-            .map_err(harness_error_to_js)?;
-        let session = if let Some(session) = self.session.as_ref() {
-            sink.emit_debug("submit_turn:reuse_session")
-                .map_err(harness_error_to_js)?;
-            session
-        } else {
-            sink.emit_debug("submit_turn:create_session")
-                .map_err(harness_error_to_js)?;
-            let session = self.create_session().await.map_err(|error| {
-                harness_error_to_js(HarnessError::new(format!("create_session failed: {error}")))
-            })?;
-            sink.emit_msg(EventMsg::SessionConfigured(
-                session.session_configured.clone(),
-            ))
-            .map_err(harness_error_to_js)?;
-            self.session = Some(session);
-            sink.emit_debug("submit_turn:session_created")
-                .map_err(harness_error_to_js)?;
-            self.session
-                .as_ref()
-                .expect("browser session just initialized")
-        };
-
-        sink.emit_debug("submit_turn:calling_submit")
-            .map_err(harness_error_to_js)?;
-        let submission_id = session
-            .thread
-            .submit(Op::UserTurn {
-                items: vec![UserInput::Text {
-                    text: prompt,
-                    text_elements: Vec::new(),
-                }],
-                cwd: session.config.cwd.as_path().to_path_buf(),
-                approval_policy: session.config.permissions.approval_policy.get().clone(),
-                approvals_reviewer: Some(session.config.approvals_reviewer),
-                sandbox_policy: session.config.permissions.sandbox_policy.get().clone(),
-                model: session
-                    .config
-                    .model
-                    .clone()
-                    .unwrap_or_else(|| DEFAULT_MODEL.to_string()),
-                effort: session.config.model_reasoning_effort,
-                summary: session.config.model_reasoning_summary,
-                service_tier: None,
-                final_output_json_schema: None,
-                collaboration_mode: None,
-                personality: None,
-            })
-            .await
-            .map_err(|error| {
-                harness_error_to_js(HarnessError::new(format!("submit failed: {error}")))
-            })?;
-        sink.emit_debug("submit_turn:submit_returned")
-            .map_err(harness_error_to_js)?;
-
-        loop {
-            let event = session.thread.next_event().await.map_err(|error| {
-                harness_error_to_js(HarnessError::new(format!("next_event failed: {error}")))
-            })?;
-            sink.emit_event(&event).map_err(harness_error_to_js)?;
-            if event.id == submission_id
-                && matches!(
-                    event.msg,
-                    EventMsg::TurnComplete(_) | EventMsg::TurnAborted(_) | EventMsg::Error(_)
-                )
-            {
+    while let Some(command) = command_rx.recv().await {
+        match command {
+            BrowserCommand::SetApiKey(api_key) => {
+                if state.api_key != api_key {
+                    if let Err(error) = reset_threads(&mut state).await {
+                        emit_debug(
+                            &state.event_handler,
+                            &format!("reset_threads:error:{error}"),
+                        );
+                    }
+                    state.api_key = api_key;
+                }
+            }
+            BrowserCommand::SetSessionOptions(options) => {
+                if state.session_options != options {
+                    if let Err(error) = reset_threads(&mut state).await {
+                        emit_debug(
+                            &state.event_handler,
+                            &format!("reset_threads:error:{error}"),
+                        );
+                    }
+                    state.session_options = options;
+                }
+            }
+            BrowserCommand::SetEventHandler(handler) => {
+                *state.event_handler.borrow_mut() = handler;
+            }
+            BrowserCommand::SetCodeExecutor(executor) => {
+                *state
+                    .runtime_state
+                    .executor
+                    .lock()
+                    .expect("browser code executor mutex poisoned") = executor;
+            }
+            BrowserCommand::Request {
+                request,
+                response_tx,
+            } => {
+                let response = handle_request(&mut state, request).await;
+                let _ = response_tx.send(response);
+            }
+            BrowserCommand::Notify {
+                notification,
+                response_tx,
+            } => {
+                let response = match notification {
+                    ClientNotification::Initialized => Ok(()),
+                };
+                let _ = response_tx.send(response);
+            }
+            BrowserCommand::Shutdown { response_tx } => {
+                let response = reset_threads(&mut state).await;
+                let _ = response_tx.send(response);
                 break;
             }
         }
-
-        Ok(JsValue::from_str(&submission_id))
-    }
-
-    async fn create_session(&self) -> Result<BrowserSession, HarnessError> {
-        let config = build_browser_config(&self.session_options)?;
-        let auth_manager =
-            AuthManager::from_auth_for_testing(CodexAuth::from_api_key(self.api_key.trim()));
-        let environment_manager = Arc::new(EnvironmentManager::new(None));
-        let manager = ThreadManager::new(
-            &config,
-            auth_manager,
-            SessionSource::Custom("codex_wasm".to_string()),
-            CollaborationModesConfig::default(),
-            environment_manager,
-        );
-        let thread = manager
-            .start_thread_with_code_mode_runtime(
-                config.clone(),
-                Arc::new(BrowserCodeModeRuntime::new(Arc::clone(&self.runtime_state))),
-            )
-            .await
-            .map_err(|error| {
-                HarnessError::new(format!("start_thread_with_code_mode_runtime: {error}"))
-            })?;
-        Ok(BrowserSession {
-            config,
-            thread: thread.thread,
-            session_configured: thread.session_configured,
-        })
     }
 }
 
-fn build_browser_config(session_options: &BrowserSessionOptions) -> Result<Config, HarnessError> {
-    let cwd = session_options.cwd.as_deref().unwrap_or(BROWSER_CWD);
-    let mut config =
-        Config::load_embedded_defaults(PathBuf::from(BROWSER_CODEX_HOME), PathBuf::from(cwd))
-            .map_err(|error| HarnessError::new(error.to_string()))?;
+async fn handle_request(
+    state: &mut BrowserWorkerState,
+    request: ClientRequest,
+) -> Result<JsonValue, HarnessError> {
+    emit_debug(
+        &state.event_handler,
+        &format!("request:{}", request.method()),
+    );
+    match request {
+        ClientRequest::ThreadStart { params, .. } => {
+            let response = handle_thread_start(state, params).await?;
+            serde_json::to_value(response).map_err(Into::into)
+        }
+        ClientRequest::ThreadRead { params, .. } => {
+            let response = handle_thread_read(state, params.thread_id, params.include_turns)?;
+            serde_json::to_value(response).map_err(Into::into)
+        }
+        ClientRequest::TurnStart { params, .. } => {
+            let response = handle_turn_start(state, params).await?;
+            serde_json::to_value(response).map_err(Into::into)
+        }
+        ClientRequest::TurnInterrupt { params, .. } => {
+            let response = handle_turn_interrupt(state, params.thread_id).await?;
+            serde_json::to_value(response).map_err(Into::into)
+        }
+        ClientRequest::TurnSteer { params, .. } => {
+            let response = handle_turn_steer(
+                state,
+                params.thread_id,
+                params.input,
+                params.expected_turn_id,
+            )
+            .await?;
+            serde_json::to_value(response).map_err(Into::into)
+        }
+        unsupported => Err(HarnessError::new(format!(
+            "unsupported browser request method: {}",
+            unsupported.method()
+        ))),
+    }
+}
+
+async fn handle_thread_start(
+    state: &mut BrowserWorkerState,
+    params: ThreadStartParams,
+) -> Result<ThreadStartResponse, HarnessError> {
+    if state.api_key.trim().is_empty() {
+        return Err(HarnessError::new(
+            "an OpenAI API key is required to run the browser app-server prototype",
+        ));
+    }
+
+    let config = build_browser_config(&state.session_options, Some(&params))?;
+    let auth_manager =
+        AuthManager::from_auth_for_testing(CodexAuth::from_api_key(state.api_key.trim()));
+    let environment_manager = Arc::new(EnvironmentManager::new(None));
+    let manager = ThreadManager::new(
+        &config,
+        auth_manager,
+        SessionSource::Custom("codex_wasm".to_string()),
+        CollaborationModesConfig::default(),
+        environment_manager,
+    );
+    let new_thread = manager
+        .start_thread_with_code_mode_runtime(
+            config.clone(),
+            Arc::new(BrowserCodeModeRuntime::new(Arc::clone(
+                &state.runtime_state,
+            ))),
+        )
+        .await
+        .map_err(|error| {
+            HarnessError::new(format!("start_thread_with_code_mode_runtime: {error}"))
+        })?;
+
+    let config_snapshot = new_thread.thread.config_snapshot().await;
+    let created_at = now_seconds();
+    let session_source = config_snapshot.session_source.clone();
+    let app_thread = AppThread {
+        id: new_thread.thread_id.to_string(),
+        preview: String::new(),
+        ephemeral: config.ephemeral,
+        model_provider: config_snapshot.model_provider_id.clone(),
+        created_at,
+        updated_at: created_at,
+        status: ThreadStatus::Idle,
+        path: None,
+        cwd: config.cwd.to_path_buf(),
+        cli_version: env!("CARGO_PKG_VERSION").to_string(),
+        source: AppSessionSource::from(session_source.clone()),
+        agent_nickname: session_source.get_nickname(),
+        agent_role: session_source.get_agent_role(),
+        git_info: None,
+        name: None,
+        turns: Vec::new(),
+    };
+    let thread_state = Rc::new(RefCell::new(BrowserThreadState {
+        thread: app_thread.clone(),
+    }));
+    let thread_id = app_thread.id.clone();
+    let thread = Arc::clone(&new_thread.thread);
+    let event_handler = Rc::clone(&state.event_handler);
+    let listener_state = Rc::clone(&thread_state);
+    tokio::task::spawn_local(async move {
+        run_thread_listener(thread_id, thread, listener_state, event_handler).await;
+    });
+
+    state.threads.insert(
+        app_thread.id.clone(),
+        BrowserThreadHandle {
+            config,
+            thread: new_thread.thread,
+            state: Rc::clone(&thread_state),
+        },
+    );
+
+    emit_notification(
+        &state.event_handler,
+        ServerNotification::ThreadStarted(ThreadStartedNotification {
+            thread: app_thread.clone(),
+        }),
+    )?;
+
+    Ok(ThreadStartResponse {
+        thread: app_thread,
+        model: config_snapshot.model,
+        model_provider: config_snapshot.model_provider_id,
+        service_tier: config_snapshot.service_tier,
+        approval_policy: AskForApproval::from(config_snapshot.approval_policy),
+        approvals_reviewer: ApprovalsReviewer::from(config_snapshot.approvals_reviewer),
+        sandbox: AppSandboxPolicy::from(config_snapshot.sandbox_policy),
+        cwd: config_snapshot.cwd,
+        reasoning_effort: config_snapshot.reasoning_effort,
+    })
+}
+
+fn handle_thread_read(
+    state: &BrowserWorkerState,
+    thread_id: String,
+    include_turns: bool,
+) -> Result<ThreadReadResponse, HarnessError> {
+    let handle = state
+        .threads
+        .get(&thread_id)
+        .ok_or_else(|| HarnessError::new(format!("unknown thread id: {thread_id}")))?;
+    let mut thread = handle.state.borrow().thread.clone();
+    if !include_turns {
+        thread.turns.clear();
+    }
+    Ok(ThreadReadResponse { thread })
+}
+
+async fn handle_turn_start(
+    state: &mut BrowserWorkerState,
+    params: TurnStartParams,
+) -> Result<TurnStartResponse, HarnessError> {
+    let handle = state
+        .threads
+        .get(&params.thread_id)
+        .ok_or_else(|| HarnessError::new(format!("unknown thread id: {}", params.thread_id)))?;
+
+    if let Some(preview) = first_text_preview(&params.input) {
+        let mut thread_state = handle.state.borrow_mut();
+        if thread_state.thread.preview.is_empty() {
+            thread_state.thread.preview = preview;
+        }
+    }
+
+    let items = params
+        .input
+        .clone()
+        .into_iter()
+        .map(codex_app_server_protocol::UserInput::into_core)
+        .collect();
+
+    let submission_id = handle
+        .thread
+        .submit(Op::UserTurn {
+            items,
+            cwd: params
+                .cwd
+                .unwrap_or_else(|| handle.config.cwd.as_path().to_path_buf()),
+            approval_policy: params
+                .approval_policy
+                .map(AskForApproval::to_core)
+                .unwrap_or_else(|| handle.config.permissions.approval_policy.get().clone()),
+            approvals_reviewer: params
+                .approvals_reviewer
+                .map(ApprovalsReviewer::to_core)
+                .or(Some(handle.config.approvals_reviewer)),
+            sandbox_policy: params
+                .sandbox_policy
+                .as_ref()
+                .map(AppSandboxPolicy::to_core)
+                .unwrap_or_else(|| handle.config.permissions.sandbox_policy.get().clone()),
+            model: params.model.unwrap_or_else(|| {
+                handle
+                    .config
+                    .model
+                    .clone()
+                    .unwrap_or_else(|| DEFAULT_MODEL.to_string())
+            }),
+            effort: params.effort.or(handle.config.model_reasoning_effort),
+            summary: params.summary.or(handle.config.model_reasoning_summary),
+            service_tier: params.service_tier,
+            final_output_json_schema: params.output_schema,
+            collaboration_mode: None,
+            personality: params.personality,
+        })
+        .await
+        .map_err(|error| HarnessError::new(format!("turn/start failed: {error}")))?;
+
+    {
+        let mut thread_state = handle.state.borrow_mut();
+        thread_state.thread.status = ThreadStatus::Active {
+            active_flags: Vec::new(),
+        };
+        thread_state.thread.updated_at = now_seconds();
+        upsert_turn(
+            &mut thread_state.thread.turns,
+            AppTurn {
+                id: submission_id.clone(),
+                items: Vec::new(),
+                status: TurnStatus::InProgress,
+                error: None,
+            },
+        );
+    }
+
+    Ok(TurnStartResponse {
+        turn: AppTurn {
+            id: submission_id,
+            items: Vec::new(),
+            status: TurnStatus::InProgress,
+            error: None,
+        },
+    })
+}
+
+async fn handle_turn_interrupt(
+    state: &BrowserWorkerState,
+    thread_id: String,
+) -> Result<TurnInterruptResponse, HarnessError> {
+    let handle = state
+        .threads
+        .get(&thread_id)
+        .ok_or_else(|| HarnessError::new(format!("unknown thread id: {thread_id}")))?;
+    handle
+        .thread
+        .submit(Op::Interrupt)
+        .await
+        .map_err(|error| HarnessError::new(format!("turn/interrupt failed: {error}")))?;
+    Ok(TurnInterruptResponse {})
+}
+
+async fn handle_turn_steer(
+    state: &BrowserWorkerState,
+    thread_id: String,
+    input: Vec<codex_app_server_protocol::UserInput>,
+    expected_turn_id: String,
+) -> Result<TurnSteerResponse, HarnessError> {
+    let handle = state
+        .threads
+        .get(&thread_id)
+        .ok_or_else(|| HarnessError::new(format!("unknown thread id: {thread_id}")))?;
+    let turn_id = handle
+        .thread
+        .steer_input(
+            input
+                .into_iter()
+                .map(codex_app_server_protocol::UserInput::into_core)
+                .collect(),
+            Some(expected_turn_id.as_str()),
+        )
+        .await
+        .map_err(|error| HarnessError::new(format!("turn/steer failed: {error:?}")))?;
+    Ok(TurnSteerResponse { turn_id })
+}
+
+async fn reset_threads(state: &mut BrowserWorkerState) -> Result<(), HarnessError> {
+    let threads = state
+        .threads
+        .drain()
+        .map(|(_, handle)| handle.thread)
+        .collect::<Vec<_>>();
+    for thread in threads {
+        thread
+            .shutdown_and_wait()
+            .await
+            .map_err(|error| HarnessError::new(format!("thread shutdown failed: {error}")))?;
+    }
+    Ok(())
+}
+
+async fn run_thread_listener(
+    thread_id: String,
+    thread: Arc<CodexThread>,
+    thread_state: Rc<RefCell<BrowserThreadState>>,
+    event_handler: Rc<RefCell<Option<JsFunctionHandle>>>,
+) {
+    loop {
+        let event = match thread.next_event().await {
+            Ok(event) => event,
+            Err(error) => {
+                emit_debug(&event_handler, &format!("thread_listener:error:{error}"));
+                break;
+            }
+        };
+        emit_raw_core_event(&event_handler, event.clone());
+        match event.msg {
+            EventMsg::TurnStarted(turn) => {
+                let turn_snapshot = {
+                    let mut state = thread_state.borrow_mut();
+                    state.thread.status = ThreadStatus::Active {
+                        active_flags: Vec::new(),
+                    };
+                    state.thread.updated_at = now_seconds();
+                    let turn_snapshot = AppTurn {
+                        id: turn.turn_id.clone(),
+                        items: Vec::new(),
+                        status: TurnStatus::InProgress,
+                        error: None,
+                    };
+                    upsert_turn(&mut state.thread.turns, turn_snapshot.clone());
+                    turn_snapshot
+                };
+                let _ = emit_notification(
+                    &event_handler,
+                    ServerNotification::TurnStarted(TurnStartedNotification {
+                        thread_id: thread_id.clone(),
+                        turn: turn_snapshot,
+                    }),
+                );
+            }
+            EventMsg::TurnComplete(turn) => {
+                let turn_snapshot = {
+                    let mut state = thread_state.borrow_mut();
+                    state.thread.status = ThreadStatus::Idle;
+                    state.thread.updated_at = now_seconds();
+                    let turn_snapshot = AppTurn {
+                        id: turn.turn_id.clone(),
+                        items: Vec::new(),
+                        status: TurnStatus::Completed,
+                        error: None,
+                    };
+                    upsert_turn(&mut state.thread.turns, turn_snapshot.clone());
+                    turn_snapshot
+                };
+                let _ = emit_notification(
+                    &event_handler,
+                    ServerNotification::TurnCompleted(TurnCompletedNotification {
+                        thread_id: thread_id.clone(),
+                        turn: turn_snapshot,
+                    }),
+                );
+            }
+            EventMsg::TurnAborted(turn) => {
+                if let Some(turn_id) = turn.turn_id {
+                    let turn_snapshot = {
+                        let mut state = thread_state.borrow_mut();
+                        state.thread.status = ThreadStatus::Idle;
+                        state.thread.updated_at = now_seconds();
+                        let turn_snapshot = AppTurn {
+                            id: turn_id.clone(),
+                            items: Vec::new(),
+                            status: TurnStatus::Interrupted,
+                            error: None,
+                        };
+                        upsert_turn(&mut state.thread.turns, turn_snapshot.clone());
+                        turn_snapshot
+                    };
+                    let _ = emit_notification(
+                        &event_handler,
+                        ServerNotification::TurnCompleted(TurnCompletedNotification {
+                            thread_id: thread_id.clone(),
+                            turn: turn_snapshot,
+                        }),
+                    );
+                }
+            }
+            _ => {}
+        }
+    }
+}
+
+fn upsert_turn(turns: &mut Vec<AppTurn>, turn: AppTurn) {
+    if let Some(existing) = turns.iter_mut().find(|existing| existing.id == turn.id) {
+        *existing = turn;
+    } else {
+        turns.push(turn);
+    }
+}
+
+fn first_text_preview(input: &[codex_app_server_protocol::UserInput]) -> Option<String> {
+    input.iter().find_map(|item| match item {
+        codex_app_server_protocol::UserInput::Text { text, .. } => Some(text.clone()),
+        _ => None,
+    })
+}
+
+fn build_browser_config(
+    session_options: &BrowserSessionOptions,
+    thread_start: Option<&ThreadStartParams>,
+) -> Result<Config, HarnessError> {
+    build_browser_config_at(
+        session_options,
+        thread_start,
+        PathBuf::from(BROWSER_CODEX_HOME),
+    )
+}
+
+fn build_browser_config_at(
+    session_options: &BrowserSessionOptions,
+    thread_start: Option<&ThreadStartParams>,
+    codex_home: PathBuf,
+) -> Result<Config, HarnessError> {
+    let cwd = thread_start
+        .and_then(|params| params.cwd.as_deref())
+        .or(session_options.cwd.as_deref())
+        .unwrap_or(BROWSER_CWD);
+    let mut config = Config::load_embedded_defaults(codex_home, PathBuf::from(cwd))
+        .map_err(|error| HarnessError::new(error.to_string()))?;
     let _ = config.features.enable(Feature::CodeMode);
     let _ = config.features.enable(Feature::CodeModeOnly);
-    config.model = Some(
-        config
-            .model
-            .clone()
-            .unwrap_or_else(|| DEFAULT_MODEL.to_string()),
-    );
-    config.base_instructions = session_options.instructions.base.clone();
-    config.developer_instructions = session_options.instructions.developer.clone();
+    config.model = thread_start
+        .and_then(|params| params.model.clone())
+        .or_else(|| config.model.clone())
+        .or_else(|| Some(DEFAULT_MODEL.to_string()));
+    config.base_instructions = thread_start
+        .and_then(|params| params.base_instructions.clone())
+        .or_else(|| session_options.instructions.base.clone());
+    config.developer_instructions = thread_start
+        .and_then(|params| params.developer_instructions.clone())
+        .or_else(|| session_options.instructions.developer.clone());
     config.user_instructions = session_options.instructions.user.clone();
+    if let Some(params) = thread_start {
+        if let Some(model_provider) = params.model_provider.clone() {
+            config.model_provider_id = model_provider;
+        }
+        if let Some(ephemeral) = params.ephemeral {
+            config.ephemeral = ephemeral;
+        }
+    }
     Ok(config)
 }
 
@@ -448,6 +939,65 @@ fn parse_browser_session_options(options: JsValue) -> Result<BrowserSessionOptio
         .map_err(|error| HarnessError::new(format!("invalid browser session options: {error}")))
 }
 
+fn parse_json_value<T>(value: JsValue) -> Result<T, HarnessError>
+where
+    T: for<'de> Deserialize<'de>,
+{
+    let text = js_sys::JSON::stringify(&value)
+        .map_err(js_exception)?
+        .as_string()
+        .ok_or_else(|| HarnessError::new("javascript value must be JSON-serializable"))?;
+    serde_json::from_str(&text).map_err(|error| HarnessError::new(error.to_string()))
+}
+
+fn emit_debug(event_handler: &Rc<RefCell<Option<JsFunctionHandle>>>, stage: &str) {
+    let payload = DebugEvent {
+        r#type: "debug",
+        stage,
+    };
+    let _ = emit_payload(event_handler, &payload);
+}
+
+fn emit_raw_core_event(event_handler: &Rc<RefCell<Option<JsFunctionHandle>>>, event: Event) {
+    let payload = RawCoreEventEnvelope {
+        r#type: "coreEvent",
+        event,
+    };
+    let _ = emit_payload(event_handler, &payload);
+}
+
+fn emit_notification(
+    event_handler: &Rc<RefCell<Option<JsFunctionHandle>>>,
+    notification: ServerNotification,
+) -> Result<(), HarnessError> {
+    emit_payload(event_handler, &notification)
+}
+
+fn emit_payload<T: Serialize>(
+    event_handler: &Rc<RefCell<Option<JsFunctionHandle>>>,
+    payload: &T,
+) -> Result<(), HarnessError> {
+    let Some(handler) = event_handler.borrow().clone() else {
+        return Ok(());
+    };
+    let value = serde_json::to_value(payload)?;
+    let js_value = json_value_to_js(value)?;
+    handler
+        .0
+        .call1(&JsValue::NULL, &js_value)
+        .map_err(js_exception)?;
+    Ok(())
+}
+
+fn json_value_to_js(value: JsonValue) -> Result<JsValue, HarnessError> {
+    let text = serde_json::to_string(&value)?;
+    js_sys::JSON::parse(&text).map_err(js_exception)
+}
+
+fn now_seconds() -> i64 {
+    (js_sys::Date::now() / 1000.0).floor() as i64
+}
+
 async fn await_possible_promise(value: JsValue) -> Result<JsValue, HarnessError> {
     if let Ok(promise) = value.clone().dyn_into::<Promise>() {
         JsFuture::from(promise).await.map_err(js_exception)
@@ -494,19 +1044,34 @@ fn harness_error_to_js(error: HarnessError) -> JsValue {
 mod tests {
     use super::BrowserInstructionOverrides;
     use super::BrowserSessionOptions;
-    use super::build_browser_config;
+    use super::build_browser_config_at;
+    use codex_app_server_protocol::ThreadStartParams;
     use pretty_assertions::assert_eq;
+    use std::path::PathBuf;
+
+    fn test_codex_home(test_name: &str) -> PathBuf {
+        let path = std::env::temp_dir().join(format!(
+            "codex-wasm-harness-{test_name}-{}",
+            std::process::id()
+        ));
+        std::fs::create_dir_all(&path).expect("create temp codex home");
+        path
+    }
 
     #[test]
     fn build_browser_config_applies_session_options() {
-        let config = build_browser_config(&BrowserSessionOptions {
-            cwd: Some("/workspace/repo".to_string()),
-            instructions: BrowserInstructionOverrides {
-                base: Some("base".to_string()),
-                developer: Some("developer".to_string()),
-                user: Some("user".to_string()),
+        let config = build_browser_config_at(
+            &BrowserSessionOptions {
+                cwd: Some("/workspace/repo".to_string()),
+                instructions: BrowserInstructionOverrides {
+                    base: Some("base".to_string()),
+                    developer: Some("developer".to_string()),
+                    user: Some("user".to_string()),
+                },
             },
-        })
+            None,
+            test_codex_home("session-options"),
+        )
         .expect("browser config");
 
         assert_eq!(config.cwd.as_path().to_string_lossy(), "/workspace/repo");
@@ -516,10 +1081,26 @@ mod tests {
     }
 
     #[test]
-    fn build_browser_config_defaults_to_workspace_cwd() {
-        let config =
-            build_browser_config(&BrowserSessionOptions::default()).expect("browser config");
+    fn build_browser_config_applies_thread_start_overrides() {
+        let config = build_browser_config_at(
+            &BrowserSessionOptions::default(),
+            Some(&ThreadStartParams {
+                model: Some("gpt-test".to_string()),
+                cwd: Some("/workspace/override".to_string()),
+                base_instructions: Some("base".to_string()),
+                developer_instructions: Some("developer".to_string()),
+                ..ThreadStartParams::default()
+            }),
+            test_codex_home("thread-start"),
+        )
+        .expect("browser config");
 
-        assert_eq!(config.cwd.as_path().to_string_lossy(), "/workspace");
+        assert_eq!(
+            config.cwd.as_path().to_string_lossy(),
+            "/workspace/override"
+        );
+        assert_eq!(config.model.as_deref(), Some("gpt-test"));
+        assert_eq!(config.base_instructions.as_deref(), Some("base"));
+        assert_eq!(config.developer_instructions.as_deref(), Some("developer"));
     }
 }
diff --git a/codex-rs/wasm-harness/src/lib.rs b/codex-rs/wasm-harness/src/lib.rs
index db2c45629e..9fa4e6c821 100644
--- a/codex-rs/wasm-harness/src/lib.rs
+++ b/codex-rs/wasm-harness/src/lib.rs
@@ -1,5 +1,5 @@
 mod browser;
 mod error;
 
-pub use browser::BrowserCodex;
+pub use browser::BrowserAppServer;
 pub use error::HarnessError;