fix(tui): align rebased thread events and extract legacy bridge

Restore `HistoryEntryResponse` buffering on the rebased app-server
thread pipeline so history lookups still replay and route correctly after
moving onto `upstream/main`.

Extract the remote legacy exec-approval bridge into a dedicated helper in
`app_server_adapter.rs` so the special-case path is isolated from normal
server request handling.

Author: fcoury

codex-rs/tui_app_server/src/app.rs

@@ -618,6 +618,7 @@ impl ThreadEventStore {
                         .pending_interactive_replay
                         .should_replay_snapshot_request(request),
                     ThreadBufferedEvent::Notification(_)
+                    | ThreadBufferedEvent::HistoryEntryResponse(_)
                     | ThreadBufferedEvent::LegacyWarning(_)
                     | ThreadBufferedEvent::LegacyRollback { .. } => true,
                 })
@@ -2379,6 +2380,50 @@ impl App {
         Ok(())
     }
 
+    async fn enqueue_thread_history_entry_response(
+        &mut self,
+        thread_id: ThreadId,
+        event: GetHistoryEntryResponseEvent,
+    ) -> Result<()> {
+        let (sender, store) = {
+            let channel = self.ensure_thread_channel(thread_id);
+            (channel.sender.clone(), Arc::clone(&channel.store))
+        };
+
+        let should_send = {
+            let mut guard = store.lock().await;
+            guard
+                .buffer
+                .push_back(ThreadBufferedEvent::HistoryEntryResponse(event.clone()));
+            if guard.buffer.len() > guard.capacity
+                && let Some(removed) = guard.buffer.pop_front()
+                && let ThreadBufferedEvent::Request(request) = &removed
+            {
+                guard
+                    .pending_interactive_replay
+                    .note_evicted_server_request(request);
+            }
+            guard.active
+        };
+
+        if should_send {
+            match sender.try_send(ThreadBufferedEvent::HistoryEntryResponse(event)) {
+                Ok(()) => {}
+                Err(TrySendError::Full(event)) => {
+                    tokio::spawn(async move {
+                        if let Err(err) = sender.send(event).await {
+                            tracing::warn!("thread {thread_id} event channel closed: {err}");
+                        }
+                    });
+                }
+                Err(TrySendError::Closed(_)) => {
+                    tracing::warn!("thread {thread_id} event channel closed");
+                }
+            }
+        }
+        Ok(())
+    }
+
     async fn enqueue_thread_legacy_rollback(
         &mut self,
         thread_id: ThreadId,
@@ -2470,6 +2515,10 @@ impl App {
                 ThreadBufferedEvent::Request(request) => {
                     self.enqueue_thread_request(thread_id, request).await?;
                 }
+                ThreadBufferedEvent::HistoryEntryResponse(event) => {
+                    self.enqueue_thread_history_entry_response(thread_id, event)
+                        .await?;
+                }
                 ThreadBufferedEvent::LegacyWarning(message) => {
                     self.enqueue_thread_legacy_warning(thread_id, message)
                         .await?;
@@ -4795,6 +4844,9 @@ impl App {
                 self.chat_widget
                     .handle_server_request(request, /*replay_kind*/ None);
             }
+            ThreadBufferedEvent::HistoryEntryResponse(event) => {
+                self.chat_widget.handle_history_entry_response(event);
+            }
             ThreadBufferedEvent::LegacyWarning(message) => {
                 self.chat_widget.add_warning_message(message);
             }
@@ -4816,6 +4868,9 @@ impl App {
             ThreadBufferedEvent::Request(request) => self
                 .chat_widget
                 .handle_server_request(request, Some(ReplayKind::ThreadSnapshot)),
+            ThreadBufferedEvent::HistoryEntryResponse(event) => {
+                self.chat_widget.handle_history_entry_response(event)
+            }
             ThreadBufferedEvent::LegacyWarning(message) => {
                 self.chat_widget.add_warning_message(message);
             }

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

@@ -164,63 +164,10 @@ impl App {
         app_server_client: &AppServerSession,
         request: ServerRequest,
     ) {
-        if app_server_client.is_remote()
-            && let ServerRequest::ExecCommandApproval { .. } = &request
+        if self
+            .try_handle_legacy_remote_exec_approval_request(app_server_client, &request)
+            .await
         {
-            match bridge_legacy_exec_approval_request(&request) {
-                Ok((thread_id, bridged_request)) => {
-                    if let Some(unsupported) = self
-                        .pending_app_server_requests
-                        .note_server_request(&request)
-                    {
-                        tracing::warn!(
-                            request_id = ?unsupported.request_id,
-                            message = unsupported.message,
-                            "rejecting unsupported app-server request"
-                        );
-                        self.chat_widget
-                            .add_error_message(unsupported.message.clone());
-                        if let Err(err) = self
-                            .reject_app_server_request(
-                                app_server_client,
-                                unsupported.request_id,
-                                unsupported.message,
-                            )
-                            .await
-                        {
-                            tracing::warn!("{err}");
-                        }
-                        return;
-                    }
-
-                    let result = if self.primary_thread_id == Some(thread_id)
-                        || self.primary_thread_id.is_none()
-                    {
-                        self.enqueue_primary_thread_request(bridged_request).await
-                    } else {
-                        self.enqueue_thread_request(thread_id, bridged_request)
-                            .await
-                    };
-                    if let Err(err) = result {
-                        self.reject_failed_legacy_exec_approval_enqueue(
-                            app_server_client,
-                            &request,
-                            err.to_string(),
-                        )
-                        .await;
-                    }
-                }
-                Err(message) => {
-                    tracing::warn!(request_id = ?request.id(), "{message}");
-                    self.chat_widget.add_error_message(message.clone());
-                    if let Err(err) = self
-                        .reject_app_server_request(app_server_client, request.id().clone(), message)
-                        .await
-                    {
-                        tracing::warn!("{err}");
-                    }
-                }
-            }
             return;
         }
 
@@ -264,6 +211,75 @@ impl App {
         }
     }
 
+    async fn try_handle_legacy_remote_exec_approval_request(
+        &mut self,
+        app_server_client: &AppServerSession,
+        request: &ServerRequest,
+    ) -> bool {
+        if !app_server_client.is_remote()
+            || !matches!(request, ServerRequest::ExecCommandApproval { .. })
+        {
+            return false;
+        }
+
+        match bridge_legacy_exec_approval_request(request) {
+            Ok((thread_id, bridged_request)) => {
+                if let Some(unsupported) = self
+                    .pending_app_server_requests
+                    .note_server_request(request)
+                {
+                    tracing::warn!(
+                        request_id = ?unsupported.request_id,
+                        message = unsupported.message,
+                        "rejecting unsupported app-server request"
+                    );
+                    self.chat_widget
+                        .add_error_message(unsupported.message.clone());
+                    if let Err(err) = self
+                        .reject_app_server_request(
+                            app_server_client,
+                            unsupported.request_id,
+                            unsupported.message,
+                        )
+                        .await
+                    {
+                        tracing::warn!("{err}");
+                    }
+                    return true;
+                }
+
+                let result = if self.primary_thread_id == Some(thread_id)
+                    || self.primary_thread_id.is_none()
+                {
+                    self.enqueue_primary_thread_request(bridged_request).await
+                } else {
+                    self.enqueue_thread_request(thread_id, bridged_request)
+                        .await
+                };
+                if let Err(err) = result {
+                    self.reject_failed_legacy_exec_approval_enqueue(
+                        app_server_client,
+                        request,
+                        err.to_string(),
+                    )
+                    .await;
+                }
+            }
+            Err(message) => {
+                tracing::warn!(request_id = ?request.id(), "{message}");
+                self.chat_widget.add_error_message(message.clone());
+                if let Err(err) = self
+                    .reject_app_server_request(app_server_client, request.id().clone(), message)
+                    .await
+                {
+                    tracing::warn!("{err}");
+                }
+            }
+        }
+
+        true
+    }
+
     async fn reject_failed_legacy_exec_approval_enqueue(
         &mut self,
         app_server_client: &AppServerSession,