tui: canonicalize interactive slash drafts

Route interactive slash-command pickers through canonical serialized drafts so live dispatch and queued replay share one parser/executor path.

Validation: cargo test -p codex-tui; just fix -p codex-tui; just fmt

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

Author: charley-oai

codex-rs/tui/src/app.rs

@@ -34,6 +34,7 @@ use crate::pager_overlay::Overlay;
 use crate::render::highlight::highlight_bash_to_lines;
 use crate::render::renderable::Renderable;
 use crate::resume_picker::SessionSelection;
+use crate::resume_picker::SessionTarget;
 use crate::tui;
 use crate::tui::TuiEvent;
 use crate::update_action::UpdateAction;
@@ -51,6 +52,7 @@ use codex_core::config::edit::ConfigEditsBuilder;
 use codex_core::config::types::ModelAvailabilityNuxConfig;
 use codex_core::config_loader::ConfigLayerStackOrdering;
 use codex_core::features::Feature;
+use codex_core::find_thread_path_by_id_str;
 use codex_core::models_manager::collaboration_mode_presets::CollaborationModesConfig;
 use codex_core::models_manager::manager::RefreshStrategy;
 use codex_core::models_manager::model_presets::HIDE_GPT_5_1_CODEX_MAX_MIGRATION_PROMPT_CONFIG;
@@ -812,6 +814,99 @@ impl App {
         }
     }
 
+    async fn resume_session_target(
+        &mut self,
+        tui: &mut tui::Tui,
+        target_session: SessionTarget,
+    ) -> Result<()> {
+        let current_cwd = self.config.cwd.clone();
+        let resume_cwd = match crate::resolve_cwd_for_resume_or_fork(
+            tui,
+            &self.config,
+            &current_cwd,
+            target_session.thread_id,
+            &target_session.path,
+            CwdPromptAction::Resume,
+            true,
+        )
+        .await?
+        {
+            crate::ResolveCwdOutcome::Continue(Some(cwd)) => cwd,
+            crate::ResolveCwdOutcome::Continue(None) => current_cwd.clone(),
+            crate::ResolveCwdOutcome::Exit => return Ok(()),
+        };
+        let mut resume_config = match self
+            .rebuild_config_for_resume_or_fallback(&current_cwd, resume_cwd)
+            .await
+        {
+            Ok(cfg) => cfg,
+            Err(err) => {
+                self.chat_widget.add_error_message(format!(
+                    "Failed to rebuild configuration for resume: {err}"
+                ));
+                return Ok(());
+            }
+        };
+        self.apply_runtime_policy_overrides(&mut resume_config);
+        let summary = session_summary(
+            self.chat_widget.token_usage(),
+            self.chat_widget.thread_id(),
+            self.chat_widget.thread_name(),
+        );
+        match self
+            .server
+            .resume_thread_from_rollout(
+                resume_config.clone(),
+                target_session.path.clone(),
+                self.auth_manager.clone(),
+            )
+            .await
+        {
+            Ok(resumed) => {
+                self.shutdown_current_thread().await;
+                self.config = resume_config;
+                tui.set_notification_method(self.config.tui_notification_method);
+                self.file_search.update_search_dir(self.config.cwd.clone());
+                let init =
+                    self.chatwidget_init_for_forked_or_resumed_thread(tui, self.config.clone());
+                self.chat_widget =
+                    ChatWidget::new_from_existing(init, resumed.thread, resumed.session_configured);
+                self.reset_thread_event_state();
+                if let Some(summary) = summary {
+                    let mut lines: Vec<Line<'static>> = vec![summary.usage_line.clone().into()];
+                    if let Some(command) = summary.resume_command {
+                        let spans = vec!["To continue this session, run ".into(), command.cyan()];
+                        lines.push(spans.into());
+                    }
+                    self.chat_widget.add_plain_history_lines(lines);
+                }
+            }
+            Err(err) => {
+                let path_display = target_session.path.display();
+                self.chat_widget.add_error_message(format!(
+                    "Failed to resume session from {path_display}: {err}"
+                ));
+            }
+        }
+        Ok(())
+    }
+
+    async fn resume_session_by_thread_id(
+        &mut self,
+        tui: &mut tui::Tui,
+        thread_id: ThreadId,
+    ) -> Result<()> {
+        let Some(path) =
+            find_thread_path_by_id_str(&self.config.codex_home, &thread_id.to_string()).await?
+        else {
+            self.chat_widget
+                .add_error_message(format!("No saved session found for thread {thread_id}."));
+            return Ok(());
+        };
+        self.resume_session_target(tui, SessionTarget { path, thread_id })
+            .await
+    }
+
     fn apply_runtime_policy_overrides(&mut self, config: &mut Config) {
         if let Some(policy) = self.runtime_approval_policy_override.as_ref()
             && let Err(err) = config.permissions.approval_policy.set(*policy)
@@ -1426,7 +1521,13 @@ impl App {
                     description: Some(uuid.clone()),
                     is_current: self.active_thread_id == Some(*thread_id),
                     actions: vec![Box::new(move |tx| {
-                        tx.send(AppEvent::SelectAgentThread(id));
+                        tx.send(AppEvent::HandleSlashCommandDraft(
+                            format!(
+                                "/{} {id}",
+                                crate::slash_command::SlashCommand::Agent.command()
+                            )
+                            .into(),
+                        ));
                     })],
                     dismiss_on_select: true,
                     search_value: Some(format!("{name} {uuid}")),
@@ -2150,87 +2251,15 @@ impl App {
             AppEvent::OpenResumePicker => {
                 match crate::resume_picker::run_resume_picker(tui, &self.config, false).await? {
                     SessionSelection::Resume(target_session) => {
-                        let current_cwd = self.config.cwd.clone();
-                        let resume_cwd = match crate::resolve_cwd_for_resume_or_fork(
-                            tui,
-                            &self.config,
-                            &current_cwd,
-                            target_session.thread_id,
-                            &target_session.path,
-                            CwdPromptAction::Resume,
-                            true,
-                        )
-                        .await?
-                        {
-                            crate::ResolveCwdOutcome::Continue(Some(cwd)) => cwd,
-                            crate::ResolveCwdOutcome::Continue(None) => current_cwd.clone(),
-                            crate::ResolveCwdOutcome::Exit => {
-                                return Ok(AppRunControl::Exit(ExitReason::UserRequested));
-                            }
-                        };
-                        let mut resume_config = match self
-                            .rebuild_config_for_resume_or_fallback(&current_cwd, resume_cwd)
-                            .await
-                        {
-                            Ok(cfg) => cfg,
-                            Err(err) => {
-                                self.chat_widget.add_error_message(format!(
-                                    "Failed to rebuild configuration for resume: {err}"
-                                ));
-                                return Ok(AppRunControl::Continue);
-                            }
-                        };
-                        self.apply_runtime_policy_overrides(&mut resume_config);
-                        let summary = session_summary(
-                            self.chat_widget.token_usage(),
-                            self.chat_widget.thread_id(),
-                            self.chat_widget.thread_name(),
-                        );
-                        match self
-                            .server
-                            .resume_thread_from_rollout(
-                                resume_config.clone(),
-                                target_session.path.clone(),
-                                self.auth_manager.clone(),
-                                None,
+                        self.chat_widget.handle_serialized_slash_command(
+                            format!(
+                                "/{} {}",
+                                crate::slash_command::SlashCommand::Resume.command(),
+                                target_session.thread_id
                             )
-                            .await
-                        {
-                            Ok(resumed) => {
-                                self.shutdown_current_thread().await;
-                                self.config = resume_config;
-                                tui.set_notification_method(self.config.tui_notification_method);
-                                self.file_search.update_search_dir(self.config.cwd.clone());
-                                let init = self.chatwidget_init_for_forked_or_resumed_thread(
-                                    tui,
-                                    self.config.clone(),
-                                );
-                                self.chat_widget = ChatWidget::new_from_existing(
-                                    init,
-                                    resumed.thread,
-                                    resumed.session_configured,
-                                );
-                                self.reset_thread_event_state();
-                                if let Some(summary) = summary {
-                                    let mut lines: Vec<Line<'static>> =
-                                        vec![summary.usage_line.clone().into()];
-                                    if let Some(command) = summary.resume_command {
-                                        let spans = vec![
-                                            "To continue this session, run ".into(),
-                                            command.cyan(),
-                                        ];
-                                        lines.push(spans.into());
-                                    }
-                                    self.chat_widget.add_plain_history_lines(lines);
-                                }
-                            }
-                            Err(err) => {
-                                let path_display = target_session.path.display();
-                                self.chat_widget.add_error_message(format!(
-                                    "Failed to resume session from {path_display}: {err}"
-                                ));
-                            }
-                        }
+                            .into(),
+                        );
+                        self.refresh_status_line();
                     }
                     SessionSelection::Exit
                     | SessionSelection::StartFresh
@@ -2240,6 +2269,9 @@ impl App {
                 // Leaving alt-screen may blank the inline viewport; force a redraw either way.
                 tui.frame_requester().schedule_frame();
             }
+            AppEvent::ResumeSession(thread_id) => {
+                self.resume_session_by_thread_id(tui, thread_id).await?;
+            }
             AppEvent::ForkCurrentSession => {
                 self.session_telemetry.counter(
                     "codex.thread.fork",
@@ -3176,9 +3208,6 @@ impl App {
             AppEvent::SelectAgentThread(thread_id) => {
                 self.select_agent_thread(tui, thread_id).await?;
             }
-            AppEvent::OpenSkillsList => {
-                self.chat_widget.open_skills_list();
-            }
             AppEvent::OpenManageSkillsPopup => {
                 self.chat_widget.open_manage_skills_popup();
             }
@@ -3875,6 +3904,7 @@ mod tests {
     use crate::app_backtrack::BacktrackSelection;
     use crate::app_backtrack::BacktrackState;
     use crate::app_backtrack::user_count;
+    use crate::chatwidget::UserMessage;
     use crate::chatwidget::tests::make_chatwidget_manual_with_sender;
     use crate::chatwidget::tests::set_chatgpt_auth;
     use crate::file_search::FileSearchManager;
@@ -5166,10 +5196,12 @@ mod tests {
         app.chat_widget
             .handle_key_event(KeyEvent::new(KeyCode::Enter, KeyModifiers::NONE));
 
-        assert_matches!(
-            app_event_rx.try_recv(),
-            Ok(AppEvent::SelectAgentThread(selected_thread_id)) if selected_thread_id == thread_id
-        );
+        match app_event_rx.try_recv() {
+            Ok(AppEvent::HandleSlashCommandDraft(draft)) => {
+                assert_eq!(draft, UserMessage::from(format!("/agent {thread_id}")));
+            }
+            other => panic!("expected serialized agent slash draft, got {other:?}"),
+        }
         Ok(())
     }
 

codex-rs/tui/src/app_event.rs

@@ -97,6 +97,9 @@ pub(crate) enum AppEvent {
     /// Open the resume picker inside the running TUI session.
     OpenResumePicker,
 
+    /// Resume a saved session by thread id.
+    ResumeSession(ThreadId),
+
     /// Fork the current session into a new thread.
     ForkCurrentSession,
 
@@ -362,9 +365,6 @@ pub(crate) enum AppEvent {
     /// Re-open the approval presets popup.
     OpenApprovalsPopup,
 
-    /// Open the skills list popup.
-    OpenSkillsList,
-
     /// Open the skills enable/disable picker.
     OpenManageSkillsPopup,
 

codex-rs/tui/src/bottom_pane/chat_composer.rs

@@ -2533,10 +2533,6 @@ impl ChatComposer {
 
         let cmd = slash_commands::find_builtin_command(name, self.builtin_command_flags())?;
 
-        if !cmd.supports_inline_args() {
-            return None;
-        }
-
         let mut args_elements =
             Self::slash_command_args_elements(rest, rest_offset, &self.textarea.text_elements());
         let trimmed_rest = rest.trim();

codex-rs/tui/src/bottom_pane/experimental_features_view.rs

@@ -17,10 +17,9 @@ use crate::render::Insets;
 use crate::render::RectExt as _;
 use crate::render::renderable::ColumnRenderable;
 use crate::render::renderable::Renderable;
+use crate::slash_command::SlashCommand;
 use crate::style::user_message_style;
 
-use codex_core::features::Feature;
-
 use super::CancellationEvent;
 use super::bottom_pane_view::BottomPaneView;
 use super::popup_consts::MAX_POPUP_ROWS;
@@ -30,7 +29,7 @@ use super::selection_popup_common::measure_rows_height;
 use super::selection_popup_common::render_rows;
 
 pub(crate) struct ExperimentalFeatureItem {
-    pub feature: Feature,
+    pub key: String,
     pub name: String,
     pub description: String,
     pub enabled: bool,
@@ -198,15 +197,16 @@ impl BottomPaneView for ExperimentalFeaturesView {
     }
 
     fn on_ctrl_c(&mut self) -> CancellationEvent {
-        // Save the updates
         if !self.features.is_empty() {
-            let updates = self
+            let args = self
                 .features
                 .iter()
-                .map(|item| (item.feature, item.enabled))
-                .collect();
-            self.app_event_tx
-                .send(AppEvent::UpdateFeatureFlags { updates });
+                .map(|item| format!("{}={}", item.key, if item.enabled { "on" } else { "off" }))
+                .collect::<Vec<_>>()
+                .join(" ");
+            self.app_event_tx.send(AppEvent::HandleSlashCommandDraft(
+                format!("/{} {args}", SlashCommand::Experimental.command()).into(),
+            ));
         }
 
         self.complete = true;

codex-rs/tui/src/bottom_pane/feedback_view.rs

@@ -485,8 +485,17 @@ fn make_feedback_item(
     description: &str,
     category: FeedbackCategory,
 ) -> super::SelectionItem {
+    let token = match category {
+        FeedbackCategory::Bug => "bug",
+        FeedbackCategory::BadResult => "bad-result",
+        FeedbackCategory::GoodResult => "good-result",
+        FeedbackCategory::SafetyCheck => "safety-check",
+        FeedbackCategory::Other => "other",
+    };
     let action: super::SelectionAction = Box::new(move |_sender: &AppEventSender| {
-        app_event_tx.send(AppEvent::OpenFeedbackConsent { category });
+        app_event_tx.send(AppEvent::HandleSlashCommandDraft(
+            format!("/feedback {token}").into(),
+        ));
     });
     super::SelectionItem {
         name: name.to_string(),

codex-rs/tui/src/bottom_pane/status_line_setup.rs

@@ -34,6 +34,7 @@ use crate::bottom_pane::bottom_pane_view::BottomPaneView;
 use crate::bottom_pane::multi_select_picker::MultiSelectItem;
 use crate::bottom_pane::multi_select_picker::MultiSelectPicker;
 use crate::render::renderable::Renderable;
+use crate::slash_command::SlashCommand;
 
 /// Available items that can be displayed in the status line.
 ///
@@ -231,12 +232,14 @@ impl StatusLineSetupView {
             .enable_ordering()
             .on_preview(move |items| preview_data.line_for_items(items))
             .on_confirm(|ids, app_event| {
-                let items = ids
-                    .iter()
-                    .map(|id| id.parse::<StatusLineItem>())
-                    .collect::<Result<Vec<_>, _>>()
-                    .unwrap_or_default();
-                app_event.send(AppEvent::StatusLineSetup { items });
+                let args = if ids.is_empty() {
+                    "none".to_string()
+                } else {
+                    ids.join(" ")
+                };
+                app_event.send(AppEvent::HandleSlashCommandDraft(
+                    format!("/{} {args}", SlashCommand::Statusline.command()).into(),
+                ));
             })
             .on_cancel(|app_event| {
                 app_event.send(AppEvent::StatusLineSetupCancelled);