Lightweight coding agent that runs in your terminal
Rust
Generate automatic and manual conversation recaps (#40705)
Felipe Coury6988d390b30b
diff --git a/codex-rs/tui/src/app/event_dispatch.rs b/codex-rs/tui/src/app/event_dispatch.rsindex 64e1b7c7c9..7ca0458d16 100644--- a/codex-rs/tui/src/app/event_dispatch.rs+++ b/codex-rs/tui/src/app/event_dispatch.rs@@ -6,6 +6,7 @@use super::resize_reflow::trailing_run_start;use super::session_lifecycle::ThreadAttachPresentation;use super::*;+use crate::app_event::RecapTrigger;use crate::app_event::ThreadTitleDestination;use crate::app_server_session::ForkGoalContinuation;use crate::app_server_session::UnsupportedLegacyPermissionProfile;@@ -2897,11 +2898,71 @@ impl App {AppEvent::KeymapCleared { context, action } => {self.apply_keymap_clear(context, action).await;}+ AppEvent::GenerateRecap { thread_id } => {+ if self.current_displayed_thread_id() == Some(thread_id) {+ if self.chat_widget.is_user_turn_pending_or_running() {+ self.chat_widget.add_error_message(+ "Wait for the current task to finish before running /recap.".to_string(),+ );+ } else {+ self.request_recap(app_server, thread_id, RecapTrigger::Manual);+ }+ }+ }AppEvent::CheckRecap { thread_id } => {- // The inference layer stacked on this change consumes the scheduled check.- let _ = thread_id;+ if self.current_displayed_thread_id() == Some(thread_id)+ && !self.chat_widget.is_user_turn_pending_or_running()+ && self.recap.should_generate(std::time::Instant::now())+ {+ self.request_recap(app_server, thread_id, RecapTrigger::Automatic);+ }+ }+ AppEvent::RecapStarted {+ thread_id,+ request_id,+ trigger,+ completed_turn_count,+ turn_revision,+ history,+ result,+ } => {+ self.handle_recap_started(+ app_server,+ recap::RecapRequest {+ thread_id,+ request_id,+ trigger,+ completed_turn_count,+ turn_revision,+ },+ history,+ result,+ );+ }+ AppEvent::RecapGenerated {+ thread_id,+ request_id,+ trigger,+ temporary_thread_id,+ completed_turn_count,+ turn_revision,+ result,+ } => {+ self.temporary_structured_requests.remove(&temporary_thread_id);+ if let Some(cell) = self.handle_generated_recap(+ recap::RecapRequest {+ thread_id,+ request_id,+ trigger,+ completed_turn_count,+ turn_revision,+ },+ temporary_thread_id,+ result,+ ) {+ self.insert_history_cell(tui, Box::new(cell));+ }}- AppEvent::RecapStarted { .. } | AppEvent::RecapGenerated { .. } => {}}Ok(AppRunControl::Continue)}diff --git a/codex-rs/tui/src/app/recap.rs b/codex-rs/tui/src/app/recap.rsindex 04783c9067..6cfc75f25e 100644--- a/codex-rs/tui/src/app/recap.rs+++ b/codex-rs/tui/src/app/recap.rs@@ -1,21 +1,21 @@//! Determines when an unfocused conversation is ready for an automatic recap.-// The stacked event-dispatch change activates the generation methods.-#![allow(dead_code)]-use std::sync::Arc;use std::time::Duration;use std::time::Instant;use super::App;use crate::app_event::AppEvent;+use crate::app_event::RecapTrigger;use crate::app_event_sender::AppEventSender;use crate::app_server_session::AppServerSession;use crate::history_cell::AgentMarkdownCell;use crate::history_cell::AgentMessageCell;use crate::history_cell::HistoryCell;use crate::history_cell::ThreadRecapHistoryCell;+use crate::history_cell::ThreadRecapLoadingCell;use crate::history_cell::UserHistoryCell;+use crate::pager_overlay::Overlay;use crate::temporary_structured_request::TemporaryStructuredThreadOptions;use crate::temporary_structured_request::run_temporary_structured_turn;use crate::temporary_structured_request::start_temporary_thread;@@ -36,6 +36,9 @@ pub(super) const RECAP_DELAY: Duration = Duration::from_secs(/*secs*/ 3 * 60);const RECAP_HISTORY_MAX_TURNS: usize = 8;const RECAP_MAX_CHARS: usize = 320;const RECAP_RETRY_DELAY: Duration = Duration::from_secs(/*secs*/ 30);+const MANUAL_RECAP_FAILURE_MESSAGE: &str = "Could not generate a recap. Please try again.";+const MANUAL_RECAP_IN_PROGRESS_MESSAGE: &str = "A recap is already being generated.";+const MANUAL_RECAP_EMPTY_HISTORY_MESSAGE: &str = "There is no conversation history to recap.";const RECAP_PROMPT_PREFIX: &str = concat!("Write a brief catch-up for a user returning to this Codex task. ","In at most 40 words and one or two plain-text sentences, explain the ",@@ -46,7 +49,7 @@ const RECAP_PROMPT_PREFIX: &str = concat!("of inventing more work. Use the user's language; omit greetings, ","markdown, lists, and tool chatter.\n\nRecent conversation:\n",);-const RECAP_PROMPT_MAX_BYTES: usize = 900;+pub(super) const RECAP_PROMPT_MAX_BYTES: usize = 900;fn render_recap_message(role: &str, content: &str, max_bytes: usize) -> Option<String> {let prefix = format!("{role}: ");@@ -167,24 +170,79 @@ fn parse_recap(response: &str) -> Option<String> {pub(super) struct RecapRequest {pub(super) thread_id: ThreadId,pub(super) request_id: Uuid,+ pub(super) trigger: RecapTrigger,pub(super) completed_turn_count: usize,pub(super) turn_revision: usize,}impl App {- pub(super) fn request_recap(&mut self, app_server: &AppServerSession, thread_id: ThreadId) {+ fn clear_recap_request(&mut self, trigger: RecapTrigger) {+ self.recap.clear_in_flight_request();++ if !matches!(trigger, RecapTrigger::Manual) {+ return;+ }++ self.chat_widget.clear_recap_loading();++ let Some(index) = self+ .transcript_cells+ .iter()+ .rposition(|cell| cell.as_any().is::<ThreadRecapLoadingCell>())+ else {+ return;+ };++ self.transcript_cells.remove(index);+ if let Some(Overlay::Transcript(overlay)) = &mut self.overlay {+ overlay.replace_cells(self.transcript_cells.clone());+ }+ }++ fn retry_or_report_recap_failure(&mut self, request: RecapRequest) {+ match request.trigger {+ RecapTrigger::Automatic => self.recap.schedule_retry(+ request.thread_id,+ self.app_event_tx.clone(),+ request.turn_revision,+ ),+ RecapTrigger::Manual => self+ .chat_widget+ .add_error_message(MANUAL_RECAP_FAILURE_MESSAGE.to_string()),+ }+ }++ pub(super) fn request_recap(+ &mut self,+ app_server: &AppServerSession,+ thread_id: ThreadId,+ trigger: RecapTrigger,+ ) {if self.recap.in_flight_request.is_some() {+ if matches!(trigger, RecapTrigger::Manual) {+ self.chat_widget+ .add_error_message(MANUAL_RECAP_IN_PROGRESS_MESSAGE.to_string());+ }return;}let history = recap_history(&self.transcript_cells);if history.is_empty() {+ if matches!(trigger, RecapTrigger::Manual) {+ self.chat_widget+ .add_error_message(MANUAL_RECAP_EMPTY_HISTORY_MESSAGE.to_string());+ }return;}+ if matches!(trigger, RecapTrigger::Manual) {+ self.chat_widget.show_recap_loading();+ }+let request = RecapRequest {thread_id,request_id: Uuid::new_v4(),+ trigger,completed_turn_count: self.recap.completed_turns,turn_revision: self.recap.turn_revision,};@@ -219,6 +277,7 @@ impl App {event_sender.send(AppEvent::RecapStarted {thread_id: request.thread_id,request_id: request.request_id,+ trigger: request.trigger,completed_turn_count: request.completed_turn_count,turn_revision: request.turn_revision,history,@@ -227,6 +286,7 @@ impl App {});self.recap.in_flight_request_id = Some(request.request_id);+ self.recap.in_flight_trigger = Some(request.trigger);self.recap.in_flight_request = Some(task);}@@ -240,10 +300,12 @@ impl App {let RecapRequest {thread_id,request_id,+ trigger,completed_turn_count,turn_revision,} = request;- let is_current_request = self.recap.in_flight_request_id == Some(request_id);+ let is_current_request = self.recap.in_flight_request_id == Some(request_id)+ && self.recap.in_flight_trigger == Some(trigger);if is_current_request {self.recap.in_flight_request.take();}@@ -252,34 +314,37 @@ impl App {Ok(temporary_thread_id) => temporary_thread_id,Err(error) => {if is_current_request {- self.recap.in_flight_request_id = None;+ self.clear_recap_request(trigger);tracing::warn!(%thread_id, %error, "failed to start thread recap request");- self.recap- .schedule_retry(thread_id, self.app_event_tx.clone(), turn_revision);+ self.retry_or_report_recap_failure(request);}return;}};+ let trigger_is_eligible = match trigger {+ RecapTrigger::Automatic => self.recap.should_generate(Instant::now()),+ RecapTrigger::Manual => true,+ };+let request_is_fresh = is_current_request&& self.current_displayed_thread_id() == Some(thread_id)&& !self.chat_widget.is_user_turn_pending_or_running()&& self.recap.completed_turns == completed_turn_count&& self.recap.turn_revision == turn_revision- && self.recap.should_generate(Instant::now());+ && trigger_is_eligible;let Ok(temporary_thread_id) = ThreadId::from_string(&temporary_thread_id_text) else {if is_current_request {- self.recap.in_flight_request_id = None;+ self.clear_recap_request(trigger);tracing::warn!(%thread_id, "thread recap request returned an invalid thread ID");- self.recap- .schedule_retry(thread_id, self.app_event_tx.clone(), turn_revision);+ self.retry_or_report_recap_failure(request);}return;};if !request_is_fresh {if is_current_request {- self.recap.in_flight_request_id = None;+ self.clear_recap_request(trigger);}let request_handle = app_server.request_handle();tokio::spawn(async move {@@ -309,6 +374,7 @@ impl App {event_sender.send(AppEvent::RecapGenerated {thread_id,request_id,+ trigger,temporary_thread_id,completed_turn_count,turn_revision,@@ -329,18 +395,18 @@ impl App {let RecapRequest {thread_id,request_id,+ trigger,completed_turn_count,turn_revision,} = request;if self.recap.in_flight_request_id != Some(request_id)+ || self.recap.in_flight_trigger != Some(trigger)|| self.recap.in_flight_thread_id != Some(temporary_thread_id){return None;}- self.recap.in_flight_request_id = None;- self.recap.in_flight_thread_id = None;- self.recap.in_flight_request.take();+ self.clear_recap_request(trigger);if self.current_displayed_thread_id() != Some(thread_id)|| self.chat_widget.is_user_turn_pending_or_running()@@ -354,8 +420,7 @@ impl App {Ok(response) => {let Some(recap) = parse_recap(&response) else {tracing::warn!(%thread_id, "generated thread recap was invalid");- self.recap- .schedule_retry(thread_id, self.app_event_tx.clone(), turn_revision);+ self.retry_or_report_recap_failure(request);return None;};@@ -364,8 +429,7 @@ impl App {}Err(error) => {tracing::warn!(%thread_id, %error, "failed to generate thread recap");- self.recap- .schedule_retry(thread_id, self.app_event_tx.clone(), turn_revision);+ self.retry_or_report_recap_failure(request);None}}@@ -407,11 +471,19 @@ pub(super) struct RecapState {scheduled_check: Option<JoinHandle<()>>,retry_revision: Option<usize>,in_flight_request_id: Option<Uuid>,+ in_flight_trigger: Option<RecapTrigger>,in_flight_thread_id: Option<ThreadId>,in_flight_request: Option<JoinHandle<()>>,}impl RecapState {+ fn clear_in_flight_request(&mut self) {+ self.in_flight_request_id = None;+ self.in_flight_trigger = None;+ self.in_flight_thread_id = None;+ self.in_flight_request.take();+ }+pub(super) fn seed_from_turns(&mut self, turns: &[Turn], now: Instant) {self.seed_from_progress(RecapProgress::from_turns(turns), now);}@@ -456,9 +528,9 @@ impl RecapState {}self.retry_revision = None;- self.in_flight_request_id = None;- self.in_flight_thread_id = None;- self.in_flight_request.take();+ if self.in_flight_trigger == Some(RecapTrigger::Automatic) {+ self.clear_in_flight_request();+ }}pub(super) fn note_turn_finished(&mut self, status: &TurnStatus, now: Instant) {diff --git a/codex-rs/tui/src/app/recap_tests.rs b/codex-rs/tui/src/app/recap_tests.rsindex b9618f28ed..0e738385e0 100644--- a/codex-rs/tui/src/app/recap_tests.rs+++ b/codex-rs/tui/src/app/recap_tests.rs@@ -12,12 +12,14 @@ use super::recap_history;use super::recap_prompt;use crate::app::test_support::make_test_app;use crate::app_event::AppEvent;+use crate::app_event::RecapTrigger;use crate::app_event_sender::AppEventSender;use crate::history_cell::AgentMarkdownCell;use crate::history_cell::AgentMessageCell;use crate::history_cell::HistoryCell;use crate::history_cell::PlainHistoryCell;use crate::history_cell::ThreadRecapHistoryCell;+use crate::history_cell::ThreadRecapLoadingCell;use crate::history_cell::UserHistoryCell;use codex_app_server_protocol::Turn;use codex_app_server_protocol::TurnStatus;@@ -275,6 +277,43 @@ async fn regaining_focus_cancels_scheduled_check() {));}+#[test]+fn regaining_focus_preserves_only_manual_in_flight_request() {+ let request_id = Uuid::new_v4();+ let thread_id = ThreadId::new();+ let mut state = RecapState::default();+ state.in_flight_request_id = Some(request_id);+ state.in_flight_trigger = Some(RecapTrigger::Manual);+ state.in_flight_thread_id = Some(thread_id);++ state.note_focus_gained();++ assert_eq!(+ (+ state.in_flight_request_id,+ state.in_flight_trigger,+ state.in_flight_thread_id,+ ),+ (+ Some(request_id),+ Some(RecapTrigger::Manual),+ Some(thread_id),+ )+ );++ state.in_flight_trigger = Some(RecapTrigger::Automatic);+ state.note_focus_gained();++ assert_eq!(+ (+ state.in_flight_request_id,+ state.in_flight_trigger,+ state.in_flight_thread_id,+ ),+ (None, None, None)+ );+}+#[tokio::test(flavor = "current_thread", start_paused = true)]async fn scheduled_check_fires_at_recap_deadline() {let thread_id = ThreadId::new();@@ -537,6 +576,7 @@ fn track_in_flight_recap(app: &mut App, thread_id: ThreadId) -> (RecapRequest, Tlet request = RecapRequest {thread_id,request_id: Uuid::new_v4(),+ trigger: RecapTrigger::Automatic,completed_turn_count: 3,turn_revision: 3,};@@ -544,6 +584,7 @@ fn track_in_flight_recap(app: &mut App, thread_id: ThreadId) -> (RecapRequest, Tapp.recap.completed_turns = request.completed_turn_count;app.recap.turn_revision = request.turn_revision;app.recap.in_flight_request_id = Some(request.request_id);+ app.recap.in_flight_trigger = Some(request.trigger);app.recap.in_flight_thread_id = Some(temporary_thread_id);app.recap.in_flight_request = Some(tokio::spawn(async {}));(request, temporary_thread_id)@@ -618,6 +659,39 @@ async fn newer_terminal_turn_invalidates_generated_recap() {assert!(app.recap.in_flight_request.is_none());}+#[tokio::test(flavor = "current_thread", start_paused = true)]+async fn manual_recap_failure_does_not_schedule_retry() {+ let thread_id = ThreadId::new();+ let mut app = app_with_visible_thread(thread_id).await;+ let (mut request, temporary_thread_id) = track_in_flight_recap(&mut app, thread_id);+ request.trigger = RecapTrigger::Manual;+ app.recap.in_flight_trigger = Some(RecapTrigger::Manual);+ app.transcript_cells+ .push(Arc::new(ThreadRecapLoadingCell::new(+ /*animations_enabled*/ false,+ )));++ assert!(+ app.handle_generated_recap(+ request,+ temporary_thread_id,+ Err("temporary failure".to_string()),+ )+ .is_none()+ );++ tokio::time::advance(RECAP_RETRY_DELAY).await;+ tokio::task::yield_now().await;++ assert_eq!(app.recap.retry_revision, None);+ assert!(app.recap.scheduled_check.is_none());+ assert!(+ !app.transcript_cells+ .iter()+ .any(|cell| cell.as_any().is::<ThreadRecapLoadingCell>())+ );+}+#[tokio::test(flavor = "current_thread", start_paused = true)]async fn recap_failure_retries_once_for_the_same_turn_revision() {let thread_id = ThreadId::new();diff --git a/codex-rs/tui/src/app/tests.rs b/codex-rs/tui/src/app/tests.rsindex f5c76a0e13..066df4e05e 100644--- a/codex-rs/tui/src/app/tests.rs+++ b/codex-rs/tui/src/app/tests.rs@@ -17,6 +17,8 @@ mod patch_approval_tests;mod permission_shortcuts_tests;mod plugin_catalog;mod rate_limits;+#[path = "tests/recap_generation_tests.rs"]+mod recap_generation;mod safety_buffering;#[path = "tests/session_lifecycle_requests.rs"]mod session_lifecycle_requests;diff --git a/codex-rs/tui/src/app/tests/recap_generation_tests.rs b/codex-rs/tui/src/app/tests/recap_generation_tests.rsnew file mode 100644index 0000000000..98d10c6dfa--- /dev/null+++ b/codex-rs/tui/src/app/tests/recap_generation_tests.rs@@ -0,0 +1,417 @@+use super::*;+use crate::app::session_lifecycle::ThreadAttachPresentation;+use crate::app::tests::session_lifecycle_requests::recorded_params;+use crate::app::tests::session_lifecycle_requests::start_recording_remote_app_server;+use crate::app_event::RecapTrigger;+use core_test_support::responses;+use core_test_support::responses::ev_assistant_message;+use core_test_support::responses::ev_completed;+use core_test_support::responses::ev_response_created;+use core_test_support::streaming_sse::StreamingSseChunk;+use core_test_support::streaming_sse::start_streaming_sse_server;+use pretty_assertions::assert_eq;+use ratatui::buffer::Buffer;+use ratatui::layout::Rect;+use serde_json::Value;++const MODEL: &str = "gpt-5.2";+const MODEL_PROVIDER_ID: &str = "recap-generation-test";++fn render_chat_widget(app: &App) -> String {+ let area = Rect::new(+ /*x*/ 0, /*y*/ 0, /*width*/ 80, /*height*/ 24,+ );+ let mut buffer = Buffer::empty(area);+ app.chat_widget.render(area, &mut buffer);+ (area.y..area.bottom())+ .map(|y| {+ (area.x..area.right())+ .map(|x| buffer[(x, y)].symbol())+ .collect::<String>()+ })+ .collect::<Vec<_>>()+ .join("\n")+}++fn prepare_eligible_recap(app: &mut App, thread_id: ThreadId) {+ app.active_thread_id = Some(thread_id);+ app.transcript_cells+ .push(Arc::new(crate::history_cell::UserHistoryCell {+ message: "Finish the recap implementation".to_string(),+ text_elements: Vec::new(),+ local_image_paths: Vec::new(),+ remote_image_urls: Vec::new(),+ }));+ let ready_at = Instant::now() - recap::RECAP_DELAY;+ app.recap.note_focus_lost(ready_at);+ for _ in 0..3 {+ app.recap+ .note_turn_finished(&TurnStatus::Completed, ready_at);+ }+}++#[tokio::test(flavor = "multi_thread", worker_threads = 2)]+async fn recap_generation_uses_bounded_structured_request_and_inserts_result() -> Result<()> {+ let chunks = [+ ev_response_created("recap-response"),+ ev_assistant_message(+ "recap-message",+ r#"{"recap":"Finished parsing. Next: run focused tests."}"#,+ ),+ ev_completed("recap-response"),+ ]+ .into_iter()+ .map(|event| StreamingSseChunk {+ gate: None,+ body: responses::sse(vec![event]),+ })+ .collect();+ let (model_server, _completions) = start_streaming_sse_server(vec![chunks]).await;+ let (mut app, mut app_event_rx, _op_rx) = make_test_app_with_channels().await;+ let codex_home = tempdir()?;+ std::fs::write(+ codex_home.path().join("config.toml"),+ format!(+ r#"+model = "{MODEL}"+model_provider = "{MODEL_PROVIDER_ID}"++[model_providers.{MODEL_PROVIDER_ID}]+name = "Recap generation test"+base_url = "{}/v1"+wire_api = "responses"+request_max_retries = 0+stream_max_retries = 0+"#,+ model_server.uri()+ ),+ )?;+ app.config.codex_home = codex_home.path().to_path_buf().abs();+ app.config.sqlite = codex_state::SqliteConfig::new_for_testing(codex_home.path().abs());+ app.config.model = Some(MODEL.to_string());+ app.config.model_provider_id = MODEL_PROVIDER_ID.to_string();+ app.config.model_provider = ModelProviderInfo {+ name: "Recap generation test".to_string(),+ base_url: Some(format!("{}/v1", model_server.uri())),+ request_max_retries: Some(0),+ stream_max_retries: Some(0),+ ..ModelProviderInfo::default()+ };++ let mut app_server = Box::pin(crate::start_embedded_app_server_for_picker(&app.config)).await?;+ let started = app_server.start_thread(&app.config).await?;+ let thread_id = started.session.thread_id;+ let mut tui = crate::tui::test_support::make_test_tui()?;+ app.replace_chat_widget_with_app_server_thread(+ &mut tui,+ started,+ ThreadAttachPresentation::SessionLineage,+ /*initial_user_message*/ None,+ )+ .await?;+ while app_event_rx.try_recv().is_ok() {}++ prepare_eligible_recap(&mut app, thread_id);++ app.handle_event(+ &mut tui,+ &mut app_server,+ AppEvent::CheckRecap { thread_id },+ )+ .await?;+ let started_event = tokio::time::timeout(Duration::from_secs(/*secs*/ 5), app_event_rx.recv())+ .await?+ .expect("recap start event");+ assert!(matches!(started_event, AppEvent::RecapStarted { .. }));+ app.handle_event(&mut tui, &mut app_server, started_event)+ .await?;++ let generated_event = tokio::time::timeout(Duration::from_secs(/*secs*/ 5), async {+ loop {+ tokio::select! {+ event = app_event_rx.recv() => {+ let event = event.expect("app event stream");+ if matches!(event, AppEvent::RecapGenerated { .. }) {+ break Ok::<_, color_eyre::Report>(event);+ }+ app.handle_event(&mut tui, &mut app_server, event).await?;+ }+ event = app_server.next_event() => {+ let event = event.expect("app-server event stream");+ app.handle_app_server_event(&app_server, event).await;+ }+ }+ }+ })+ .await??;+ app.handle_event(&mut tui, &mut app_server, generated_event)+ .await?;++ let recap = app+ .transcript_cells+ .last()+ .and_then(|cell| {+ cell.as_any()+ .downcast_ref::<crate::history_cell::ThreadRecapHistoryCell>()+ })+ .expect("recap history cell");+ assert_eq!(+ recap+ .raw_lines()+ .iter()+ .map(ToString::to_string)+ .collect::<Vec<_>>(),+ vec![+ "Conversation recap",+ "Finished parsing. Next: run focused tests.",+ ]+ );++ let model_requests = model_server.requests().await;+ assert_eq!(model_requests.len(), 1);+ let request: Value = serde_json::from_slice(&model_requests[0])?;+ let prompt = request["input"]+ .as_array()+ .and_then(|items| items.iter().rfind(|item| item["role"] == "user"))+ .and_then(|item| item["content"].as_array())+ .and_then(|content| content.iter().find(|item| item["type"] == "input_text"))+ .and_then(|item| item["text"].as_str())+ .expect("recap prompt");+ assert!(+ prompt.contains("Finish the recap implementation"),+ "prompt: {prompt}\nrequest: {request}"+ );+ assert!(prompt.len() <= recap::RECAP_PROMPT_MAX_BYTES);+ assert_eq!(request["text"]["format"]["type"], "json_schema");+ assert_eq!(request["tools"], serde_json::json!([]));++ app_server.shutdown().await?;+ model_server.shutdown().await;+ Ok(())+}++#[tokio::test]+async fn manual_recap_bypasses_automatic_eligibility_and_reports_failure() -> Result<()> {+ let (mut app, mut app_event_rx, _op_rx) = make_test_app_with_channels().await;+ let thread_id = ThreadId::new();+ app.active_thread_id = Some(thread_id);+ app.transcript_cells+ .push(Arc::new(crate::history_cell::UserHistoryCell {+ message: "Summarize this conversation".to_string(),+ text_elements: Vec::new(),+ local_image_paths: Vec::new(),+ remote_image_urls: Vec::new(),+ }));+ let (mut app_server, _requests, proxy) = start_recording_remote_app_server(&app.config).await?;+ let mut tui = crate::tui::test_support::make_test_tui()?;++ app.handle_event(+ &mut tui,+ &mut app_server,+ AppEvent::GenerateRecap { thread_id },+ )+ .await?;+ assert!(+ render_chat_widget(&app).contains("Generating conversation recap…"),+ "manual recap should show progress while generation is in flight"+ );+ let started_event = tokio::time::timeout(Duration::from_secs(/*secs*/ 5), app_event_rx.recv())+ .await?+ .expect("manual recap start event");+ let (request, temporary_thread_id) = match &started_event {+ AppEvent::RecapStarted {+ thread_id: requested_thread_id,+ request_id,+ trigger,+ completed_turn_count,+ turn_revision,+ result: Ok(temporary_thread_id),+ ..+ } if *requested_thread_id == thread_id && *trigger == RecapTrigger::Manual => (+ recap::RecapRequest {+ thread_id: *requested_thread_id,+ request_id: *request_id,+ trigger: *trigger,+ completed_turn_count: *completed_turn_count,+ turn_revision: *turn_revision,+ },+ ThreadId::from_string(temporary_thread_id).expect("temporary recap thread ID"),+ ),+ other => panic!("expected a started manual recap, got {other:?}"),+ };++ app.handle_event(&mut tui, &mut app_server, started_event)+ .await?;++ assert_eq!(app.temporary_structured_requests.len(), 1);+ assert!(+ app.handle_generated_recap(+ request,+ temporary_thread_id,+ Err("temporary failure".to_string()),+ )+ .is_none()+ );+ assert!(+ !render_chat_widget(&app).contains("Generating conversation recap…"),+ "manual recap progress should clear when generation finishes"+ );++ let cell = match app_event_rx.try_recv() {+ Ok(AppEvent::InsertHistoryCell(cell)) => cell,+ other => panic!("expected visible manual recap error, got {other:?}"),+ };+ let rendered = lines_to_single_string(&cell.display_lines(/*width*/ 80));+ assert!(+ rendered.contains("Could not generate a recap. Please try again."),+ "rendered error: {rendered:?}"+ );++ app_server.shutdown().await?;+ proxy.await??;+ Ok(())+}++#[tokio::test]+async fn recap_generation_uses_remote_workspace_cwd() -> Result<()> {+ let (mut app, mut app_event_rx, _op_rx) = make_test_app_with_channels().await;+ let remote_cwd = if cfg!(windows) {+ PathBuf::from(r"C:\remote\project")+ } else {+ PathBuf::from("/srv/remote/project")+ };+ let (app_server, requests, proxy) = start_recording_remote_app_server(&app.config).await?;+ let mut app_server = app_server.with_remote_cwd_override(Some(remote_cwd.clone()));+ let mut tui = crate::tui::test_support::make_test_tui()?;+ app.transcript_cells+ .push(Arc::new(crate::history_cell::UserHistoryCell {+ message: "Finish the recap implementation".to_string(),+ text_elements: Vec::new(),+ local_image_paths: Vec::new(),+ remote_image_urls: Vec::new(),+ }));++ app.request_recap(&app_server, ThreadId::new(), RecapTrigger::Automatic);+ let started_event = tokio::time::timeout(Duration::from_secs(/*secs*/ 5), app_event_rx.recv())+ .await?+ .expect("recap start event");+ app.handle_event(&mut tui, &mut app_server, started_event)+ .await?;++ let starts = recorded_params(&requests, "thread/start");+ assert_eq!(starts.len(), 1);+ assert_eq!(starts[0]["cwd"], remote_cwd.to_string_lossy().into_owned());+ assert_eq!(starts[0]["ephemeral"], true);+ assert_eq!(starts[0]["environments"], serde_json::json!([]));++ app_server.shutdown().await?;+ proxy.await??;+ Ok(())+}++#[tokio::test]+async fn temporary_recap_threads_disable_memories_and_remote_mcp_servers() -> Result<()> {+ let (mut app, _app_event_rx, _op_rx) = make_test_app_with_channels().await;+ let codex_home = tempdir()?;+ std::fs::write(+ codex_home.path().join("config.toml"),+ "[mcp_servers.filesystem]\ncommand = 'true'\n",+ )?;+ app.config.codex_home = codex_home.path().to_path_buf().abs();+ app.config.sqlite = codex_state::SqliteConfig::new_for_testing(codex_home.path().abs());+ let (app_server, requests, proxy) = start_recording_remote_app_server(&app.config).await?;++ let config = app.chat_widget.config_ref();+ let options = crate::temporary_structured_request::TemporaryStructuredThreadOptions {+ model: app.chat_widget.current_model().to_string(),+ model_provider: config.model_provider_id.clone(),+ cwd: config.cwd.display().to_string(),+ active_permission_profile: config+ .permissions+ .active_permission_profile()+ .map(|profile| profile.id),+ mcp_server_names: Vec::new(),+ };+ crate::temporary_structured_request::start_temporary_thread(+ &app_server.request_handle(),+ options,+ )+ .await?;++ let starts = recorded_params(&requests, "thread/start");+ assert_eq!(starts.len(), 1);+ assert_eq!(starts[0]["config"]["features.memories"], false);+ assert!(starts[0]["config"].get("features.memory_tool").is_none());+ assert_eq!(+ starts[0]["config"]["mcp_servers"]["filesystem"]["enabled"],+ false+ );++ app_server.shutdown().await?;+ proxy.await??;+ Ok(())+}++#[tokio::test]+async fn recap_check_rejects_a_non_displayed_thread() -> Result<()> {+ let (mut app, mut app_event_rx, _op_rx) = make_test_app_with_channels().await;+ let displayed_thread_id = ThreadId::new();+ prepare_eligible_recap(&mut app, displayed_thread_id);+ while app_event_rx.try_recv().is_ok() {}+ let (mut app_server, requests, proxy) = start_recording_remote_app_server(&app.config).await?;+ let mut tui = crate::tui::test_support::make_test_tui()?;++ app.handle_event(+ &mut tui,+ &mut app_server,+ AppEvent::CheckRecap {+ thread_id: ThreadId::new(),+ },+ )+ .await?;+ tokio::task::yield_now().await;++ assert!(app_event_rx.try_recv().is_err());+ assert_eq!(+ recorded_params(&requests, "thread/start"),+ Vec::<Value>::new()+ );++ app_server.shutdown().await?;+ proxy.await??;+ Ok(())+}++#[tokio::test]+async fn recap_check_rejects_a_running_turn() -> Result<()> {+ let (mut app, mut app_event_rx, _op_rx) = make_test_app_with_channels().await;+ let thread_id = ThreadId::new();+ prepare_eligible_recap(&mut app, thread_id);+ app.chat_widget+ .handle_thread_session(test_thread_session(thread_id, app.config.cwd.to_path_buf()));+ app.chat_widget.handle_server_notification(+ turn_started_notification(thread_id, "active-turn"),+ /*replay_kind*/ None,+ );+ while app_event_rx.try_recv().is_ok() {}+ let (mut app_server, requests, proxy) = start_recording_remote_app_server(&app.config).await?;+ let mut tui = crate::tui::test_support::make_test_tui()?;++ app.handle_event(+ &mut tui,+ &mut app_server,+ AppEvent::CheckRecap { thread_id },+ )+ .await?;+ tokio::task::yield_now().await;++ assert!(app_event_rx.try_recv().is_err());+ assert_eq!(+ recorded_params(&requests, "thread/start"),+ Vec::<Value>::new()+ );++ app_server.shutdown().await?;+ proxy.await??;+ Ok(())+}diff --git a/codex-rs/tui/src/app/tests/session_lifecycle_requests.rs b/codex-rs/tui/src/app/tests/session_lifecycle_requests.rsindex 5e88addf3c..8732ae3dfa 100644--- a/codex-rs/tui/src/app/tests/session_lifecycle_requests.rs+++ b/codex-rs/tui/src/app/tests/session_lifecycle_requests.rs@@ -37,8 +37,8 @@ use tokio::task::JoinHandle;use tokio_tungstenite::accept_async;use tokio_tungstenite::tungstenite::Message;-type RecordedRequests = Arc<Mutex<Vec<JSONRPCRequest>>>;-type RecordingAppServer = (AppServerSession, RecordedRequests, JoinHandle<Result<()>>);+pub(super) type RecordedRequests = Arc<Mutex<Vec<JSONRPCRequest>>>;+pub(super) type RecordingAppServer = (AppServerSession, RecordedRequests, JoinHandle<Result<()>>);#[derive(Clone, Copy, Debug, Eq, PartialEq)]enum HistoryCapabilities {@@ -75,6 +75,20 @@ pub(super) async fn start_recording_app_server(HistoryCapabilities::Current,blocked_thread_list,failed_thread_name,+ crate::app_server_session::ThreadParamsMode::Embedded,+ )+ .await+}++pub(super) async fn start_recording_remote_app_server(+ config: &Config,+) -> Result<RecordingAppServer> {+ start_recording_app_server_with_history(+ config,+ HistoryCapabilities::Current,+ /*blocked_thread_list*/ None,+ /*failed_thread_name*/ None,+ crate::app_server_session::ThreadParamsMode::Remote,).await}@@ -85,6 +99,7 @@ async fn start_recording_app_server_with_history(history_capabilities: HistoryCapabilities,mut blocked_thread_list: Option<(ThreadId, oneshot::Sender<()>, oneshot::Receiver<()>)>,failed_thread_name: Option<&'static str>,+ thread_params_mode: crate::app_server_session::ThreadParamsMode,) -> Result<RecordingAppServer> {let state_db =crate::init_state_db_for_app_server_target(config, &crate::AppServerTarget::Embedded)@@ -299,11 +314,7 @@ async fn start_recording_app_server_with_history(.await?;Ok((- AppServerSession::new(- app_server,- crate::app_server_session::ThreadParamsMode::Embedded,- )- .with_startup_config(config),+ AppServerSession::new(app_server, thread_params_mode).with_startup_config(config),requests,proxy,))@@ -330,7 +341,7 @@ fn create_history_rollout(Ok(ThreadId::from_string(&thread_id)?)}-fn recorded_params(requests: &RecordedRequests, method: &str) -> Vec<serde_json::Value> {+pub(super) fn recorded_params(requests: &RecordedRequests, method: &str) -> Vec<serde_json::Value> {requests.lock().expect("request recorder lock")@@ -930,6 +941,7 @@ async fn older_external_server_starts_without_unsupported_dynamic_tools_or_histoHistoryCapabilities::LegacyDynamicToolsAndHistory,/*blocked_thread_list*/ None,/*failed_thread_name*/ None,+ crate::app_server_session::ThreadParamsMode::Embedded,).await?;@@ -1762,6 +1774,7 @@ async fn remote_legacy_history_start_negotiates_once_for_resume_and_fork() -> ReHistoryCapabilities::LegacyOnly,/*blocked_thread_list*/ None,/*failed_thread_name*/ None,+ crate::app_server_session::ThreadParamsMode::Embedded,).await?;@@ -1852,6 +1865,7 @@ async fn remote_legacy_history_start_retries_unsupported_paginated_variant() ->HistoryCapabilities::LegacyOnlyUnsupportedVariant,/*blocked_thread_list*/ None,/*failed_thread_name*/ None,+ crate::app_server_session::ThreadParamsMode::Embedded,).await?;@@ -1882,6 +1896,7 @@ async fn assert_remote_legacy_history_retry(request: LegacyHistoryRequest) -> ReHistoryCapabilities::LegacyOnly,/*blocked_thread_list*/ None,/*failed_thread_name*/ None,+ crate::app_server_session::ThreadParamsMode::Embedded,).await?;@@ -1947,6 +1962,7 @@ async fn paginated_fork_survives_post_response_hydration_failure() -> Result<()>HistoryCapabilities::ForkHydrationFails,/*blocked_thread_list*/ None,/*failed_thread_name*/ None,+ crate::app_server_session::ThreadParamsMode::Embedded,).await?;diff --git a/codex-rs/tui/src/app_event.rs b/codex-rs/tui/src/app_event.rsindex 8740e3da62..a8126066d9 100644--- a/codex-rs/tui/src/app_event.rs+++ b/codex-rs/tui/src/app_event.rs@@ -204,6 +204,13 @@ pub(crate) enum ThreadTitleDestination {RenameSuggestion { request_id: Uuid },}+/// Identifies the policy that initiated a recap request.+#[derive(Debug, Clone, Copy, PartialEq, Eq)]+pub(crate) enum RecapTrigger {+ Automatic,+ Manual,+}+#[allow(clippy::large_enum_variant)]#[derive(Debug, IntoStaticStr)]pub(crate) enum AppEvent {@@ -1326,16 +1333,21 @@ pub(crate) enum AppEvent {action: String,},+ /// Generate a recap for the displayed idle thread at the user's request.+ GenerateRecap {+ thread_id: ThreadId,+ },+/// Recheck whether an unfocused thread is ready for an automatic recap.CheckRecap {thread_id: ThreadId,},- /// Deliver the result of starting an automatic recap's temporary thread.- #[allow(dead_code)]+ /// Deliver the result of starting a recap's temporary thread.RecapStarted {thread_id: ThreadId,request_id: Uuid,+ trigger: RecapTrigger,completed_turn_count: usize,turn_revision: usize,history: String,@@ -1343,10 +1355,10 @@ pub(crate) enum AppEvent {},/// Deliver the generated recap from a temporary structured turn.- #[allow(dead_code)]RecapGenerated {thread_id: ThreadId,request_id: Uuid,+ trigger: RecapTrigger,temporary_thread_id: ThreadId,completed_turn_count: usize,turn_revision: usize,diff --git a/codex-rs/tui/src/bottom_pane/snapshots/codex_tui__bottom_pane__command_popup__tests__command_popup_default_items.snap b/codex-rs/tui/src/bottom_pane/snapshots/codex_tui__bottom_pane__command_popup__tests__command_popup_default_items.snapindex 7dcde80358..8bbb6892df 100644--- a/codex-rs/tui/src/bottom_pane/snapshots/codex_tui__bottom_pane__command_popup__tests__command_popup_default_items.snap+++ b/codex-rs/tui/src/bottom_pane/snapshots/codex_tui__bottom_pane__command_popup__tests__command_popup_default_items.snap@@ -23,6 +23,7 @@ expression: commands/app - continue this session in the Desktop app/init - create an AGENTS.md file with instructions for Codex/compact - summarize conversation to prevent hitting the context limit+/recap - summarize the current conversation now/agents - view and switch between all active agent sessions/side - start a side conversation in an ephemeral fork/copy - copy the last response, code block, or quotediff --git a/codex-rs/tui/src/chatwidget.rs b/codex-rs/tui/src/chatwidget.rsindex 6f0367cd46..4fee2ad703 100644--- a/codex-rs/tui/src/chatwidget.rs+++ b/codex-rs/tui/src/chatwidget.rs@@ -401,6 +401,7 @@ use self::rate_limits::RateLimitWarningState;use self::rate_limits::app_server_rate_limit_error_kind;pub(crate) use self::rate_limits::fallback_limit_label;use self::rate_limits::is_app_server_cyber_policy_error;+mod recap;mod reset_credits;pub(crate) use self::rate_limits::limit_label_for_window;mod reasoning_shortcuts;diff --git a/codex-rs/tui/src/chatwidget/input_submission.rs b/codex-rs/tui/src/chatwidget/input_submission.rsindex c0b78cac92..1fc8b6ba04 100644--- a/codex-rs/tui/src/chatwidget/input_submission.rs+++ b/codex-rs/tui/src/chatwidget/input_submission.rs@@ -377,6 +377,11 @@ impl ChatWidget {// App-event submissions are handled serially, and turn/start can wait on remote work.// Queue the optimistic prompt first so the user's input is visible while that happens.// Direct submissions do not share that queue, so keep their existing failure behavior.+ if render_in_history {+ // Do not let a transient manual-recap progress cell become permanent terminal+ // scrollback when the new user prompt flushes the active history cell.+ self.clear_recap_loading();+ }let render_before_submit =render_in_history && matches!(&self.codex_op_target, CodexOpTarget::AppEvent);if render_before_submit {diff --git a/codex-rs/tui/src/chatwidget/recap.rs b/codex-rs/tui/src/chatwidget/recap.rsnew file mode 100644index 0000000000..ac003930a8--- /dev/null+++ b/codex-rs/tui/src/chatwidget/recap.rs@@ -0,0 +1,28 @@+//! Manual recap progress presentation for `ChatWidget`.++use super::*;++impl ChatWidget {+ pub(crate) fn show_recap_loading(&mut self) {+ self.flush_answer_stream_with_separator();+ self.flush_active_cell();+ self.transcript.active_cell = Some(Box::new(history_cell::ThreadRecapLoadingCell::new(+ self.config.animations,+ )));+ self.bump_active_cell_revision();+ self.request_redraw();+ }++ pub(crate) fn clear_recap_loading(&mut self) {+ let Some(active) = self.transcript.active_cell.as_ref() else {+ return;+ };+ if !active.as_any().is::<history_cell::ThreadRecapLoadingCell>() {+ return;+ }++ self.transcript.active_cell = None;+ self.bump_active_cell_revision();+ self.request_redraw();+ }+}diff --git a/codex-rs/tui/src/chatwidget/slash_dispatch.rs b/codex-rs/tui/src/chatwidget/slash_dispatch.rsindex fb1b75fd8f..69229ba4dd 100644--- a/codex-rs/tui/src/chatwidget/slash_dispatch.rs+++ b/codex-rs/tui/src/chatwidget/slash_dispatch.rs@@ -273,6 +273,16 @@ impl ChatWidget {self.input_queue.user_turn_pending_start = true;self.app_event_tx.compact();}+ SlashCommand::Recap => {+ let Some(thread_id) = self.thread_id else {+ self.add_error_message(+ "Session is still starting; try /recap again in a moment.".to_string(),+ );+ return;+ };+ self.app_event_tx+ .send(AppEvent::GenerateRecap { thread_id });+ }SlashCommand::Review => {self.open_review_popup();if self.mcp_startup_status.is_some() {@@ -1139,6 +1149,7 @@ impl ChatWidget {| SlashCommand::Diff| SlashCommand::App| SlashCommand::Rename+ | SlashCommand::Recap| SlashCommand::TestApproval => QueueDrain::Continue,SlashCommand::Cd => match self.thread_id {Some(thread_id) if self.can_change_working_directory(thread_id) => QueueDrain::Stop,diff --git a/codex-rs/tui/src/chatwidget/tests/composer_submission.rs b/codex-rs/tui/src/chatwidget/tests/composer_submission.rsindex 1acc1e5a27..394fe45c33 100644--- a/codex-rs/tui/src/chatwidget/tests/composer_submission.rs+++ b/codex-rs/tui/src/chatwidget/tests/composer_submission.rs@@ -1,5 +1,6 @@use super::*;use crate::app_event::ConnectorsSnapshot;+use crate::history_cell::ThreadRecapLoadingCell;use codex_protocol::models::ManagedFileSystemPermissions;use codex_protocol::permissions::FileSystemAccessMode;use codex_protocol::permissions::FileSystemPath;@@ -32,6 +33,25 @@ fn assert_hidden_shell_payload_is_literal(op: Result<Op, TryRecvError>, payload:}}+#[tokio::test]+async fn user_submission_does_not_commit_recap_loading_to_history() {+ let (mut chat, mut rx, _op_rx) = make_chatwidget_manual(/*model_override*/ None).await;+ chat.thread_id = Some(ThreadId::new());+ chat.show_recap_loading();+ while rx.try_recv().is_ok() {}++ chat.submit_user_message(UserMessage::from("Continue with the task"));++ let mut saw_user_message = false;+ while let Ok(event) = rx.try_recv() {+ if let AppEvent::InsertHistoryCell(cell) = event {+ assert!(!cell.as_any().is::<ThreadRecapLoadingCell>());+ saw_user_message |= cell.as_any().is::<UserHistoryCell>();+ }+ }+ assert!(saw_user_message);+}+#[tokio::test]async fn hidden_shell_paste_submits_literal_prompt() {let (mut chat, _rx, mut op_rx) = make_chatwidget_manual(/*model_override*/ None).await;diff --git a/codex-rs/tui/src/chatwidget/tests/slash_commands.rs b/codex-rs/tui/src/chatwidget/tests/slash_commands.rsindex 2433ee6e05..2b681d40e2 100644--- a/codex-rs/tui/src/chatwidget/tests/slash_commands.rs+++ b/codex-rs/tui/src/chatwidget/tests/slash_commands.rs@@ -177,6 +177,22 @@ async fn slash_compact_eagerly_queues_follow_up_before_turn_start() {assert_matches!(op_rx.try_recv(), Err(TryRecvError::Empty));}+#[tokio::test]+async fn slash_recap_requests_generation_for_current_thread() {+ let (mut chat, mut rx, _op_rx) = make_chatwidget_manual(/*model_override*/ None).await;+ let thread_id = ThreadId::new();+ chat.thread_id = Some(thread_id);++ chat.dispatch_command(SlashCommand::Recap);++ assert_matches!(+ rx.try_recv(),+ Ok(AppEvent::GenerateRecap {+ thread_id: requested_thread_id,+ }) if requested_thread_id == thread_id+ );+}+#[tokio::test]async fn queued_slash_compact_dispatches_after_active_turn() {let (mut chat, mut rx, _op_rx) = make_chatwidget_manual(/*model_override*/ None).await;diff --git a/codex-rs/tui/src/history_cell/notices.rs b/codex-rs/tui/src/history_cell/notices.rsindex ca360c9b5f..3862797ab2 100644--- a/codex-rs/tui/src/history_cell/notices.rs+++ b/codex-rs/tui/src/history_cell/notices.rs@@ -230,6 +230,52 @@ pub(crate) fn new_error_event(message: String) -> PlainHistoryCell {PlainHistoryCell { lines }}+#[derive(Debug)]+pub(crate) struct ThreadRecapLoadingCell {+ start_time: Instant,+ animations_enabled: bool,+}++impl ThreadRecapLoadingCell {+ pub(crate) fn new(animations_enabled: bool) -> Self {+ Self {+ start_time: Instant::now(),+ animations_enabled,+ }+ }+}++impl HistoryCell for ThreadRecapLoadingCell {+ fn display_lines(&self, _width: u16) -> Vec<Line<'static>> {+ vec![+ vec![+ activity_indicator(+ Some(self.start_time),+ MotionMode::from_animations_enabled(self.animations_enabled),+ ReducedMotionIndicator::StaticBullet,+ )+ .unwrap_or_else(|| "•".dim()),+ " ".into(),+ "Generating conversation recap".bold(),+ "…".dim(),+ ]+ .into(),+ ]+ }++ fn raw_lines(&self) -> Vec<Line<'static>> {+ vec![Line::from("Generating conversation recap...")]+ }++ fn transcript_animation_tick(&self) -> Option<u64> {+ if !self.animations_enabled {+ return None;+ }++ Some((self.start_time.elapsed().as_millis() / 50) as u64)+ }+}+#[cfg_attr(not(test), allow(dead_code))]#[derive(Debug)]pub(crate) struct ThreadRecapHistoryCell {diff --git a/codex-rs/tui/src/history_cell/tests.rs b/codex-rs/tui/src/history_cell/tests.rsindex 5333aadc31..59e05fbd65 100644--- a/codex-rs/tui/src/history_cell/tests.rs+++ b/codex-rs/tui/src/history_cell/tests.rs@@ -1420,6 +1420,14 @@ fn mcp_inventory_loading_without_animations_is_stable() {assert_eq!(first, vec!["• Loading MCP inventory…".to_string()]);}+#[test]+fn thread_recap_loading_without_animations_snapshot() {+ let cell = ThreadRecapLoadingCell::new(/*animations_enabled*/ false);+ let rendered = render_lines(&cell.display_lines(/*width*/ 80)).join("\n");++ insta::assert_snapshot!(rendered, @"• Generating conversation recap…");+}+#[test]fn completed_mcp_tool_call_success_snapshot() {let invocation = McpInvocation {diff --git a/codex-rs/tui/src/slash_command.rs b/codex-rs/tui/src/slash_command.rsindex 3c12b3e284..aab133ffb7 100644--- a/codex-rs/tui/src/slash_command.rs+++ b/codex-rs/tui/src/slash_command.rs@@ -38,6 +38,7 @@ pub enum SlashCommand {App,Init,Compact,+ Recap,Plan,Goal,Agents,@@ -90,6 +91,7 @@ impl SlashCommand {SlashCommand::New => "start a new chat during a conversation",SlashCommand::Init => "create an AGENTS.md file with instructions for Codex",SlashCommand::Compact => "summarize conversation to prevent hitting the context limit",+ SlashCommand::Recap => "summarize the current conversation now",SlashCommand::Review => "review my current changes and find issues",SlashCommand::Rename => "rename the current thread",SlashCommand::Resume => "resume a saved chat",@@ -210,6 +212,7 @@ impl SlashCommand {| SlashCommand::Fork| SlashCommand::Init| SlashCommand::Compact+ | SlashCommand::Recap| SlashCommand::Export| SlashCommand::Keymap| SlashCommand::Vim