Fix BTW restack drift on current main

Resolve the remaining API and test drift after restacking the /btw implementation onto current main.

- align tui /btw with ForkSnapshot-based forking
- adapt tui_app_server BTW attachment to the current session/turn cache model
- make BTW fork banners deterministic even for unnamed parent threads
- clean up the stale thread_manager test import from the cherry-pick

Co-authored-by: Codex <noreply@openai.com>

Author: charley-oai

codex-rs/core/src/thread_manager_tests.rs

@@ -1,5 +1,4 @@
 use super::*;
-use crate::EventPersistenceMode;
 use crate::codex::make_session_and_context;
 use crate::config::test_config;
 use crate::models_manager::collaboration_mode_presets::CollaborationModesConfig;

codex-rs/tui/src/app.rs

@@ -1803,7 +1803,7 @@ impl App {
                     thread_id,
                     config_snapshot.session_source.get_nickname(),
                     config_snapshot.session_source.get_agent_role(),
-                    false,
+                    /*is_closed*/ false,
                 );
             }
         }
@@ -2214,8 +2214,7 @@ impl App {
         let next_btw_fork_banner_parent_label =
             self.take_next_btw_fork_banner_parent_label(thread_id);
         let mut chat_widget = ChatWidget::new_with_op_sender(init, codex_op_tx);
-        chat_widget
-            .set_next_fork_banner_parent_label(next_btw_fork_banner_parent_label);
+        chat_widget.set_next_fork_banner_parent_label(next_btw_fork_banner_parent_label);
         self.replace_chat_widget(chat_widget);
 
         self.reset_for_thread_switch(tui)?;

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

@@ -138,22 +138,35 @@ impl App {
         self.sync_active_agent_label();
     }
 
-    async fn fork_banner_parent_label(&self, parent_thread_id: ThreadId) -> Option<String> {
-        if self.chat_widget.thread_id() == Some(parent_thread_id) {
-            return self
+    async fn fork_banner_parent_label(&self, parent_thread_id: ThreadId) -> String {
+        if self.chat_widget.thread_id() == Some(parent_thread_id)
+            && let Some(thread_name) = self
                 .chat_widget
                 .thread_name()
-                .filter(|name| !name.trim().is_empty());
+                .filter(|name| !name.trim().is_empty())
+        {
+            return thread_name;
+        }
+
+        if let Some(channel) = self.thread_event_channels.get(&parent_thread_id) {
+            let store = channel.store.lock().await;
+            if let Some(thread_name) =
+                match store.session_configured.as_ref().map(|event| &event.msg) {
+                    Some(EventMsg::SessionConfigured(session)) => session
+                        .thread_name
+                        .clone()
+                        .filter(|name| !name.trim().is_empty()),
+                    _ => None,
+                }
+            {
+                return thread_name;
+            }
         }
 
-        let channel = self.thread_event_channels.get(&parent_thread_id)?;
-        let store = channel.store.lock().await;
-        match store.session_configured.as_ref().map(|event| &event.msg) {
-            Some(EventMsg::SessionConfigured(session)) => session
-                .thread_name
-                .clone()
-                .filter(|name| !name.trim().is_empty()),
-            _ => None,
+        if self.primary_thread_id == Some(parent_thread_id) {
+            "main thread".to_string()
+        } else {
+            self.thread_label(parent_thread_id)
         }
     }
 
@@ -193,8 +206,8 @@ impl App {
 
         let fork_result = if self.chat_widget.agent_turn_running() {
             self.server
-                .fork_thread_from_interrupted_snapshot(
-                    /*nth_user_message*/ usize::MAX,
+                .fork_thread(
+                    ForkSnapshot::Interrupted,
                     self.config.clone(),
                     parent_rollout_path.clone(),
                     /*persist_extended_history*/ false,
@@ -204,7 +217,7 @@ impl App {
         } else {
             self.server
                 .fork_thread(
-                    /*nth_user_message*/ usize::MAX,
+                    /*snapshot*/ usize::MAX,
                     self.config.clone(),
                     parent_rollout_path.clone(),
                     /*persist_extended_history*/ false,
@@ -217,7 +230,7 @@ impl App {
             Ok(forked) => {
                 let child_thread_id = forked.thread_id;
                 let next_fork_banner_parent_label =
-                    self.fork_banner_parent_label(parent_thread_id).await;
+                    Some(self.fork_banner_parent_label(parent_thread_id).await);
                 self.attach_live_thread(
                     child_thread_id,
                     Arc::clone(&forked.thread),

codex-rs/tui/src/app/tests/btw.rs

@@ -414,6 +414,7 @@ async fn setup_btw_parent_thread(app: &mut App, parent_message: Option<&str>) ->
                         source: SessionSource::Cli,
                         agent_nickname: None,
                         agent_role: None,
+                        agent_path: None,
                         model_provider: Some(app.config.model_provider_id.clone()),
                         base_instructions: None,
                         dynamic_tools: None,

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

@@ -141,22 +141,32 @@ impl App {
         self.sync_active_agent_label();
     }
 
-    async fn fork_banner_parent_label(&self, parent_thread_id: ThreadId) -> Option<String> {
-        if self.chat_widget.thread_id() == Some(parent_thread_id) {
-            return self
+    async fn fork_banner_parent_label(&self, parent_thread_id: ThreadId) -> String {
+        if self.chat_widget.thread_id() == Some(parent_thread_id)
+            && let Some(thread_name) = self
                 .chat_widget
                 .thread_name()
-                .filter(|name| !name.trim().is_empty());
+                .filter(|name| !name.trim().is_empty())
+        {
+            return thread_name;
+        }
+
+        if let Some(channel) = self.thread_event_channels.get(&parent_thread_id) {
+            let store = channel.store.lock().await;
+            if let Some(thread_name) = store
+                .session
+                .as_ref()
+                .and_then(|session| session.thread_name.clone())
+                .filter(|name| !name.trim().is_empty())
+            {
+                return thread_name;
+            }
         }
 
-        let channel = self.thread_event_channels.get(&parent_thread_id)?;
-        let store = channel.store.lock().await;
-        match store.session_configured.as_ref().map(|event| &event.msg) {
-            Some(EventMsg::SessionConfigured(session)) => session
-                .thread_name
-                .clone()
-                .filter(|name| !name.trim().is_empty()),
-            _ => None,
+        if self.primary_thread_id == Some(parent_thread_id) {
+            "main thread".to_string()
+        } else {
+            self.thread_label(parent_thread_id)
         }
     }
 
@@ -221,17 +231,15 @@ impl App {
 
         match fork_result {
             Ok(forked) => {
-                let child_thread_id = forked.session_configured.session_id;
+                let AppServerStartedThread { session, turns } = forked;
+                let child_thread_id = session.thread_id;
                 let next_fork_banner_parent_label =
-                    self.fork_banner_parent_label(parent_thread_id).await;
-                self.enqueue_thread_event(
-                    child_thread_id,
-                    Event {
-                        id: String::new(),
-                        msg: EventMsg::SessionConfigured(forked.session_configured),
-                    },
-                )
-                .await?;
+                    Some(self.fork_banner_parent_label(parent_thread_id).await);
+                let channel = self.ensure_thread_channel(child_thread_id);
+                {
+                    let mut store = channel.store.lock().await;
+                    store.set_session(session, turns);
+                }
                 self.btw_threads.insert(
                     child_thread_id,
                     BtwThreadState {

codex-rs/tui_app_server/src/app_server_session.rs

@@ -332,7 +332,7 @@ impl AppServerSession {
     ) -> Result<AppServerStartedThread> {
         let request_id = self.next_request_id();
         let mut params =
-            thread_fork_params_from_config(config, thread_id, self.thread_params_mode());
+            thread_fork_params_from_config(&config, thread_id, self.thread_params_mode());
         params.path = path;
         let response: ThreadForkResponse = self
             .client
@@ -856,19 +856,19 @@ fn thread_resume_params_from_config(
 }
 
 fn thread_fork_params_from_config(
-    config: Config,
+    config: &Config,
     thread_id: ThreadId,
     thread_params_mode: ThreadParamsMode,
 ) -> ThreadForkParams {
     ThreadForkParams {
         thread_id: thread_id.to_string(),
         model: config.model.clone(),
-        model_provider: thread_params_mode.model_provider_from_config(&config),
-        cwd: thread_cwd_from_config(&config, thread_params_mode),
+        model_provider: thread_params_mode.model_provider_from_config(config),
+        cwd: thread_cwd_from_config(config, thread_params_mode),
         approval_policy: Some(config.permissions.approval_policy.value().into()),
-        approvals_reviewer: approvals_reviewer_override_from_config(&config),
+        approvals_reviewer: approvals_reviewer_override_from_config(config),
         sandbox: sandbox_mode_from_policy(config.permissions.sandbox_policy.get().clone()),
-        config: config_request_overrides_from_config(&config),
+        config: config_request_overrides_from_config(config),
         ephemeral: config.ephemeral,
         persist_extended_history: true,
         ..ThreadForkParams::default()
@@ -1131,7 +1131,7 @@ mod tests {
         let start = thread_start_params_from_config(&config, ThreadParamsMode::Remote);
         let resume =
             thread_resume_params_from_config(config.clone(), thread_id, ThreadParamsMode::Remote);
-        let fork = thread_fork_params_from_config(config, thread_id, ThreadParamsMode::Remote);
+        let fork = thread_fork_params_from_config(&config, thread_id, ThreadParamsMode::Remote);
 
         assert_eq!(start.cwd, None);
         assert_eq!(resume.cwd, None);

codex-rs/tui_app_server/src/chatwidget.rs

@@ -1939,57 +1939,7 @@ impl ChatWidget {
             PlainHistoryCell::new(vec![line]),
         )));
     }
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
+
     fn on_thread_name_updated(&mut self, event: codex_protocol::protocol::ThreadNameUpdatedEvent) {
         if self.thread_id == Some(event.thread_id) {
             self.thread_name = event.thread_name;
@@ -5395,7 +5345,7 @@ impl ChatWidget {
                 return None;
             }
             self.submit_op(AppCommand::run_user_shell_command(cmd.to_string()));
-            return;
+            return None;
         }
 
         for image_url in &remote_image_urls {
@@ -5528,7 +5478,7 @@ impl ChatWidget {
             self.add_error_message(
                 "Thread model is unavailable. Wait for the thread to finish syncing or choose a model before sending input.".to_string(),
             );
-            return;
+            return None;
         }
         let collaboration_mode = if self.collaboration_modes_enabled() {
             self.active_collaboration_mask