feat: exec-server prep for unified exec (#15691)

This PR partially rebase `unified_exec` on the `exec-server` and adapt
the `exec-server` accordingly.

## What changed in `exec-server`

1. Replaced the old "broadcast-driven; process-global" event model with
process-scoped session events. The goal is to be able to have dedicated
handler for each process.
2. Add to protocol contract to support explicit lifecycle status and
stream ordering:
- `WriteResponse` now returns `WriteStatus` (Accepted, UnknownProcess,
StdinClosed, Starting) instead of a bool.
  - Added seq fields to output/exited notifications.
  - Added terminal process/closed notification.
3. Demultiplexed remote notifications into per-process channels. Same as
for the event sys
4. Local and remote backends now both implement ExecBackend.
5. Local backend wraps internal process ID/operations into per-process
ExecProcess objects.
6. Remote backend registers a session channel before launch and
unregisters on failed launch.

## What changed in `unified_exec`

1. Added unified process-state model and backend-neutral process
wrapper. This will probably disappear in the future, but it makes it
easier to keep the work flowing on both side.
- `UnifiedExecProcess` now handles both local PTY sessions and remote
exec-server processes through a shared `ProcessHandle`.
- Added `ProcessState` to track has_exited, exit_code, and terminal
failure message consistently across backends.
2. Routed write and lifecycle handling through process-level methods.

## Some rationals

1. The change centralizes execution transport in exec-server while
preserving policy and orchestration ownership in core, avoiding
duplicated launch approval logic. This comes from internal discussion.
2. Session-scoped events remove coupling/cross-talk between processes
and make stream ordering and terminal state explicit (seq, closed,
failed).
3. The failure-path surfacing (remote launch failures, write failures,
transport disconnects) makes command tool output and cleanup behavior
deterministic

## Follow-ups:
* Unify the concept of thread ID behind an obfuscated struct
* FD handling
* Full zsh-fork compatibility
* Full network sandboxing compatibility
* Handle ws disconnection

codex-rs/exec-server/src/remote_process.rs

@@ -1,16 +1,17 @@
+use std::sync::Arc;
+
 use async_trait::async_trait;
-use tokio::sync::broadcast;
+use tokio::sync::watch;
 use tracing::trace;
 
+use crate::ExecBackend;
 use crate::ExecProcess;
-use crate::ExecServerClient;
 use crate::ExecServerError;
-use crate::ExecServerEvent;
+use crate::StartedExecProcess;
+use crate::client::ExecServerClient;
+use crate::client::Session;
 use crate::protocol::ExecParams;
-use crate::protocol::ExecResponse;
-use crate::protocol::ReadParams;
 use crate::protocol::ReadResponse;
-use crate::protocol::TerminateResponse;
 use crate::protocol::WriteResponse;
 
 #[derive(Clone)]
@@ -18,6 +19,10 @@ pub(crate) struct RemoteProcess {
     client: ExecServerClient,
 }
 
+struct RemoteExecProcess {
+    session: Session,
+}
+
 impl RemoteProcess {
     pub(crate) fn new(client: ExecServerClient) -> Self {
         trace!("remote process new");
@@ -26,33 +31,56 @@ impl RemoteProcess {
 }
 
 #[async_trait]
-impl ExecProcess for RemoteProcess {
-    async fn start(&self, params: ExecParams) -> Result<ExecResponse, ExecServerError> {
-        trace!("remote process start");
-        self.client.exec(params).await
-    }
+impl ExecBackend for RemoteProcess {
+    async fn start(&self, params: ExecParams) -> Result<StartedExecProcess, ExecServerError> {
+        let process_id = params.process_id.clone();
+        let session = self.client.register_session(&process_id).await?;
+        if let Err(err) = self.client.exec(params).await {
+            session.unregister().await;
+            return Err(err);
+        }
 
-    async fn read(&self, params: ReadParams) -> Result<ReadResponse, ExecServerError> {
-        trace!("remote process read");
-        self.client.read(params).await
-    }
-
-    async fn write(
-        &self,
-        process_id: &str,
-        chunk: Vec<u8>,
-    ) -> Result<WriteResponse, ExecServerError> {
-        trace!("remote process write");
-        self.client.write(process_id, chunk).await
-    }
-
-    async fn terminate(&self, process_id: &str) -> Result<TerminateResponse, ExecServerError> {
-        trace!("remote process terminate");
-        self.client.terminate(process_id).await
-    }
-
-    fn subscribe_events(&self) -> broadcast::Receiver<ExecServerEvent> {
-        trace!("remote process subscribe_events");
-        self.client.event_receiver()
+        Ok(StartedExecProcess {
+            process: Arc::new(RemoteExecProcess { session }),
+        })
+    }
+}
+
+#[async_trait]
+impl ExecProcess for RemoteExecProcess {
+    fn process_id(&self) -> &crate::ProcessId {
+        self.session.process_id()
+    }
+
+    fn subscribe_wake(&self) -> watch::Receiver<u64> {
+        self.session.subscribe_wake()
+    }
+
+    async fn read(
+        &self,
+        after_seq: Option<u64>,
+        max_bytes: Option<usize>,
+        wait_ms: Option<u64>,
+    ) -> Result<ReadResponse, ExecServerError> {
+        self.session.read(after_seq, max_bytes, wait_ms).await
+    }
+
+    async fn write(&self, chunk: Vec<u8>) -> Result<WriteResponse, ExecServerError> {
+        trace!("exec process write");
+        self.session.write(chunk).await
+    }
+
+    async fn terminate(&self) -> Result<(), ExecServerError> {
+        trace!("exec process terminate");
+        self.session.terminate().await
+    }
+}
+
+impl Drop for RemoteExecProcess {
+    fn drop(&mut self) {
+        let session = self.session.clone();
+        tokio::spawn(async move {
+            session.unregister().await;
+        });
     }
 }