chore(app-server): delete v1 RPC methods and notifications (#13375)

## Summary
This removes the old app-server v1 methods and notifications we no
longer need, while keeping the small set the main codex app client still
depends on for now.

The remaining legacy surface is:
- `initialize`
- `getConversationSummary`
- `getAuthStatus`
- `gitDiffToRemote`
- `fuzzyFileSearch`
- `fuzzyFileSearch/sessionStart`
- `fuzzyFileSearch/sessionUpdate`
- `fuzzyFileSearch/sessionStop`

And the raw `codex/event/*` notifications emitted from core. These
notifications will be removed in a followup PR.

## What changed
- removed deprecated v1 request variants from the protocol and
app-server dispatcher
- removed deprecated typed notifications: `authStatusChange`,
`loginChatGptComplete`, and `sessionConfigured`
- updated the app-server test client to use v2 flows instead of deleted
v1 flows
- deleted legacy-only app-server test suites and added focused coverage
for `getConversationSummary`
- regenerated app-server schema fixtures and updated the MCP interface
docs to match the remaining compatibility surface

## Testing
- `just write-app-server-schema`
- `cargo test -p codex-app-server-protocol`
- `cargo test -p codex-app-server`

codex-rs/app-server/src/thread_state.rs

@@ -16,7 +16,6 @@ use std::sync::Weak;
 use tokio::sync::Mutex;
 use tokio::sync::mpsc;
 use tokio::sync::oneshot;
-use uuid::Uuid;
 
 type PendingInterruptQueue = Vec<(
     ConnectionRequestId,
@@ -116,12 +115,6 @@ impl ThreadState {
     }
 }
 
-#[derive(Clone, Copy)]
-struct SubscriptionState {
-    thread_id: ThreadId,
-    connection_id: ConnectionId,
-}
-
 struct ThreadEntry {
     state: Arc<Mutex<ThreadState>>,
     connection_ids: HashSet<ConnectionId>,
@@ -140,7 +133,6 @@ impl Default for ThreadEntry {
 struct ThreadStateManagerInner {
     live_connections: HashSet<ConnectionId>,
     threads: HashMap<ThreadId, ThreadEntry>,
-    subscription_state_by_id: HashMap<Uuid, SubscriptionState>,
     thread_ids_by_connection: HashMap<ConnectionId, HashSet<ThreadId>>,
 }
 
@@ -176,70 +168,6 @@ impl ThreadStateManager {
         state.threads.entry(thread_id).or_default().state.clone()
     }
 
-    pub(crate) async fn remove_listener(&self, subscription_id: Uuid) -> Option<ThreadId> {
-        let (subscription_state, connection_still_subscribed_to_thread, thread_state) = {
-            let mut state = self.state.lock().await;
-            let subscription_state = state.subscription_state_by_id.remove(&subscription_id)?;
-            let thread_id = subscription_state.thread_id;
-
-            let connection_still_subscribed_to_thread = state
-                .subscription_state_by_id
-                .values()
-                .any(|subscription_state_entry| {
-                    subscription_state_entry.thread_id == thread_id
-                        && subscription_state_entry.connection_id
-                            == subscription_state.connection_id
-                });
-            if !connection_still_subscribed_to_thread {
-                let mut remove_connection_entry = false;
-                if let Some(thread_ids) = state
-                    .thread_ids_by_connection
-                    .get_mut(&subscription_state.connection_id)
-                {
-                    thread_ids.remove(&thread_id);
-                    remove_connection_entry = thread_ids.is_empty();
-                }
-                if remove_connection_entry {
-                    state
-                        .thread_ids_by_connection
-                        .remove(&subscription_state.connection_id);
-                }
-                if let Some(thread_entry) = state.threads.get_mut(&thread_id) {
-                    thread_entry
-                        .connection_ids
-                        .remove(&subscription_state.connection_id);
-                }
-            }
-
-            let thread_state = state.threads.get(&thread_id).map(|thread_entry| {
-                (
-                    thread_entry.connection_ids.is_empty(),
-                    thread_entry.state.clone(),
-                )
-            });
-            (
-                subscription_state,
-                connection_still_subscribed_to_thread,
-                thread_state,
-            )
-        };
-        let thread_id = subscription_state.thread_id;
-
-        if let Some((no_subscribers, thread_state)) = thread_state {
-            let thread_state = thread_state.lock().await;
-            if !connection_still_subscribed_to_thread && no_subscribers {
-                tracing::debug!(
-                    thread_id = %thread_id,
-                    subscription_id = %subscription_id,
-                    connection_id = ?subscription_state.connection_id,
-                    listener_generation = thread_state.listener_generation,
-                    "retaining thread listener after last subscription removed"
-                );
-            }
-        }
-        Some(thread_id)
-    }
-
     pub(crate) async fn remove_thread_state(&self, thread_id: ThreadId) {
         let thread_state = {
             let mut state = self.state.lock().await;
@@ -247,9 +175,6 @@ impl ThreadStateManager {
                 .threads
                 .remove(&thread_id)
                 .map(|thread_entry| thread_entry.state);
-            state
-                .subscription_state_by_id
-                .retain(|_, state| state.thread_id != thread_id);
             state.thread_ids_by_connection.retain(|_, thread_ids| {
                 thread_ids.remove(&thread_id);
                 !thread_ids.is_empty()
@@ -298,13 +223,6 @@ impl ThreadStateManager {
             if let Some(thread_entry) = state.threads.get_mut(&thread_id) {
                 thread_entry.connection_ids.remove(&connection_id);
             }
-
-            state
-                .subscription_state_by_id
-                .retain(|_, subscription_state| {
-                    !(subscription_state.thread_id == thread_id
-                        && subscription_state.connection_id == connection_id)
-                });
         };
 
         true
@@ -319,38 +237,6 @@ impl ThreadStateManager {
             .is_some_and(|thread_entry| !thread_entry.connection_ids.is_empty())
     }
 
-    pub(crate) async fn set_listener(
-        &self,
-        subscription_id: Uuid,
-        thread_id: ThreadId,
-        connection_id: ConnectionId,
-        experimental_raw_events: bool,
-    ) -> Arc<Mutex<ThreadState>> {
-        let thread_state = {
-            let mut state = self.state.lock().await;
-            state.subscription_state_by_id.insert(
-                subscription_id,
-                SubscriptionState {
-                    thread_id,
-                    connection_id,
-                },
-            );
-            state
-                .thread_ids_by_connection
-                .entry(connection_id)
-                .or_default()
-                .insert(thread_id);
-            let thread_entry = state.threads.entry(thread_id).or_default();
-            thread_entry.connection_ids.insert(connection_id);
-            thread_entry.state.clone()
-        };
-        {
-            let mut thread_state_guard = thread_state.lock().await;
-            thread_state_guard.set_experimental_raw_events(experimental_raw_events);
-        }
-        thread_state
-    }
-
     pub(crate) async fn try_ensure_connection_subscribed(
         &self,
         thread_id: ThreadId,
@@ -411,9 +297,6 @@ impl ThreadStateManager {
                 .thread_ids_by_connection
                 .remove(&connection_id)
                 .unwrap_or_default();
-            state
-                .subscription_state_by_id
-                .retain(|_, state| state.connection_id != connection_id);
             for thread_id in &thread_ids {
                 if let Some(thread_entry) = state.threads.get_mut(thread_id) {
                     thread_entry.connection_ids.remove(&connection_id);