Attach resumed sessions in-process and add the agent view composer

Two changes that together close the gap with Claude Code's agent view UX:

In-process attach. The previous Enter→resume path forced the outer CLI to
tear down the TUI and re-exec into `codex resume --thread <id>`, paying the
full startup cost (~2s of perceived lag). Reuse the existing
`replace_chat_widget_with_app_server_thread` helper to swap chat widgets
inside the running App loop instead — the new `attach_resumed_thread_from_browser`
helper calls `app_server.resume_thread`, builds a `ChatWidgetInit` via the
existing `chatwidget_init_for_forked_or_resumed_thread` plumbing, swaps the
widget, and replays the rollout. Attach feels instantaneous now.

Inline composer in the agent view. The selected row is no longer the only way
to act on a session — there is a 3-line input pane at the bottom of the
browser. Typing builds up a draft; Enter resumes the highlighted session
with that draft as the first user message (carried through
`ResumeThreadFromBrowser.initial_prompt`); `Ctrl+N` exits and re-launches a
fresh session with the draft as the initial prompt; `Esc` clears a non-empty
draft (and only closes the view when empty); arrow keys still navigate the
list while composing, while `j`/`k`/`g`/`G`/`q` stop hijacking the alphabet
once a draft is in flight.

Plumbing: extend `AppExitInfo` with `resume_initial_prompt` and
`start_new_session`, plus matching `AppEvent::StartNewSessionFromBrowser` for
the Ctrl+N path, and propagate both through the cli/main.rs re-launch loop
(the resume re-launch path stays as a fallback even though it is no longer
the primary route).

Smoke-verified end-to-end: Left opens the full-screen view, typing
populates the composer, Enter resumes the highlighted session into the same
process and immediately renders the typed message as the first user turn,
codex begins working on it, no `color_spantrace::set_theme` crash.

Co-authored-by: Open Codex <hff582580@gmail.com>

Author: 2 people

codex-rs/cli/src/main.rs

@@ -2076,12 +2076,24 @@ async fn run_interactive_tui(
         );
         let err = match attempt.await {
             Ok(exit_info) => {
-                // If the session browser overlay asked us to resume into a
-                // different thread, re-launch the TUI in place so the user
-                // perceives an in-app "attach".
+                // The session browser overlay can ask the outer loop to
+                // relaunch. Two cases:
+                //   * `start_new_session` — Ctrl+N: bring up a fresh codex
+                //     session, optionally with a typed prompt.
+                //   * `resume_thread_id` — kept as a fallback for
+                //     non-in-process paths (most resumes are now handled
+                //     in-process by `attach_resumed_thread_from_browser`).
+                if exit_info.start_new_session {
+                    interactive.resume_picker = false;
+                    interactive.resume_session_id = None;
+                    interactive.prompt = exit_info.resume_initial_prompt.clone();
+                    attempted_repair = false;
+                    continue;
+                }
                 if let Some(thread_id) = exit_info.resume_thread_id.clone() {
                     interactive.resume_picker = false;
                     interactive.resume_session_id = Some(thread_id);
+                    interactive.prompt = exit_info.resume_initial_prompt.clone();
                     attempted_repair = false;
                     continue;
                 }

codex-rs/tui/src/app.rs

@@ -382,6 +382,12 @@ pub struct AppExitInfo {
     /// When set, the outer CLI loop should re-launch the TUI in resume mode
     /// targeting this thread id. Populated by the session browser overlay.
     pub resume_thread_id: Option<String>,
+    /// Initial prompt text to inject into the next launch. Populated by the
+    /// agent view's inline composer.
+    pub resume_initial_prompt: Option<String>,
+    /// When true, the outer CLI should launch a fresh session (ignoring any
+    /// `resume_thread_id`). Triggered by `Ctrl+N` in the agent view.
+    pub start_new_session: bool,
 }
 
 impl AppExitInfo {
@@ -393,6 +399,8 @@ impl AppExitInfo {
             update_action: None,
             exit_reason: ExitReason::Fatal(message.into()),
             resume_thread_id: None,
+            resume_initial_prompt: None,
+            start_new_session: false,
         }
     }
 }
@@ -540,6 +548,12 @@ pub(crate) struct App {
     /// this thread id after the current TUI exits. Triggered by the session
     /// browser overlay.
     pub(crate) pending_resume_thread_id: Option<String>,
+    /// Initial prompt to inject into the resumed (or fresh) session created
+    /// after this TUI exits. Comes from the agent view's inline composer.
+    pub(crate) pending_resume_prompt: Option<String>,
+    /// When true, the outer CLI should launch a brand-new session instead of
+    /// resuming. `pending_resume_thread_id` is ignored when this is set.
+    pub(crate) pending_start_new_session: bool,
 
     windows_sandbox: WindowsSandboxState,
 
@@ -721,6 +735,8 @@ impl App {
                     update_action: None,
                     exit_reason: ExitReason::UserRequested,
                     resume_thread_id: None,
+                    resume_initial_prompt: None,
+                    start_new_session: false,
                 });
             }
         };
@@ -965,6 +981,8 @@ See the Codex keymap documentation for supported actions and examples."
             pending_update_action: None,
             pending_shutdown_exit_thread_id: None,
             pending_resume_thread_id: None,
+            pending_resume_prompt: None,
+            pending_start_new_session: false,
             windows_sandbox: WindowsSandboxState::default(),
             thread_event_channels: HashMap::new(),
             thread_event_listener_tasks: HashMap::new(),
@@ -1167,6 +1185,8 @@ See the Codex keymap documentation for supported actions and examples."
             update_action: app.pending_update_action,
             exit_reason,
             resume_thread_id: app.pending_resume_thread_id.take(),
+            resume_initial_prompt: app.pending_resume_prompt.take(),
+            start_new_session: std::mem::take(&mut app.pending_start_new_session),
         })
     }
 

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

@@ -1723,8 +1723,22 @@ impl App {
             AppEvent::SessionBrowserLoaded(sessions) => {
                 self.chat_widget.update_session_browser_sessions(sessions);
             }
-            AppEvent::ResumeThreadFromBrowser { thread_id } => {
-                self.pending_resume_thread_id = Some(thread_id);
+            AppEvent::ResumeThreadFromBrowser {
+                thread_id,
+                initial_prompt,
+            } => {
+                self.attach_resumed_thread_from_browser(
+                    tui,
+                    app_server,
+                    thread_id,
+                    initial_prompt,
+                )
+                .await?;
+            }
+            AppEvent::StartNewSessionFromBrowser { initial_prompt } => {
+                self.pending_start_new_session = true;
+                self.pending_resume_thread_id = None;
+                self.pending_resume_prompt = initial_prompt;
                 return Ok(self
                     .handle_exit_mode(app_server, ExitMode::ShutdownFirst)
                     .await);

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

@@ -490,6 +490,49 @@ impl App {
         tui.frame_requester().schedule_frame();
     }
 
+    /// In-process attach to a session selected from the agent view. Calls
+    /// `app_server.resume_thread` and reuses
+    /// [`Self::replace_chat_widget_with_app_server_thread`] so the swap happens
+    /// without exiting the App loop or re-launching the binary — much smoother
+    /// than the previous re-exec path.
+    pub(crate) async fn attach_resumed_thread_from_browser(
+        &mut self,
+        tui: &mut tui::Tui,
+        app_server: &mut AppServerSession,
+        thread_id_str: String,
+        initial_prompt: Option<String>,
+    ) -> Result<()> {
+        use codex_protocol::ThreadId;
+        let thread_id = match ThreadId::from_string(&thread_id_str) {
+            Ok(id) => id,
+            Err(err) => {
+                self.chat_widget
+                    .add_error_message(format!("Invalid thread id `{thread_id_str}`: {err}"));
+                return Ok(());
+            }
+        };
+        let started = match app_server.resume_thread(self.config.clone(), thread_id).await {
+            Ok(started) => started,
+            Err(err) => {
+                self.chat_widget
+                    .add_error_message(format!("Failed to resume session: {err:#}"));
+                return Ok(());
+            }
+        };
+        let initial_user_message = crate::chatwidget::create_initial_user_message(
+            initial_prompt,
+            Vec::new(),
+            Vec::new(),
+        );
+        self.replace_chat_widget_with_app_server_thread(
+            tui,
+            app_server,
+            started,
+            initial_user_message,
+        )
+        .await
+    }
+
     pub(super) async fn replace_chat_widget_with_app_server_thread(
         &mut self,
         tui: &mut tui::Tui,

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

@@ -307,6 +307,8 @@ pub(super) async fn handle_model_migration_prompt_if_needed(
                     update_action: None,
                     exit_reason: ExitReason::UserRequested,
                     resume_thread_id: None,
+                resume_initial_prompt: None,
+                start_new_session: false,
                 });
             }
         }

codex-rs/tui/src/app_event.rs

@@ -148,9 +148,17 @@ pub(crate) enum AppEvent {
     /// async I/O thread.
     SessionBrowserLoaded(Vec<codex_agent_view::SessionSummary>),
     /// User picked a session row in the browser; ask the outer loop to exit
-    /// and re-launch into resume mode for the given thread id.
+    /// and re-launch into resume mode for the given thread id. When the
+    /// composer at the bottom of the browser is non-empty, that text is
+    /// forwarded as the initial prompt for the resumed session.
     ResumeThreadFromBrowser {
         thread_id: String,
+        initial_prompt: Option<String>,
+    },
+    /// User pressed `Ctrl+N` in the browser. Exit and re-launch a brand-new
+    /// session using the typed text (if any) as the initial prompt.
+    StartNewSessionFromBrowser {
+        initial_prompt: Option<String>,
     },
     /// Peek panel finished loading rollout items for the highlighted session.
     SessionBrowserPeekLoaded(Box<codex_agent_view::PeekContent>),