Start TUI on embedded app server (#14512)

This PR is part of the effort to move the TUI on top of the app server.
In a previous PR, we introduced an in-process app server and moved
`exec` on top of it.

For the TUI, we want to do the migration in stages. The app server
doesn't currently expose all of the functionality required by the TUI,
so we're going to need to support a hybrid approach as we make the
transition.

This PR changes the TUI initialization to instantiate an in-process app
server and access its `AuthManager` and `ThreadManager` rather than
constructing its own copies. It also adds a placeholder TUI event
handler that will eventually translate app server events into TUI
events. App server notifications are accepted but ignored for now. It
also adds proper shutdown of the app server when the TUI terminates.

codex-rs/tui/src/app/app_server_adapter.rs

@@ -0,0 +1,72 @@
+/*
+This module holds the temporary adapter layer between the TUI and the app
+server during the hybrid migration period.
+
+For now, the TUI still owns its existing direct-core behavior, but startup
+allocates a local in-process app server and drains its event stream. Keeping
+the app-server-specific wiring here keeps that transitional logic out of the
+main `app.rs` orchestration path.
+
+As more TUI flows move onto the app-server surface directly, this adapter
+should shrink and eventually disappear.
+*/
+
+use super::App;
+use codex_app_server_client::InProcessAppServerClient;
+use codex_app_server_client::InProcessServerEvent;
+use codex_app_server_protocol::JSONRPCErrorError;
+
+impl App {
+    pub(super) async fn handle_app_server_event(
+        &mut self,
+        app_server_client: &InProcessAppServerClient,
+        event: InProcessServerEvent,
+    ) {
+        match event {
+            InProcessServerEvent::Lagged { skipped } => {
+                tracing::warn!(
+                    skipped,
+                    "app-server event consumer lagged; dropping ignored events"
+                );
+            }
+            InProcessServerEvent::ServerNotification(_) => {}
+            InProcessServerEvent::LegacyNotification(_) => {}
+            InProcessServerEvent::ServerRequest(request) => {
+                let request_id = request.id().clone();
+                tracing::warn!(
+                    ?request_id,
+                    "rejecting app-server request while TUI still uses direct core APIs"
+                );
+                if let Err(err) = self
+                    .reject_app_server_request(
+                        app_server_client,
+                        request_id,
+                        "TUI client does not yet handle this app-server server request".to_string(),
+                    )
+                    .await
+                {
+                    tracing::warn!("{err}");
+                }
+            }
+        }
+    }
+
+    async fn reject_app_server_request(
+        &self,
+        app_server_client: &InProcessAppServerClient,
+        request_id: codex_app_server_protocol::RequestId,
+        reason: String,
+    ) -> std::result::Result<(), String> {
+        app_server_client
+            .reject_server_request(
+                request_id,
+                JSONRPCErrorError {
+                    code: -32000,
+                    message: reason,
+                    data: None,
+                },
+            )
+            .await
+            .map_err(|err| format!("failed to reject app-server request: {err}"))
+    }
+}