Skip to content

armgit / codex

Public Imported from GitHub
0

Lightweight coding agent that runs in your terminal

Rust

Show streaming reasoning summaries in the TUI status row (#43921)

Felipe Coury9ec33e192609
diff --git a/codex-rs/core/src/compact.rs b/codex-rs/core/src/compact.rs
index 7c5b114283..189dd5df40 100644
--- a/codex-rs/core/src/compact.rs
+++ b/codex-rs/core/src/compact.rs
@@ -381,8 +381,8 @@ async fn run_compact_task_inner_impl(
}
let reference_context_item = match initial_context_injection {
InitialContextInjection::DoNotInject => None,
- InitialContextInjection::BeforeLastUserMessage { .. } => {
- Some(turn_context.to_turn_context_item())
+ InitialContextInjection::BeforeLastUserMessage { step_context, .. } => {
+ Some(step_context.to_turn_context_item())
}
};
sess.replace_compacted_history(
diff --git a/codex-rs/core/src/compact_remote.rs b/codex-rs/core/src/compact_remote.rs
index d1eb2124eb..a6dfb177b6 100644
--- a/codex-rs/core/src/compact_remote.rs
+++ b/codex-rs/core/src/compact_remote.rs
@@ -273,8 +273,8 @@ async fn run_remote_compact_task_inner_impl(
let reference_context_item = match initial_context_injection {
InitialContextInjection::DoNotInject => None,
- InitialContextInjection::BeforeLastUserMessage { .. } => {
- Some(compaction_turn_context.to_turn_context_item())
+ InitialContextInjection::BeforeLastUserMessage { step_context, .. } => {
+ Some(step_context.to_turn_context_item())
}
};
// Install is the semantic boundary where the compact endpoint's output becomes live
diff --git a/codex-rs/core/src/compact_remote_v2.rs b/codex-rs/core/src/compact_remote_v2.rs
index f68b8d47cc..e5b9fdd44b 100644
--- a/codex-rs/core/src/compact_remote_v2.rs
+++ b/codex-rs/core/src/compact_remote_v2.rs
@@ -329,8 +329,8 @@ async fn run_remote_compact_task_inner_impl(
let reference_context_item = match initial_context_injection {
InitialContextInjection::DoNotInject => None,
- InitialContextInjection::BeforeLastUserMessage { .. } => {
- Some(compaction_turn_context.to_turn_context_item())
+ InitialContextInjection::BeforeLastUserMessage { step_context, .. } => {
+ Some(step_context.to_turn_context_item())
}
};
if let Some(trace_input_history) = trace_input_history.as_deref() {
diff --git a/codex-rs/core/src/session/mod.rs b/codex-rs/core/src/session/mod.rs
index f69af3f038..0aae16f6a3 100644
--- a/codex-rs/core/src/session/mod.rs
+++ b/codex-rs/core/src/session/mod.rs
@@ -4297,7 +4297,7 @@ impl Session {
.map(ResponseItemEnvelope::new)
.chain(retained_client_developer_messages)
.collect();
- let turn_context_item = turn_context.to_turn_context_item();
+ let turn_context_item = step_context.to_turn_context_item();
self.replace_compacted_history(
context_items,
Some(turn_context_item),
@@ -4343,7 +4343,7 @@ impl Session {
let state = self.state.lock().await;
state.reference_context_item()
};
- let turn_context_item = turn_context.to_turn_context_item();
+ let turn_context_item = step_context.to_turn_context_item();
let turn_context_changed = reference_context_item.as_ref() != Some(&turn_context_item);
let should_inject_full_context = reference_context_item.is_none();
let world_state = Arc::new(self.build_world_state_for_step(step_context).await?);
diff --git a/codex-rs/core/src/session/step_activation_tests.rs b/codex-rs/core/src/session/step_activation_tests.rs
index ef63fb535a..70d74bb106 100644
--- a/codex-rs/core/src/session/step_activation_tests.rs
+++ b/codex-rs/core/src/session/step_activation_tests.rs
@@ -433,6 +433,27 @@ async fn submitted_sparse_updates_preserve_captured_steps_and_ordering() {
]
);
assert!(Arc::ptr_eq(&before.turn, &after.turn));
+ assert_eq!(
+ turn.to_turn_context_item().summary,
+ ReasoningSummary::Concise
+ );
+ // Even after the live update, an already-captured request retains its own
+ // summary setting in the durable context.
+ for step in [&before, &during, &after] {
+ let world_state = session
+ .record_context_updates_and_set_reference_context_item(step)
+ .await
+ .expect("record captured settings");
+ assert_eq!(
+ session.reference_context_item().await.unwrap().summary,
+ step.settings.reasoning_summary,
+ );
+ session.start_new_context_window(step, world_state).await;
+ assert_eq!(
+ session.reference_context_item().await.unwrap().summary,
+ step.settings.reasoning_summary,
+ );
+ }
assert_eq!(after.settings.model_info.as_ref(), &expected_destination);
let initial_budget = turn
.config
diff --git a/codex-rs/core/src/session/step_context.rs b/codex-rs/core/src/session/step_context.rs
index ff91aad3c9..31085d1089 100644
--- a/codex-rs/core/src/session/step_context.rs
+++ b/codex-rs/core/src/session/step_context.rs
@@ -1,3 +1,5 @@
+//! Request-scoped settings and capabilities, including the durable context snapshot.
+
use std::sync::Arc;
use crate::agents_md::LoadedAgentsMd;
@@ -10,6 +12,7 @@ use codex_exec_server::ExecutorCapabilityDiscoverySnapshot;
use codex_exec_server::ResolvedSelectedCapabilityRoot;
use codex_mcp::McpBinding;
use codex_otel::SessionTelemetry;
+use codex_protocol::protocol::TurnContextItem;
/// Request-scoped state that may change between model sampling requests.
pub(crate) struct StepContext {
@@ -32,3 +35,12 @@ pub(crate) struct StepContext {
/// The canonical AGENTS.md value observed with this environment snapshot.
pub(crate) loaded_agents_md: Option<Arc<LoadedAgentsMd>>,
}
+
+impl StepContext {
+ /// Persist the summary captured for this request, even after a live settings update.
+ pub(crate) fn to_turn_context_item(&self) -> TurnContextItem {
+ let mut item = self.turn.to_turn_context_item();
+ item.summary = self.settings.reasoning_summary;
+ item
+ }
+}
diff --git a/codex-rs/core/src/session/turn_context.rs b/codex-rs/core/src/session/turn_context.rs
index 7e28ac8b51..84a2815c61 100644
--- a/codex-rs/core/src/session/turn_context.rs
+++ b/codex-rs/core/src/session/turn_context.rs
@@ -639,7 +639,7 @@ impl TurnContext {
realtime_active: Some(self.realtime_active),
cyber_access_program: self.cyber_access_program,
effort: self.reasoning_effort().cloned(),
- summary: ReasoningSummaryConfig::Auto,
+ summary: self.reasoning_summary(),
}
}
diff --git a/codex-rs/core/tests/suite/step_settings.rs b/codex-rs/core/tests/suite/step_settings.rs
index c27c566434..b487f88f05 100644
--- a/codex-rs/core/tests/suite/step_settings.rs
+++ b/codex-rs/core/tests/suite/step_settings.rs
@@ -1481,3 +1481,6 @@ async fn request_preference_activation_keeps_admitted_model_metadata() -> Result
Ok(())
}
+
+#[path = "step_settings_compaction.rs"]
+mod compaction;
diff --git a/codex-rs/core/tests/suite/step_settings_compaction.rs b/codex-rs/core/tests/suite/step_settings_compaction.rs
new file mode 100644
index 0000000000..473af1d235
--- /dev/null
+++ b/codex-rs/core/tests/suite/step_settings_compaction.rs
@@ -0,0 +1,129 @@
+//! Compaction checkpoints retain the summary captured after a mid-turn settings update.
+
+use super::*;
+use codex_history::RolloutItem;
+use core_test_support::responses;
+use pretty_assertions::assert_eq;
+use test_case::test_case;
+
+#[derive(Clone, Copy)]
+enum CompactionMode {
+ Local,
+ Remote,
+ RemoteV2,
+}
+
+#[test_case(CompactionMode::Local; "local")]
+#[test_case(CompactionMode::Remote; "remote")]
+#[test_case(CompactionMode::RemoteV2; "remote v2")]
+#[tokio::test]
+async fn compaction_preserves_updated_summary(mode: CompactionMode) -> Result<()> {
+ skip_if_no_network!(Ok(()));
+ let server = start_mock_server().await;
+ let mut bodies = vec![
+ paused_response("pause", "pause-call"),
+ sse(vec![
+ ev_function_call(
+ "plan",
+ "update_plan",
+ &json!({"plan": [{"step": "Finish the answer", "status": "in_progress"}]})
+ .to_string(),
+ ),
+ responses::ev_completed_with_tokens("plan-response", /*total_tokens*/ 330_000),
+ ]),
+ ];
+ let compact = match mode {
+ CompactionMode::Local => {
+ bodies.push(sse(vec![
+ responses::ev_assistant_message("summary", "Compacted history"),
+ ev_completed("compact"),
+ ]));
+ None
+ }
+ CompactionMode::Remote => Some(
+ responses::mount_compact_user_history_with_summary_once(&server, "encrypted-summary")
+ .await,
+ ),
+ CompactionMode::RemoteV2 => {
+ bodies.push(sse(vec![json!({"type": "response.output_item.done", "item": {"type": "compaction", "encrypted_content": "encrypted-summary"}}), ev_completed("compact")]));
+ None
+ }
+ };
+ bodies.push(sse_completed("done"));
+ let responses = mount_sse_sequence(&server, bodies).await;
+ let test = step_settings_test()
+ .with_auth(CodexAuth::create_dummy_chatgpt_auth_for_testing())
+ .with_config(move |config| {
+ config.model_auto_compact_token_limit = Some(200_000);
+ config
+ .features
+ .disable(Feature::TokenBudget)
+ .expect("disable token budget");
+ config.model_provider.name = match mode {
+ CompactionMode::Local => "Local compaction test",
+ CompactionMode::Remote | CompactionMode::RemoteV2 => "OpenAI",
+ }
+ .to_string();
+ if matches!(mode, CompactionMode::RemoteV2) {
+ config
+ .features
+ .enable(Feature::RemoteCompactionV2)
+ .expect("enable v2");
+ } else {
+ config
+ .features
+ .disable(Feature::RemoteCompactionV2)
+ .expect("disable v2");
+ }
+ })
+ .build_with_auto_env(&server)
+ .await?;
+ let pause = start_paused_turn(&test.codex).await?;
+ assert_eq!(
+ submit_turn_settings(
+ &test.codex,
+ &pause.turn_id,
+ TurnSettingsUpdate {
+ summary: Some(ReasoningSummary::Detailed),
+ ..Default::default()
+ }
+ )
+ .await?,
+ TurnSettingsUpdateOutcome::Applied
+ );
+ answer_paused_turn(&test.codex, &pause.turn_id).await?;
+ wait_for_event(&test.codex, |event| {
+ matches!(event, EventMsg::TurnComplete(_))
+ })
+ .await;
+ test.codex.shutdown_and_wait().await?;
+
+ let requests = responses.requests();
+ assert_eq!(
+ [
+ requests[0].body_json()["reasoning"]["summary"].clone(),
+ requests[1].body_json()["reasoning"]["summary"].clone()
+ ],
+ [json!("concise"), json!("detailed")]
+ );
+ if let Some(compact) = compact {
+ compact.single_request();
+ }
+ let rollout =
+ std::fs::read_to_string(test.session_configured.rollout_path.expect("rollout path"))?;
+ let items = rollout
+ .lines()
+ .map(codex_rollout::parse_rollout_line)
+ .collect::<std::result::Result<Vec<_>, _>>()?;
+ let checkpoint = items
+ .iter()
+ .skip_while(|line| !matches!(line.item, RolloutItem::Compacted(_)))
+ .skip(/*n*/ 1)
+ .take_while(|line| !matches!(line.item, RolloutItem::EventMsg(_)))
+ .find_map(|line| match &line.item {
+ RolloutItem::TurnContext(context) => Some(context.summary),
+ _ => None,
+ });
+ assert_eq!(checkpoint, Some(ReasoningSummary::Detailed));
+ Ok(())
+}
diff --git a/codex-rs/tui/src/app.rs b/codex-rs/tui/src/app.rs
index 37a74f3bce..9bc4836332 100644
--- a/codex-rs/tui/src/app.rs
+++ b/codex-rs/tui/src/app.rs
@@ -236,6 +236,7 @@ mod platform_actions;
mod plugin_mentions;
mod rate_limit_refresh;
mod realtime_delivery;
+mod reasoning_replay;
mod recap;
mod reconnect;
mod replay_filter;
diff --git a/codex-rs/tui/src/app/reasoning_replay.rs b/codex-rs/tui/src/app/reasoning_replay.rs
new file mode 100644
index 0000000000..84ae583873
--- /dev/null
+++ b/codex-rs/tui/src/app/reasoning_replay.rs
@@ -0,0 +1,67 @@
+//! Restores the active reasoning stream without treating its snapshot as a completed item.
+//!
+//! Buffered turn events must replay before the active item is restored. Its first retained
+//! event, or the end of replay when all its events were evicted, establishes that boundary.
+
+use super::ThreadBufferedEvent;
+use super::ThreadEventSnapshot;
+use crate::chatwidget::ChatWidget;
+use codex_app_server_protocol::ItemStartedNotification;
+use codex_app_server_protocol::ServerNotification;
+use codex_app_server_protocol::ThreadItem;
+use codex_app_server_protocol::TurnStatus;
+
+pub(super) struct ReasoningReplay {
+ started: Option<ItemStartedNotification>,
+ parts: Option<(Vec<String>, Vec<String>)>,
+}
+
+impl ReasoningReplay {
+ pub(super) fn new(snapshot: &mut ThreadEventSnapshot) -> Self {
+ let started = snapshot.active_reasoning_item.take();
+ let parts = started.as_ref().and_then(|started| {
+ let turn = snapshot
+ .turns
+ .iter_mut()
+ .find(|turn| turn.id == started.turn_id && turn.status == TurnStatus::InProgress)?;
+ let index = turn.items.iter().position(
+ |item| matches!(item, ThreadItem::Reasoning { id, .. } if id == started.item.id()),
+ )?;
+ match turn.items.remove(index) {
+ ThreadItem::Reasoning {
+ summary, content, ..
+ } => Some((summary, content)),
+ _ => unreachable!("matched a reasoning item"),
+ }
+ });
+ Self { started, parts }
+ }
+
+ pub(super) fn before_event(&mut self, event: &ThreadBufferedEvent, chat: &mut ChatWidget) {
+ if self.started.as_ref().is_some_and(|started| {
+ matches!(event, ThreadBufferedEvent::Notification(notification) if match notification.as_ref() {
+ ServerNotification::ItemStarted(item) => {
+ item.turn_id == started.turn_id && item.item.id() == started.item.id()
+ }
+ ServerNotification::ReasoningSummaryTextDelta(delta) => {
+ delta.turn_id == started.turn_id && delta.item_id == started.item.id()
+ }
+ ServerNotification::ReasoningTextDelta(delta) => {
+ delta.turn_id == started.turn_id && delta.item_id == started.item.id()
+ }
+ ServerNotification::ReasoningSummaryPartAdded(part) => {
+ part.turn_id == started.turn_id && part.item_id == started.item.id()
+ }
+ _ => false,
+ })
+ }) {
+ self.restore(chat);
+ }
+ }
+
+ pub(super) fn restore(&mut self, chat: &mut ChatWidget) {
+ if let Some(started) = self.started.take() {
+ chat.restore_active_reasoning_item(started, self.parts.take());
+ }
+ }
+}
diff --git a/codex-rs/tui/src/app/tests.rs b/codex-rs/tui/src/app/tests.rs
index 5a5b59fdb8..9c337cc148 100644
--- a/codex-rs/tui/src/app/tests.rs
+++ b/codex-rs/tui/src/app/tests.rs
@@ -48,6 +48,8 @@ mod realtime_handoff_e2e;
mod realtime_requests;
#[path = "tests/realtime_start.rs"]
mod realtime_start;
+#[path = "tests/reasoning_resume_tests.rs"]
+mod reasoning_resume_tests;
#[path = "tests/recap_generation_tests.rs"]
mod recap_generation;
mod safety_buffering;
@@ -1348,6 +1350,7 @@ async fn replayed_turn_complete_submits_restored_queued_follow_up() {
events: vec![ThreadBufferedEvent::Notification(Box::new(
turn_completed_notification(thread_id, "turn-1", TurnStatus::Completed),
))],
+ active_reasoning_item: None,
input_state: Some(input_state),
},
/*resume_restored_queue*/ true,
@@ -1402,6 +1405,7 @@ async fn replay_only_thread_keeps_restored_queue_visible() {
events: vec![ThreadBufferedEvent::Notification(Box::new(
turn_completed_notification(thread_id, "turn-1", TurnStatus::Completed),
))],
+ active_reasoning_item: None,
input_state: Some(input_state),
},
/*resume_restored_queue*/ false,
@@ -1452,6 +1456,7 @@ async fn replay_thread_snapshot_keeps_queue_when_running_state_only_comes_from_s
session: None,
turns: Vec::new(),
events: vec![],
+ active_reasoning_item: None,
input_state: Some(input_state),
},
/*resume_restored_queue*/ true,
@@ -1502,6 +1507,7 @@ async fn replay_thread_snapshot_in_progress_turn_restores_running_queue_state()
session: None,
turns: vec![test_turn("turn-1", TurnStatus::InProgress, Vec::new())],
events: Vec::new(),
+ active_reasoning_item: None,
input_state: Some(input_state),
},
/*resume_restored_queue*/ true,
@@ -1532,6 +1538,7 @@ async fn replay_thread_snapshot_in_progress_turn_restores_running_state_without_
session: None,
turns: vec![test_turn("turn-1", TurnStatus::InProgress, Vec::new())],
events: Vec::new(),
+ active_reasoning_item: None,
input_state: None,
},
/*resume_restored_queue*/ false,
@@ -1584,6 +1591,7 @@ async fn replay_thread_snapshot_does_not_submit_queue_before_replay_catches_up()
thread_id, "turn-1",
))),
],
+ active_reasoning_item: None,
input_state: Some(input_state),
},
/*resume_restored_queue*/ true,
@@ -1717,6 +1725,7 @@ async fn replay_thread_snapshot_restores_collaboration_mode_for_draft_submit() {
session: None,
turns: Vec::new(),
events: vec![],
+ active_reasoning_item: None,
input_state: Some(input_state),
},
/*resume_restored_queue*/ true,
@@ -1798,6 +1807,7 @@ async fn replay_thread_snapshot_restores_collaboration_mode_without_input() {
session: None,
turns: Vec::new(),
events: vec![],
+ active_reasoning_item: None,
input_state: Some(input_state),
},
/*resume_restored_queue*/ true,
@@ -1851,6 +1861,7 @@ async fn replayed_interrupted_turn_restores_queued_input_to_composer() {
events: vec![ThreadBufferedEvent::Notification(Box::new(
turn_completed_notification(thread_id, "turn-1", TurnStatus::Interrupted),
))],
+ active_reasoning_item: None,
input_state: Some(input_state),
},
/*resume_restored_queue*/ true,
@@ -3748,6 +3759,7 @@ async fn replay_snapshot_with_pending_request_suppresses_replay_notices() {
/*approval_id*/ None,
))),
],
+ active_reasoning_item: None,
input_state: None,
},
/*resume_restored_queue*/ false,
@@ -4142,6 +4154,7 @@ async fn replayed_file_change_approval_recovers_snapshot_changes() {
},
},
))],
+ active_reasoning_item: None,
input_state: None,
},
/*resume_restored_queue*/ false,
@@ -5079,6 +5092,7 @@ async fn side_thread_snapshot_does_not_refresh_from_fork_history() {
}),
turns: Vec::new(),
events: Vec::new(),
+ active_reasoning_item: None,
input_state: None,
};
@@ -5109,6 +5123,7 @@ async fn side_thread_snapshot_skips_session_header_preamble() {
}),
turns: Vec::new(),
events: Vec::new(),
+ active_reasoning_item: None,
input_state: None,
};
@@ -5284,6 +5299,7 @@ async fn active_side_thread_renders_live_mcp_startup_notifications() {
)),
turns: Vec::new(),
events: Vec::new(),
+ active_reasoning_item: None,
input_state: None,
},
/*resume_restored_queue*/ false,
@@ -8133,6 +8149,7 @@ async fn replay_thread_snapshot_replays_turn_history_in_order() {
},
],
events: Vec::new(),
+ active_reasoning_item: None,
input_state: None,
},
/*resume_restored_queue*/ false,
@@ -8222,6 +8239,7 @@ async fn replace_chat_widget_reseeds_collab_agent_metadata_for_replay() {
},
),
))],
+ active_reasoning_item: None,
input_state: None,
},
/*resume_restored_queue*/ false,
@@ -8278,6 +8296,7 @@ async fn refreshed_snapshot_session_persists_resumed_turns() {
session: Some(initial_session),
turns: Vec::new(),
events: Vec::new(),
+ active_reasoning_item: None,
input_state: None,
};
diff --git a/codex-rs/tui/src/app/tests/advanced_reasoning_tests.rs b/codex-rs/tui/src/app/tests/advanced_reasoning_tests.rs
index 765278421f..1f60e913f8 100644
--- a/codex-rs/tui/src/app/tests/advanced_reasoning_tests.rs
+++ b/codex-rs/tui/src/app/tests/advanced_reasoning_tests.rs
@@ -69,6 +69,7 @@ async fn switching_from_ultra_thread_restores_configured_plan_effort() {
session: Some(ultra_session),
turns: Vec::new(),
events: Vec::new(),
+ active_reasoning_item: None,
input_state: None,
},
/*resume_restored_queue*/ false,
@@ -79,6 +80,7 @@ async fn switching_from_ultra_thread_restores_configured_plan_effort() {
session: Some(normal_session),
turns: Vec::new(),
events: Vec::new(),
+ active_reasoning_item: None,
input_state: None,
},
/*resume_restored_queue*/ false,
diff --git a/codex-rs/tui/src/app/tests/buffered_replay.rs b/codex-rs/tui/src/app/tests/buffered_replay.rs
index 8ed490e569..ee2bd6c48f 100644
--- a/codex-rs/tui/src/app/tests/buffered_replay.rs
+++ b/codex-rs/tui/src/app/tests/buffered_replay.rs
@@ -2,7 +2,10 @@
use super::*;
use crate::chatwidget::tests::helpers::normalize_snapshot_paths;
+use crate::chatwidget::tests::helpers::render_bottom_popup;
use codex_app_server_protocol::ItemCompletedNotification;
+use codex_app_server_protocol::ItemStartedNotification;
+use codex_app_server_protocol::ReasoningSummaryTextDeltaNotification;
use pretty_assertions::assert_eq;
fn delta(thread: &str, turn: &str, item: &str) -> ServerNotification {
@@ -30,6 +33,153 @@ fn completed(thread: &str) -> ServerNotification {
})
}
+#[tokio::test]
+async fn refreshed_active_reasoning_accepts_later_deltas_and_complete_summary() {
+ for (refresh, refreshed_item_is_partial, capacity, voice_handoff) in [
+ (true, false, 1, false),
+ (true, true, 1, false),
+ (false, false, 8, false),
+ (false, false, 1, false),
+ (true, false, 1, true),
+ ] {
+ let (mut app, mut events, _ops) = make_test_app_with_channels().await;
+ let thread_id = ThreadId::new();
+ let session = test_thread_session(thread_id, app.config.cwd.to_path_buf());
+ let mut turn = test_turn("reasoning-turn", TurnStatus::InProgress, Vec::new());
+ let channel =
+ ThreadEventChannel::new_with_session(capacity, session.clone(), vec![turn.clone()]);
+ {
+ let mut store = channel.store.lock().await;
+ store.push_notification(ServerNotification::ItemStarted(ItemStartedNotification {
+ thread_id: thread_id.to_string(),
+ turn_id: turn.id.clone(),
+ item: ThreadItem::Reasoning {
+ id: "reasoning".into(),
+ summary: Vec::new(),
+ content: Vec::new(),
+ },
+ started_at_ms: 0,
+ }));
+ store.push_notification(ServerNotification::ReasoningSummaryTextDelta(
+ ReasoningSummaryTextDeltaNotification {
+ thread_id: thread_id.to_string(),
+ turn_id: turn.id.clone(),
+ item_id: "reasoning".into(),
+ delta: "**First heading**\nOriginal analysis paragraph".into(),
+ summary_index: 0,
+ },
+ ));
+ assert_eq!(store.buffer.len(), capacity.min(/*other*/ 2));
+ if voice_handoff {
+ store.push_notification(ServerNotification::ItemStarted(ItemStartedNotification {
+ thread_id: thread_id.to_string(),
+ turn_id: turn.id.clone(),
+ item: ThreadItem::UserMessage {
+ id: "voice-handoff".into(),
+ client_id: None,
+ content: vec![AppServerUserInput::Text {
+ text: "<realtime_delegation><input>spoken follow-up</input></realtime_delegation>".into(),
+ text_elements: Vec::new(),
+ }],
+ },
+ started_at_ms: 0,
+ }));
+ }
+ }
+ let mut snapshot = channel.store.lock().await.snapshot();
+ app.thread_event_channels.insert(thread_id, channel);
+ if refreshed_item_is_partial {
+ turn.items.push(ThreadItem::Reasoning {
+ id: "reasoning".into(),
+ summary: vec!["**First heading**\nOriginal analysis paragraph".into()],
+ content: Vec::new(),
+ });
+ }
+ if refresh {
+ app.apply_refreshed_snapshot_thread(
+ thread_id,
+ AppServerStartedThread {
+ session,
+ turns: vec![turn],
+ blocks_direct_input: false,
+ task_tools_available: false,
+ },
+ &mut snapshot,
+ )
+ .await;
+ assert!(snapshot.events.is_empty());
+ }
+ assert!(snapshot.active_reasoning_item.is_some());
+ app.replay_thread_snapshot(snapshot, /*resume_restored_queue*/ false);
+ app.chat_widget.handle_server_notification(
+ ServerNotification::ReasoningSummaryTextDelta(ReasoningSummaryTextDeltaNotification {
+ thread_id: thread_id.to_string(),
+ turn_id: "reasoning-turn".into(),
+ item_id: "reasoning".into(),
+ delta: "\n**Running checks**\nFinal paragraph".into(),
+ summary_index: 0,
+ }),
+ /*replay_kind*/ None,
+ );
+ assert!(render_bottom_popup(&app.chat_widget, /*width*/ 80).contains("Final paragraph"));
+ let completed = ServerNotification::ItemCompleted(ItemCompletedNotification {
+ thread_id: thread_id.to_string(),
+ turn_id: "reasoning-turn".into(),
+ item: ThreadItem::Reasoning {
+ id: "reasoning".into(),
+ summary: vec![
+ "**First heading**\nOriginal analysis paragraph\n**Running checks**\nFinal paragraph"
+ .into(),
+ ],
+ content: Vec::new(),
+ },
+ completed_at_ms: 0,
+ });
+ let store = &app.thread_event_channels[&thread_id].store;
+ store.lock().await.push_notification_ref(&completed);
+ assert!(
+ store
+ .lock()
+ .await
+ .snapshot()
+ .active_reasoning_item
+ .is_none()
+ );
+ app.chat_widget
+ .handle_server_notification(completed, /*replay_kind*/ None);
+ app.chat_widget.handle_server_notification(
+ ServerNotification::ReasoningSummaryTextDelta(ReasoningSummaryTextDeltaNotification {
+ thread_id: thread_id.to_string(),
+ turn_id: "reasoning-turn".into(),
+ item_id: "reasoning".into(),
+ delta: "\n**Stale heading**".into(),
+ summary_index: 0,
+ }),
+ /*replay_kind*/ None,
+ );
+ assert!(!render_bottom_popup(&app.chat_widget, /*width*/ 80).contains("Stale heading"));
+ let transcript = std::iter::from_fn(|| events.try_recv().ok())
+ .filter_map(|event| match event {
+ AppEvent::InsertHistoryCell(cell)
+ if cell
+ .as_any()
+ .is::<crate::history_cell::ReasoningSummaryCell>() =>
+ {
+ Some(lines_to_single_string(&cell.transcript_lines(/*width*/ 80)))
+ }
+ _ => None,
+ })
+ .collect::<String>();
+ insta::allow_duplicates! {
+ insta::assert_snapshot!(transcript, @"
+ • Original analysis paragraph
+ Running checks
+ Final paragraph
+ ");
+ }
+ }
+}
+
#[test]
fn buffered_replay_keeps_unfinished_and_unrelated_deltas_in_order() {
let completion = completed("thread");
diff --git a/codex-rs/tui/src/app/tests/mcp_startup.rs b/codex-rs/tui/src/app/tests/mcp_startup.rs
index ffc6db5cc4..3c355bb8e2 100644
--- a/codex-rs/tui/src/app/tests/mcp_startup.rs
+++ b/codex-rs/tui/src/app/tests/mcp_startup.rs
@@ -43,6 +43,7 @@ async fn subagent_mcp_startup_settles_while_cached_servers_remain_deferred() {
)),
turns: Vec::new(),
events: Vec::new(),
+ active_reasoning_item: None,
input_state: None,
},
/*resume_restored_queue*/ false,
diff --git a/codex-rs/tui/src/app/tests/patch_approval_tests.rs b/codex-rs/tui/src/app/tests/patch_approval_tests.rs
index c01f6789f3..8f5e36e101 100644
--- a/codex-rs/tui/src/app/tests/patch_approval_tests.rs
+++ b/codex-rs/tui/src/app/tests/patch_approval_tests.rs
@@ -295,6 +295,7 @@ async fn replayed_patch_approval_pager_recovers_stored_turn_changes() {
vec![patch_item()],
)],
events: vec![ThreadBufferedEvent::Request(Box::new(request(thread_id)))],
+ active_reasoning_item: None,
input_state: None,
},
/*resume_restored_queue*/ false,
diff --git a/codex-rs/tui/src/app/tests/realtime_requests.rs b/codex-rs/tui/src/app/tests/realtime_requests.rs
index 2df11927c9..77e5d07eb4 100644
--- a/codex-rs/tui/src/app/tests/realtime_requests.rs
+++ b/codex-rs/tui/src/app/tests/realtime_requests.rs
@@ -66,6 +66,7 @@ fn empty_thread_snapshot(app: &App, thread_id: ThreadId) -> ThreadEventSnapshot
session: Some(test_thread_session(thread_id, app.config.cwd.to_path_buf())),
turns: Vec::new(),
events: Vec::new(),
+ active_reasoning_item: None,
input_state: None,
}
}
@@ -558,6 +559,7 @@ async fn replay_reconciles_only_matching_voice_captions_one_for_one() {
session: Some(test_thread_session(source, app.config.cwd.to_path_buf())),
turns: vec![voice, typed],
events: Vec::new(),
+ active_reasoning_item: None,
input_state: None,
},
/*resume_restored_queue*/ false,
@@ -727,6 +729,7 @@ async fn buffered_voice_items_reconcile_captions_after_thread_switch() {
session: Some(test_thread_session(source, app.config.cwd.to_path_buf())),
turns: Vec::new(),
events: events_to_replay,
+ active_reasoning_item: None,
input_state: None,
},
/*resume_restored_queue*/ false,
@@ -827,6 +830,7 @@ async fn unrendered_buffered_items_do_not_consume_retained_captions() {
)],
),
],
+ active_reasoning_item: None,
input_state: None,
},
/*resume_restored_queue*/ false,
@@ -1152,6 +1156,7 @@ async fn switching_threads_retains_undelivered_voice_answer_after_replay_evictio
duration_ms: None,
}],
events: Vec::new(),
+ active_reasoning_item: None,
input_state: None,
},
/*resume_restored_queue*/ false,
diff --git a/codex-rs/tui/src/app/tests/reasoning_resume_tests.rs b/codex-rs/tui/src/app/tests/reasoning_resume_tests.rs
new file mode 100644
index 0000000000..526a0ee8e0
--- /dev/null
+++ b/codex-rs/tui/src/app/tests/reasoning_resume_tests.rs
@@ -0,0 +1,180 @@
+//! Resume snapshots must accept an unfinished reasoning stream without an earlier item/started.
+
+use super::*;
+use crate::chatwidget::tests::helpers::render_bottom_popup;
+use codex_app_server_protocol::ItemCompletedNotification;
+use codex_app_server_protocol::ReasoningSummaryTextDeltaNotification;
+
+#[tokio::test]
+async fn resumed_reasoning_without_start_accepts_deltas_and_completion() {
+ for initial_replay in [false, true] {
+ for snapshot_item_id in [None, Some("reasoning"), Some("previous")] {
+ for with_delta in [false, true] {
+ let (mut app, mut events, _ops) = make_test_app_with_channels().await;
+ let thread_id = ThreadId::new();
+ let session = test_thread_session(thread_id, app.config.cwd.to_path_buf());
+ let items = snapshot_item_id
+ .into_iter()
+ .map(|id| ThreadItem::Reasoning {
+ id: id.into(),
+ summary: vec![
+ if id == "previous" {
+ "**Earlier work**\nEarlier paragraph."
+ } else {
+ "**Inspecting**\nSnapshot paragraph."
+ }
+ .into(),
+ ],
+ content: Vec::new(),
+ })
+ .collect();
+ let turns = vec![test_turn("turn", TurnStatus::InProgress, items)];
+ if initial_replay {
+ app.chat_widget.handle_thread_session(session);
+ app.chat_widget
+ .replay_thread_turns(turns, ReplayKind::ResumeInitialMessages);
+ } else {
+ // Reconnect constructs a fresh store; no start notification was retained.
+ let store =
+ ThreadEventStore::new_with_session(/*capacity*/ 1, session, turns);
+ assert!(store.active_reasoning_item.is_none());
+ app.replay_thread_snapshot(
+ store.snapshot(),
+ /*resume_restored_queue*/ false,
+ );
+ }
+ let delta = |turn_id: &str, text: &str| {
+ ServerNotification::ReasoningSummaryTextDelta(
+ ReasoningSummaryTextDeltaNotification {
+ thread_id: thread_id.to_string(),
+ turn_id: turn_id.into(),
+ item_id: "reasoning".into(),
+ delta: text.into(),
+ summary_index: 0,
+ },
+ )
+ };
+ app.chat_widget.handle_server_notification(
+ delta("old-turn", "Wrong turn"),
+ /*replay_kind*/ None,
+ );
+ assert!(
+ !render_bottom_popup(&app.chat_widget, /*width*/ 80).contains("Wrong turn")
+ );
+ if with_delta {
+ app.chat_widget.handle_server_notification(
+ delta("turn", "\n**Running checks**"),
+ /*replay_kind*/ None,
+ );
+ assert!(
+ render_bottom_popup(&app.chat_widget, /*width*/ 80)
+ .contains("Running checks")
+ );
+ }
+ app.chat_widget.handle_server_notification(
+ ServerNotification::ItemCompleted(ItemCompletedNotification {
+ thread_id: thread_id.to_string(),
+ turn_id: "turn".into(),
+ completed_at_ms: 0,
+ item: ThreadItem::Reasoning {
+ id: "reasoning".into(),
+ summary: vec![
+ "**Inspecting**\nSnapshot paragraph.\nCompleted paragraph.".into(),
+ ],
+ content: Vec::new(),
+ },
+ }),
+ /*replay_kind*/ None,
+ );
+ app.chat_widget.handle_server_notification(
+ delta("turn", "Stale update"),
+ /*replay_kind*/ None,
+ );
+ assert!(
+ !render_bottom_popup(&app.chat_widget, /*width*/ 80).contains("Stale update")
+ );
+ let transcript = reasoning_transcript(&mut events);
+ insta::allow_duplicates! {
+ if snapshot_item_id == Some("previous") {
+ insta::assert_snapshot!(transcript, @"
+ • Earlier paragraph.
+
+ • Snapshot paragraph.
+ Completed paragraph.
+ ");
+ } else {
+ insta::assert_snapshot!(transcript, @"
+ • Snapshot paragraph.
+ Completed paragraph.
+ ");
+ }
+ }
+ }
+ }
+ }
+}
+
+#[tokio::test]
+async fn resumed_trailing_reasoning_is_kept_when_no_more_reasoning_arrives() {
+ for next_item in [false, true] {
+ let (mut app, mut events, _ops) = make_test_app_with_channels().await;
+ let thread_id = ThreadId::new();
+ let session = test_thread_session(thread_id, app.config.cwd.to_path_buf());
+ let store = ThreadEventStore::new_with_session(
+ /*capacity*/ 1,
+ session,
+ vec![test_turn(
+ "turn",
+ TurnStatus::InProgress,
+ vec![ThreadItem::Reasoning {
+ id: "finished".into(),
+ summary: vec!["**Inspecting**\nSaved paragraph.".into()],
+ content: Vec::new(),
+ }],
+ )],
+ );
+ app.replay_thread_snapshot(store.snapshot(), /*resume_restored_queue*/ false);
+ if next_item {
+ app.chat_widget.handle_server_notification(
+ ServerNotification::ItemStarted(
+ codex_app_server_protocol::ItemStartedNotification {
+ thread_id: thread_id.to_string(),
+ turn_id: "turn".into(),
+ started_at_ms: 0,
+ item: ThreadItem::Reasoning {
+ id: "next".into(),
+ summary: Vec::new(),
+ content: Vec::new(),
+ },
+ },
+ ),
+ /*replay_kind*/ None,
+ );
+ }
+ app.chat_widget.handle_server_notification(
+ turn_completed_notification(thread_id, "turn", TurnStatus::Completed),
+ /*replay_kind*/ None,
+ );
+ insta::allow_duplicates! {
+ insta::assert_snapshot!(reasoning_transcript(&mut events), @"
+ • Saved paragraph.
+ ");
+ }
+ }
+}
+
+fn reasoning_transcript(events: &mut tokio::sync::mpsc::UnboundedReceiver<AppEvent>) -> String {
+ std::iter::from_fn(|| events.try_recv().ok())
+ .filter_map(|event| match event {
+ AppEvent::InsertHistoryCell(cell)
+ if cell
+ .as_any()
+ .is::<crate::history_cell::ReasoningSummaryCell>() =>
+ {
+ Some(lines_to_single_string(&cell.transcript_lines(/*width*/ 80)))
+ }
+ _ => None,
+ })
+ .collect::<Vec<_>>()
+ .join("\n\n")
+}
diff --git a/codex-rs/tui/src/app/tests/startup.rs b/codex-rs/tui/src/app/tests/startup.rs
index 1bbcaa135a..d217135021 100644
--- a/codex-rs/tui/src/app/tests/startup.rs
+++ b/codex-rs/tui/src/app/tests/startup.rs
@@ -1520,6 +1520,7 @@ async fn ignore_same_thread_resume_allows_retrying_read_only_view() -> Result<()
session: Some(session),
turns: vec![test_turn("running", TurnStatus::InProgress, Vec::new())],
events: Vec::new(),
+ active_reasoning_item: None,
input_state: None,
},
/*resume_restored_queue*/ false,
diff --git a/codex-rs/tui/src/app/thread_events.rs b/codex-rs/tui/src/app/thread_events.rs
index f577a1f02a..e80695fe40 100644
--- a/codex-rs/tui/src/app/thread_events.rs
+++ b/codex-rs/tui/src/app/thread_events.rs
@@ -14,6 +14,7 @@ pub(super) struct ThreadEventSnapshot {
pub(super) delegated_turns: Vec<String>,
pub(super) turns: Vec<Turn>,
pub(super) events: Vec<ThreadBufferedEvent>,
+ pub(super) active_reasoning_item: Option<codex_app_server_protocol::ItemStartedNotification>,
pub(super) input_state: Option<ThreadInputState>,
}
@@ -65,6 +66,8 @@ pub(super) struct ThreadEventStore {
pub(super) buffer: VecDeque<ThreadBufferedEvent>,
pub(super) pending_interactive_replay: PendingInteractiveReplayState,
pub(super) active_turn_id: Option<String>,
+ // Retain the active item even if its start falls out of the bounded replay buffer.
+ pub(super) active_reasoning_item: Option<codex_app_server_protocol::ItemStartedNotification>,
// Lifecycle identity must survive bounded replay-buffer eviction.
pub(super) latest_turn_id: Option<String>,
pub(super) pending_interrupt_turn_id: Option<String>,
@@ -109,6 +112,7 @@ impl ThreadEventStore {
buffer: VecDeque::new(),
pending_interactive_replay: PendingInteractiveReplayState::default(),
active_turn_id: None,
+ active_reasoning_item: None,
latest_turn_id: None,
pending_interrupt_turn_id: None,
input_state: None,
@@ -143,6 +147,14 @@ impl ThreadEventStore {
}
pub(super) fn set_turns(&mut self, turns: Vec<Turn>) {
+ if self.active_reasoning_item.as_ref().is_some_and(|started| {
+ turns.iter().any(|turn| {
+ (turn.id == started.turn_id && turn.status != TurnStatus::InProgress)
+ || (turn.id != started.turn_id && turn.status == TurnStatus::InProgress)
+ })
+ }) {
+ self.active_reasoning_item = None;
+ }
self.recap_progress
.merge(recap::RecapProgress::from_turns(&turns));
self.active_turn_id = turns
@@ -185,8 +197,22 @@ impl ThreadEventStore {
match notification.as_ref() {
ServerNotification::TurnStarted(turn) => {
self.set_active_turn_id(turn.turn.id.clone());
+ if self
+ .active_reasoning_item
+ .as_ref()
+ .is_some_and(|started| started.turn_id != turn.turn.id)
+ {
+ self.active_reasoning_item = None;
+ }
}
ServerNotification::TurnCompleted(turn) => {
+ if self
+ .active_reasoning_item
+ .as_ref()
+ .is_some_and(|started| started.turn_id == turn.turn.id)
+ {
+ self.active_reasoning_item = None;
+ }
if self.active_turn_id.is_none() {
self.latest_turn_id = Some(turn.turn.id.clone());
}
@@ -210,8 +236,40 @@ impl ThreadEventStore {
}
ServerNotification::ThreadClosed(_) => {
self.active_turn_id = None;
+ self.active_reasoning_item = None;
self.pending_interrupt_turn_id = None;
}
+ ServerNotification::ItemStarted(
+ started @ codex_app_server_protocol::ItemStartedNotification {
+ item: ThreadItem::Reasoning { id, .. },
+ ..
+ },
+ ) if !self.delegated_turns.contains(&started.turn_id)
+ && !self.turns.iter().any(|turn| {
+ turn.id == started.turn_id && turn.items.iter().any(is_voice_handoff_item)
+ }) =>
+ {
+ self.active_reasoning_item =
+ Some(codex_app_server_protocol::ItemStartedNotification {
+ thread_id: started.thread_id.clone(),
+ turn_id: started.turn_id.clone(),
+ item: ThreadItem::Reasoning {
+ id: id.clone(),
+ summary: Vec::new(),
+ content: Vec::new(),
+ },
+ started_at_ms: started.started_at_ms,
+ });
+ }
+ ServerNotification::ItemCompleted(completed)
+ if matches!(&completed.item, ThreadItem::Reasoning { .. })
+ && self.active_reasoning_item.as_ref().is_some_and(|started| {
+ started.turn_id == completed.turn_id
+ && started.item.id() == completed.item.id()
+ }) =>
+ {
+ self.active_reasoning_item = None;
+ }
_ => {}
}
@@ -313,6 +371,7 @@ impl ThreadEventStore {
})
.cloned()
.collect(),
+ active_reasoning_item: self.active_reasoning_item.clone(),
input_state: self.input_state.clone(),
};
if let Some(latest_turn_id) = &self.latest_turn_id {
@@ -353,7 +412,11 @@ impl ThreadEventStore {
.difference(&buffered_markers)
.cloned()
.collect::<std::collections::HashSet<_>>();
- let mut typed_items = std::collections::HashSet::new();
+ let mut typed_items = self
+ .active_reasoning_item
+ .iter()
+ .map(|started| (started.turn_id.clone(), started.item.id().to_string()))
+ .collect::<std::collections::HashSet<_>>();
snapshot.events.retain_mut(|event| {
let ThreadBufferedEvent::Notification(notification) = event else {
return true;
diff --git a/codex-rs/tui/src/app/thread_routing.rs b/codex-rs/tui/src/app/thread_routing.rs
index 165a8ec0cd..c5692ceade 100644
--- a/codex-rs/tui/src/app/thread_routing.rs
+++ b/codex-rs/tui/src/app/thread_routing.rs
@@ -1676,6 +1676,7 @@ impl App {
let mut store = channel.store.lock().await;
store.set_session(session.clone(), turns.clone());
store.rebase_buffer_after_session_refresh();
+ snapshot.active_reasoning_item = store.active_reasoning_item.clone();
}
snapshot.session = Some(session);
snapshot.turns = turns;
@@ -1766,6 +1767,7 @@ impl App {
mut snapshot: ThreadEventSnapshot,
resume_restored_queue: bool,
) {
+ let mut reasoning_replay = reasoning_replay::ReasoningReplay::new(&mut snapshot);
let replayed_final_items = realtime_delivery::completed_agent_items(&snapshot);
let replayed_voice_texts = realtime_delivery::replayed_voice_texts(&snapshot);
replay_filter::omit_completed_agent_deltas(&mut snapshot.events);
@@ -1832,6 +1834,7 @@ impl App {
.replay_thread_turns(snapshot.turns, ReplayKind::ThreadSnapshot);
}
for (event, changes) in snapshot.events.into_iter().zip(request_changes) {
+ reasoning_replay.before_event(&event, &mut self.chat_widget);
if suppress_replay_notices && replay_filter::event_is_notice(&event) {
continue;
}
@@ -1842,6 +1845,7 @@ impl App {
(event, _) => self.handle_thread_event_replay(event),
}
}
+ reasoning_replay.restore(&mut self.chat_widget);
if should_buffer_replay {
self.app_event_tx
.send(AppEvent::EndInitialHistoryReplayBuffer);
diff --git a/codex-rs/tui/src/app_server_session.rs b/codex-rs/tui/src/app_server_session.rs
index ee55b9a85d..980839b7f2 100644
--- a/codex-rs/tui/src/app_server_session.rs
+++ b/codex-rs/tui/src/app_server_session.rs
@@ -1909,6 +1909,36 @@ fn remove_permission_config_overrides(config: &mut Option<HashMap<String, serde_
}
}
+fn new_thread_reasoning_overrides(config: &Config) -> Option<HashMap<String, serde_json::Value>> {
+ let mut overrides = config_request_overrides_from_config(config).unwrap_or_default();
+ let summary = config
+ .model_reasoning_summary
+ .unwrap_or(codex_protocol::config_types::ReasoningSummary::Detailed);
+ overrides.insert(
+ "model_reasoning_summary".to_string(),
+ serde_json::Value::String(summary.to_string()),
+ );
+ let explicit_feature = config
+ .config_layer_stack
+ .effective_config()
+ .get("features")
+ .and_then(|features| features.get("concurrent_reasoning_summaries"))
+ .and_then(toml::Value::as_bool);
+ let features = overrides
+ .entry("features".to_string())
+ .or_insert_with(|| serde_json::json!({}));
+ if let Some(features) = features.as_object_mut() {
+ features.insert(
+ "concurrent_reasoning_summaries".to_string(),
+ serde_json::Value::Bool(
+ summary != codex_protocol::config_types::ReasoningSummary::None
+ && explicit_feature.unwrap_or(/*default*/ false),
+ ),
+ );
+ }
+ Some(overrides)
+}
+
fn service_tier_override_from_config(config: &Config) -> Option<Option<String>> {
let local_settings = LocalSettings::from(config);
config.service_tier.clone().map(Some).or_else(|| {
@@ -2041,7 +2071,10 @@ pub(crate) fn thread_start_params_from_config(
approvals_reviewer: approvals_reviewer_override_from_config(config),
sandbox,
permissions,
- config: config_request_overrides_from_config(config),
+ config: match thread_params_mode {
+ ThreadParamsMode::Embedded => new_thread_reasoning_overrides(config),
+ ThreadParamsMode::Remote => config_request_overrides_from_config(config),
+ },
ephemeral: Some(config.ephemeral),
history_mode: (!config.ephemeral).then_some(ThreadHistoryMode::Paginated),
session_start_source,
@@ -2466,6 +2499,10 @@ pub(crate) fn app_server_rate_limit_snapshots(
snapshots
}
+#[cfg(test)]
+#[path = "app_server_session/reasoning_defaults_tests.rs"]
+mod reasoning_defaults_tests;
+
#[cfg(test)]
#[path = "app_server_session/prompt_history_tests.rs"]
mod prompt_history_tests;
@@ -3354,7 +3391,12 @@ mod tests {
("web_search".to_string(), string("disabled")),
("bypass_hook_trust".to_string(), true.into()),
]);
- assert_eq!(start.config, Some(expected_config.clone()));
+ let mut expected_start_config = expected_config.clone();
+ expected_start_config.insert(
+ "features".to_string(),
+ serde_json::json!({"concurrent_reasoning_summaries": false}),
+ );
+ assert_eq!(start.config, Some(expected_start_config));
assert_eq!(resume.config, Some(expected_config.clone()));
assert_eq!(fork.config, Some(expected_config));
}
diff --git a/codex-rs/tui/src/app_server_session/reasoning_defaults_tests.rs b/codex-rs/tui/src/app_server_session/reasoning_defaults_tests.rs
new file mode 100644
index 0000000000..40c65d9c4e
--- /dev/null
+++ b/codex-rs/tui/src/app_server_session/reasoning_defaults_tests.rs
@@ -0,0 +1,174 @@
+//! Verify embedded TUI reasoning configuration and its outbound model request.
+
+use super::*;
+use crate::legacy_core::config::ConfigBuilder;
+use codex_app_server_protocol::ServerNotification;
+use core_test_support::responses;
+use pretty_assertions::assert_eq;
+use serde_json::json;
+
+#[tokio::test]
+async fn embedded_reasoning_defaults_reach_responses() -> Result<()> {
+ for (settings, summary, stream_options) in [
+ ("", json!("detailed"), json!(null)),
+ (
+ "[features]\nconcurrent_reasoning_summaries = false",
+ json!("detailed"),
+ json!(null),
+ ),
+ (
+ "[features]\nconcurrent_reasoning_summaries = true",
+ json!("detailed"),
+ json!({"reasoning_summary_delivery": "sequential_cutoff"}),
+ ),
+ (
+ "model_reasoning_summary = 'none'\n[features]\nconcurrent_reasoning_summaries = true",
+ json!(null),
+ json!(null),
+ ),
+ ] {
+ let server = responses::start_mock_server().await;
+ let response = responses::mount_sse_once(
+ &server,
+ responses::sse(vec![
+ responses::ev_response_created("response"),
+ responses::ev_completed("response"),
+ ]),
+ )
+ .await;
+ let home = tempfile::tempdir()?;
+ let base_url = server.uri();
+ std::fs::write(
+ home.path().join("config.toml"),
+ format!(
+ r#"
+model = "gpt-5.2"
+model_provider = "reasoning-test"
+{settings}
+[model_providers.reasoning-test]
+name = "OpenAI"
+base_url = "{base_url}/v1"
+wire_api = "responses"
+request_max_retries = 0
+stream_max_retries = 0
+"#
+ ),
+ )?;
+ let config = ConfigBuilder::default()
+ .codex_home(home.path().to_path_buf())
+ .build()
+ .await?;
+ let mut app_server = crate::start_embedded_app_server_for_picker(&config).await?;
+ let started = app_server.start_thread(&config).await?;
+ let request_id = app_server.next_request_id();
+ let _: TurnStartResponse = app_server
+ .client
+ .request_typed(ClientRequest::TurnStart {
+ request_id,
+ params: TurnStartParams {
+ thread_id: started.session.thread_id.to_string(),
+ input: vec![UserInput::Text {
+ text: "hello".to_string(),
+ text_elements: Vec::new(),
+ }],
+ ..Default::default()
+ },
+ })
+ .await?;
+ tokio::time::timeout(std::time::Duration::from_secs(/*secs*/ 30), async {
+ while let Some(event) = app_server.next_event().await {
+ if let AppServerEvent::ServerNotification(notification) = event
+ && let ServerNotification::TurnCompleted(completed) = *notification
+ {
+ assert_eq!(
+ completed.turn.status,
+ codex_app_server_protocol::TurnStatus::Completed
+ );
+ return;
+ }
+ }
+ panic!("app-server disconnected before completing the turn");
+ })
+ .await?;
+ let body = response.single_request().body_json();
+ assert_eq!(
+ json!({"summary": body["reasoning"]["summary"], "stream_options": body["stream_options"]}),
+ json!({"summary": summary, "stream_options": stream_options}),
+ "settings: {settings}"
+ );
+ app_server.shutdown().await?;
+ }
+ Ok(())
+}
+
+#[tokio::test]
+async fn new_tui_threads_request_summaries_unless_explicitly_disabled() {
+ let temp_dir = tempfile::tempdir().expect("tempdir");
+ for (config_text, expected_summary, expected_concurrent) in [
+ ("", "detailed", false),
+ (
+ "[features]\nconcurrent_reasoning_summaries = true",
+ "detailed",
+ true,
+ ),
+ ("model_reasoning_summary = 'none'", "none", false),
+ (
+ "model_reasoning_summary = 'none'\n[features]\nconcurrent_reasoning_summaries = true",
+ "none",
+ false,
+ ),
+ (
+ "model_reasoning_summary = 'concise'\n[features]\nconcurrent_reasoning_summaries = false",
+ "concise",
+ false,
+ ),
+ ] {
+ std::fs::write(temp_dir.path().join("config.toml"), config_text).expect("config");
+ let config = ConfigBuilder::default()
+ .codex_home(temp_dir.path().to_path_buf())
+ .build()
+ .await
+ .expect("config should build");
+ let start = thread_start_params_from_config(
+ &config,
+ ThreadParamsMode::Embedded,
+ /*remote_cwd_override*/ None,
+ /*session_start_source*/ None,
+ );
+ let overrides = start.config.expect("thread config");
+ assert_eq!(
+ overrides.get("model_reasoning_summary"),
+ Some(&serde_json::json!(expected_summary)),
+ );
+ assert_eq!(
+ overrides["features"]["concurrent_reasoning_summaries"],
+ expected_concurrent,
+ );
+ }
+ std::fs::write(
+ temp_dir.path().join("config.toml"),
+ "model_reasoning_summary = 'detailed'",
+ )
+ .expect("config");
+ let config = ConfigBuilder::default()
+ .codex_home(temp_dir.path().to_path_buf())
+ .cli_overrides(vec![(
+ "model_reasoning_summary".to_string(),
+ toml::Value::String("none".to_string()),
+ )])
+ .build()
+ .await
+ .expect("override config");
+ let start = thread_start_params_from_config(
+ &config,
+ ThreadParamsMode::Embedded,
+ /*remote_cwd_override*/ None,
+ /*session_start_source*/ None,
+ );
+ let overrides = start.config.expect("thread config");
+ assert_eq!(overrides["model_reasoning_summary"], "none");
+ assert_eq!(
+ overrides["features"]["concurrent_reasoning_summaries"],
+ false
+ );
+}
diff --git a/codex-rs/tui/src/chatwidget/protocol.rs b/codex-rs/tui/src/chatwidget/protocol.rs
index d43adf4f53..ca893999f9 100644
--- a/codex-rs/tui/src/chatwidget/protocol.rs
+++ b/codex-rs/tui/src/chatwidget/protocol.rs
@@ -15,6 +15,11 @@ impl ChatWidget {
return;
}
+ if replay_kind != Some(ReplayKind::ResumeInitialMessages)
+ && !self.recover_resumed_reasoning(&notification)
+ {
+ return;
+ }
let was_replaying_turn_completion = self.thread_usage.replaying_turn_completion;
self.thread_usage.replaying_turn_completion = replay_kind.is_some();
let from_replay = replay_kind.is_some();
@@ -98,7 +103,9 @@ impl ChatWidget {
if !self.is_realtime_delegated_reasoning_item(
&notification.turn_id,
&notification.item_id,
- ) {
+ ) && self.status_state.reasoning_item_id.as_deref()
+ == Some(&notification.item_id)
+ {
self.on_agent_reasoning_delta(notification.delta);
}
}
@@ -108,6 +115,7 @@ impl ChatWidget {
&notification.turn_id,
&notification.item_id,
)
+ && self.status_state.reasoning_item_id.as_deref() == Some(&notification.item_id)
{
self.on_agent_reasoning_delta(notification.delta);
}
@@ -116,7 +124,9 @@ impl ChatWidget {
if !self.is_realtime_delegated_reasoning_item(
&notification.turn_id,
&notification.item_id,
- ) {
+ ) && self.status_state.reasoning_item_id.as_deref()
+ == Some(&notification.item_id)
+ {
self.on_reasoning_section_break();
}
}
@@ -334,6 +344,20 @@ impl ChatWidget {
| ServerNotification::ThreadProjectUpdated(_) => {}
ServerNotification::ContextCompacted(_) => {}
}
+ // Tool and hook activity can recreate a hidden row with its default
+ // heading. Restore the selected status before that row is rendered.
+ if self
+ .bottom_pane
+ .status_widget()
+ .is_some_and(|status| status.header() != self.status_state.current_status.header)
+ {
+ self.bottom_pane.update_status(
+ self.status_state.current_status.header.clone(),
+ self.status_state.current_status.details.clone(),
+ StatusDetailsCapitalization::Preserve,
+ self.status_state.current_status.details_max_lines,
+ );
+ }
self.thread_usage.replaying_turn_completion = was_replaying_turn_completion;
}
@@ -461,16 +485,22 @@ impl ChatWidget {
ThreadItem::AgentMessage { id, .. } if replay_kind.is_none() => {
self.is_realtime_delegated_agent_item(&notification.turn_id, &id);
}
- ThreadItem::Reasoning { id, .. }
+ ThreadItem::Reasoning { id, .. } => {
if replay_kind.is_none()
- && !self.is_realtime_delegated_reasoning_turn(&notification.turn_id) =>
- {
- // A later voice handoff can steer this turn without making an
- // already-started typed reasoning item private.
- self.realtime_conversation
- .agent_items
- .entry((notification.turn_id.clone(), id))
- .or_insert(realtime::RealtimeAgentItemOrigin::Typed);
+ && !self.is_realtime_delegated_reasoning_turn(&notification.turn_id)
+ {
+ // A later voice handoff can steer this turn without making an
+ // already-started typed reasoning item private.
+ self.realtime_conversation
+ .agent_items
+ .entry((notification.turn_id.clone(), id.clone()))
+ .or_insert(realtime::RealtimeAgentItemOrigin::Typed);
+ }
+ if !matches!(replay_kind, Some(ReplayKind::ResumeInitialMessages))
+ && !self.is_realtime_delegated_reasoning_item(&notification.turn_id, &id)
+ {
+ self.on_reasoning_item_started(id);
+ }
}
ThreadItem::ContextCompaction { id }
if !matches!(replay_kind, Some(ReplayKind::ResumeInitialMessages)) =>
@@ -552,6 +582,12 @@ impl ChatWidget {
{
self.add_async_questions(id, questions);
}
+ if replay_kind.is_none()
+ && let ThreadItem::Reasoning { id, .. } = &notification.item
+ && self.status_state.reasoning_item_id.as_ref() != Some(id)
+ {
+ return;
+ }
match notification.item {
item @ ThreadItem::CommandExecution { .. } => self.on_command_execution_completed(item),
item => self.handle_thread_item(
diff --git a/codex-rs/tui/src/chatwidget/realtime_tests/speech_recovery.rs b/codex-rs/tui/src/chatwidget/realtime_tests/speech_recovery.rs
index 4710b8feb7..7c3f33ed15 100644
--- a/codex-rs/tui/src/chatwidget/realtime_tests/speech_recovery.rs
+++ b/codex-rs/tui/src/chatwidget/realtime_tests/speech_recovery.rs
@@ -338,6 +338,12 @@ async fn delegated_reasoning_never_enters_live_history() {
}
}
assert!(!chat.is_realtime_delegated_reasoning_turn(turn_id));
+ let typed_reasoning = ThreadItem::Reasoning {
+ id: "typed-reasoning".into(),
+ summary: vec!["ordinary summary".into()],
+ content: Vec::new(),
+ };
+ start_item(&mut chat, thread_id, "typed-turn", typed_reasoning.clone());
chat.handle_server_notification(
ServerNotification::ReasoningSummaryTextDelta(ReasoningSummaryTextDeltaNotification {
thread_id: thread_id.to_string(),
@@ -348,16 +354,7 @@ async fn delegated_reasoning_never_enters_live_history() {
}),
/*replay_kind*/ None,
);
- complete_item(
- &mut chat,
- thread_id,
- "typed-turn",
- ThreadItem::Reasoning {
- id: "typed-reasoning".into(),
- summary: vec!["ordinary summary".into()],
- content: Vec::new(),
- },
- );
+ complete_item(&mut chat, thread_id, "typed-turn", typed_reasoning);
let rendered = std::iter::from_fn(|| events.try_recv().ok())
.filter_map(|event| match event {
AppEvent::InsertHistoryCell(cell) => Some(
diff --git a/codex-rs/tui/src/chatwidget/replay.rs b/codex-rs/tui/src/chatwidget/replay.rs
index a233ce20e0..0fb1efde45 100644
--- a/codex-rs/tui/src/chatwidget/replay.rs
+++ b/codex-rs/tui/src/chatwidget/replay.rs
@@ -1,11 +1,95 @@
//! Thread replay rendering for `ChatWidget`.
//!
//! This module rehydrates turns and items into transcript state while avoiding
-//! live-only side effects.
+//! live-only side effects. An in-progress snapshot does not carry reasoning completion
+//! state: keep its trailing reasoning provisional until live events identify the next item.
use super::*;
impl ChatWidget {
+ /// Restores the active typed reasoning item after a thread switch or session refresh.
+ /// Its completion carries the full summary if the bounded event buffer lost earlier deltas.
+ pub(crate) fn restore_active_reasoning_item(
+ &mut self,
+ started: codex_app_server_protocol::ItemStartedNotification,
+ parts: Option<(Vec<String>, Vec<String>)>,
+ ) {
+ let turn_id = started.turn_id;
+ let id = started.item.id().to_string();
+ self.realtime_conversation
+ .agent_items
+ .entry((turn_id, id.clone()))
+ .or_insert(realtime::RealtimeAgentItemOrigin::Typed);
+ self.on_reasoning_item_started(id);
+ self.status_state.reasoning_recovered_after_refresh = true;
+ if let Some((summary, content)) = parts {
+ let reasoning_parts = summary.into_iter().chain(
+ self.config
+ .show_raw_agent_reasoning
+ .then_some(content)
+ .into_iter()
+ .flatten(),
+ );
+ for (index, delta) in reasoning_parts.enumerate() {
+ if index > 0 {
+ self.on_reasoning_section_break();
+ }
+ self.on_agent_reasoning_delta(delta);
+ }
+ }
+ }
+
+ /// The first reasoning update after resume can arrive without an item/started event.
+ /// Returns false for unrelated reasoning while waiting for the resumed turn's first update.
+ pub(super) fn recover_resumed_reasoning(&mut self, notification: &ServerNotification) -> bool {
+ let Some(resumed_turn_id) = self.status_state.reasoning_resume_turn_id.clone() else {
+ return true;
+ };
+ let (turn_id, item_id) = match notification {
+ ServerNotification::ReasoningSummaryTextDelta(delta) => {
+ (&delta.turn_id, &delta.item_id)
+ }
+ ServerNotification::ReasoningTextDelta(delta) => (&delta.turn_id, &delta.item_id),
+ ServerNotification::ReasoningSummaryPartAdded(part) => (&part.turn_id, &part.item_id),
+ ServerNotification::ItemCompleted(
+ codex_app_server_protocol::ItemCompletedNotification {
+ turn_id,
+ item: ThreadItem::Reasoning { id, .. },
+ ..
+ },
+ ) => (turn_id, id),
+ ServerNotification::ItemStarted(item)
+ if resumed_turn_id == item.turn_id
+ && !matches!(item.item, ThreadItem::UserMessage { .. })
+ && self.status_state.reasoning_item_id.as_deref() != Some(item.item.id()) =>
+ {
+ // A new item closes a trailing snapshot that was already complete at resume.
+ self.on_agent_reasoning_final();
+ return true;
+ }
+ _ => return true,
+ };
+ if resumed_turn_id != *turn_id
+ || self.is_realtime_delegated_reasoning_item(turn_id, item_id)
+ {
+ return false;
+ }
+ self.restore_active_reasoning_item(
+ codex_app_server_protocol::ItemStartedNotification {
+ thread_id: self.thread_id.map(|id| id.to_string()).unwrap_or_default(),
+ turn_id: turn_id.clone(),
+ item: ThreadItem::Reasoning {
+ id: item_id.clone(),
+ summary: Vec::new(),
+ content: Vec::new(),
+ },
+ started_at_ms: 0,
+ },
+ /*parts*/ None,
+ );
+ true
+ }
+
/// Flush prior activity before live or replayed assistant text.
pub(super) fn prepare_assistant_message(&mut self) {
self.flush_unified_exec_wait_streak();
@@ -59,6 +143,13 @@ impl ChatWidget {
self.last_non_retry_error = None;
self.on_task_started();
}
+ let trailing_reasoning_id = (status == TurnStatus::InProgress)
+ .then(|| items.last())
+ .flatten()
+ .and_then(|item| match item {
+ ThreadItem::Reasoning { id, .. } => Some(id.clone()),
+ _ => None,
+ });
let mut replaying_delegation = false;
for item in items {
if matches!(&item, ThreadItem::UserMessage { content, .. }
@@ -74,13 +165,38 @@ impl ChatWidget {
if hidden_nested_review_turn && matches!(item, ThreadItem::UserMessage { .. }) {
continue;
}
- self.replay_thread_item(item, turn_id.clone(), replay_kind);
+ if trailing_reasoning_id.as_deref() == Some(item.id())
+ && let ThreadItem::Reasoning {
+ id,
+ summary,
+ content,
+ } = item
+ {
+ self.restore_active_reasoning_item(
+ codex_app_server_protocol::ItemStartedNotification {
+ thread_id: self.thread_id.map(|id| id.to_string()).unwrap_or_default(),
+ turn_id: turn_id.clone(),
+ item: ThreadItem::Reasoning {
+ id,
+ summary: Vec::new(),
+ content: Vec::new(),
+ },
+ started_at_ms: 0,
+ },
+ Some((summary, content)),
+ );
+ } else {
+ self.replay_thread_item(item, turn_id.clone(), replay_kind);
+ }
}
let status = if hidden_nested_review_turn {
TurnStatus::Completed
} else {
status
};
+ if status == TurnStatus::InProgress {
+ self.status_state.reasoning_resume_turn_id = Some(turn_id.clone());
+ }
// A resolved historical precaution must not clear the restored draft or input queue.
if Some(&turn_id) != latest_turn_id.as_ref()
&& error.as_ref().is_some_and(|error| {
@@ -201,9 +317,22 @@ impl ChatWidget {
}
ThreadItem::Plan { text, .. } => self.on_plan_item_completed(text),
ThreadItem::Reasoning {
- summary, content, ..
+ id,
+ summary,
+ content,
} => {
- if from_replay {
+ let recover_completion = self.status_state.reasoning_recovered_after_refresh
+ && (!summary.is_empty()
+ || (self.config.show_raw_agent_reasoning && !content.is_empty()));
+ if from_replay || recover_completion {
+ if from_replay {
+ self.on_reasoning_item_started(id);
+ } else {
+ // A refreshed snapshot can omit the active item and its earlier deltas.
+ // Reconcile with the complete item before committing the transcript.
+ self.reasoning_buffer.clear();
+ self.reasoning_summary_parts.clear();
+ }
let reasoning_parts = summary.into_iter().chain(
self.config
.show_raw_agent_reasoning
diff --git a/codex-rs/tui/src/chatwidget/snapshots/codex_tui__chatwidget__tests__reasoning_activity_row_40.snap b/codex-rs/tui/src/chatwidget/snapshots/codex_tui__chatwidget__tests__reasoning_activity_row_40.snap
new file mode 100644
index 0000000000..66b37b9256
--- /dev/null
+++ b/codex-rs/tui/src/chatwidget/snapshots/codex_tui__chatwidget__tests__reasoning_activity_row_40.snap
@@ -0,0 +1,5 @@
+---
+source: tui/src/chatwidget/tests/reasoning_status_tests.rs
+expression: terminal.backend()
+---
+"• Preparing evidence report (42s • esc …"
diff --git a/codex-rs/tui/src/chatwidget/snapshots/codex_tui__chatwidget__tests__reasoning_activity_row_80.snap b/codex-rs/tui/src/chatwidget/snapshots/codex_tui__chatwidget__tests__reasoning_activity_row_80.snap
new file mode 100644
index 0000000000..862a70d35f
--- /dev/null
+++ b/codex-rs/tui/src/chatwidget/snapshots/codex_tui__chatwidget__tests__reasoning_activity_row_80.snap
@@ -0,0 +1,5 @@
+---
+source: tui/src/chatwidget/tests/reasoning_status_tests.rs
+expression: terminal.backend()
+---
+"• Preparing evidence report (42s • esc to interrupt) · 1 background terminal ru…"
diff --git a/codex-rs/tui/src/chatwidget/snapshots/codex_tui__chatwidget__tests__reasoning_delta_restores_recreated_status_indicator.snap b/codex-rs/tui/src/chatwidget/snapshots/codex_tui__chatwidget__tests__reasoning_delta_restores_recreated_status_indicator.snap
index 9201be6555..c107219278 100644
--- a/codex-rs/tui/src/chatwidget/snapshots/codex_tui__chatwidget__tests__reasoning_delta_restores_recreated_status_indicator.snap
+++ b/codex-rs/tui/src/chatwidget/snapshots/codex_tui__chatwidget__tests__reasoning_delta_restores_recreated_status_indicator.snap
@@ -1,9 +1,10 @@
---
source: tui/src/chatwidget/tests/status_and_layout.rs
+assertion_line: 4833
expression: normalized_backend_snapshot(terminal.backend())
---
" "
-"• Checking files (0s • esc to interrupt) · 1 background terminal running · /ps …"
+"• Checking files and preparing a response (0s • esc to interrupt) · 1 backgroun…"
" "
" "
"› Ask Codex to do anything "
diff --git a/codex-rs/tui/src/chatwidget/status_state.rs b/codex-rs/tui/src/chatwidget/status_state.rs
index bd42599424..5fe1eba3da 100644
--- a/codex-rs/tui/src/chatwidget/status_state.rs
+++ b/codex-rs/tui/src/chatwidget/status_state.rs
@@ -110,6 +110,12 @@ impl PendingGuardianReviewStatus {
#[derive(Debug)]
pub(super) struct StatusState {
+ /// Only the active reasoning item may update the streamed heading.
+ pub(super) reasoning_item_id: Option<String>,
+ /// An in-progress snapshot can omit the start of its next live reasoning update.
+ pub(super) reasoning_resume_turn_id: Option<String>,
+ /// A restored stream may have missed earlier deltas; use its complete item at finalization.
+ pub(super) reasoning_recovered_after_refresh: bool,
pub(super) compaction: Option<super::compaction::ActiveCompaction>,
pub(super) current_status: StatusIndicatorState,
pub(super) pending_guardian_review_status: PendingGuardianReviewStatus,
@@ -122,6 +128,9 @@ pub(super) struct StatusState {
impl Default for StatusState {
fn default() -> Self {
Self {
+ reasoning_item_id: None,
+ reasoning_resume_turn_id: None,
+ reasoning_recovered_after_refresh: false,
compaction: None,
current_status: StatusIndicatorState::working(),
pending_guardian_review_status: PendingGuardianReviewStatus::default(),
diff --git a/codex-rs/tui/src/chatwidget/streaming.rs b/codex-rs/tui/src/chatwidget/streaming.rs
index 1ddf39698e..18b421661e 100644
--- a/codex-rs/tui/src/chatwidget/streaming.rs
+++ b/codex-rs/tui/src/chatwidget/streaming.rs
@@ -5,15 +5,56 @@
use super::*;
+fn latest_summary_line(text: &str) -> Option<String> {
+ text.lines().rev().find_map(|line| {
+ let line = line.trim();
+ if line.is_empty() || line.starts_with("<!--") {
+ return None;
+ }
+ let line = line.trim_start_matches('#').trim();
+ let line = if let Some(stripped) = line.strip_prefix("**") {
+ let (bold, trailing) = stripped.split_once("**")?;
+ format!("{bold}{trailing}")
+ } else {
+ line.to_string()
+ };
+ (!line.is_empty()).then_some(line)
+ })
+}
+
impl ChatWidget {
+ pub(super) fn on_reasoning_item_started(&mut self, id: String) {
+ if self.status_state.reasoning_resume_turn_id.take().is_some()
+ && self.status_state.reasoning_item_id.as_ref() != Some(&id)
+ {
+ self.on_agent_reasoning_final();
+ }
+ if self.status_state.reasoning_item_id.as_ref() == Some(&id) {
+ return;
+ }
+ self.status_state.reasoning_item_id = Some(id);
+ self.status_state.reasoning_recovered_after_refresh = false;
+ self.reasoning_buffer.clear();
+ self.reasoning_summary_parts.clear();
+ self.restore_reasoning_status_header();
+ }
+
pub(super) fn restore_reasoning_status_header(&mut self) {
- if self.reasoning_header.is_none() {
- self.reasoning_header = extract_first_bold(&self.reasoning_buffer);
+ if self.safety_buffering_is_waiting()
+ || self.unified_exec_wait_streak.is_some()
+ || self.status_state.compaction.is_some()
+ || !self.status_state.pending_guardian_review_status.is_empty()
+ {
+ return;
}
+ self.reasoning_header =
+ latest_summary_line(&self.reasoning_buffer).or(self.reasoning_header.take());
if let Some(header) = self.reasoning_header.clone() {
self.status_state.terminal_title_status_kind = TerminalTitleStatusKind::Thinking;
self.set_status_header(header);
- } else if self.bottom_pane.is_task_running() {
+ } else if self.bottom_pane.is_task_running()
+ || self.status_state.current_status.is_guardian_review()
+ {
self.status_state.terminal_title_status_kind = TerminalTitleStatusKind::Working;
self.set_status_header(String::from("Working"));
}
@@ -230,9 +271,7 @@ impl ChatWidget {
}
pub(super) fn on_agent_reasoning_delta(&mut self, delta: String) {
- // For reasoning deltas, do not stream to history. Accumulate the
- // current reasoning block and extract the first bold element
- // (between **/**) as the chunk header. Show this header as status.
+ // Accumulate the current reasoning block for history and activity text.
self.reasoning_buffer.push_str(&delta);
if self.safety_buffering_is_waiting() {
@@ -244,11 +283,14 @@ impl ChatWidget {
return;
}
- if self.reasoning_header.is_none() {
- self.reasoning_header = extract_first_bold(&self.reasoning_buffer);
+ if !self.status_state.pending_guardian_review_status.is_empty() {
+ return;
}
+
+ self.reasoning_header =
+ latest_summary_line(&self.reasoning_buffer).or(self.reasoning_header.take());
let Some(header) = self.reasoning_header.as_deref() else {
- // Fallback while we don't yet have a bold header: leave existing header as-is.
+ // No usable summary has arrived yet.
return;
};
@@ -279,13 +321,22 @@ impl ChatWidget {
self.reasoning_summary_parts
.push(std::mem::take(&mut self.reasoning_buffer));
}
+ self.reasoning_header = self
+ .reasoning_summary_parts
+ .iter()
+ .rev()
+ .find_map(|part| latest_summary_line(part))
+ .or(self.reasoning_header.take());
if !self.reasoning_summary_parts.is_empty() {
let reasoning_parts = std::mem::take(&mut self.reasoning_summary_parts);
let cell = history_cell::new_reasoning_summary_block(reasoning_parts, &self.config.cwd);
self.add_boxed_history(cell);
}
self.reasoning_buffer.clear();
- self.reasoning_header = None;
+ // Keep the last useful summary through tools and later empty items.
+ self.status_state.reasoning_item_id = None;
+ self.status_state.reasoning_resume_turn_id = None;
+ self.status_state.reasoning_recovered_after_refresh = false;
self.reasoning_summary_parts.clear();
self.request_redraw();
}
@@ -296,7 +347,6 @@ impl ChatWidget {
self.reasoning_summary_parts
.push(std::mem::take(&mut self.reasoning_buffer));
}
- self.reasoning_header = None;
}
pub(super) fn on_stream_error(&mut self, message: String, additional_details: Option<String>) {
diff --git a/codex-rs/tui/src/chatwidget/tests.rs b/codex-rs/tui/src/chatwidget/tests.rs
index a1d17beca0..c7aaa1a7a5 100644
--- a/codex-rs/tui/src/chatwidget/tests.rs
+++ b/codex-rs/tui/src/chatwidget/tests.rs
@@ -267,6 +267,8 @@ mod plugin_catalog;
mod popups_and_settings;
#[path = "tests/rate_limit_recovery_tests.rs"]
mod rate_limit_recovery_tests;
+#[path = "tests/reasoning_status_tests.rs"]
+mod reasoning_status_tests;
#[path = "tests/replay_render_tests.rs"]
mod replay_render_tests;
mod review_mode;
diff --git a/codex-rs/tui/src/chatwidget/tests/helpers.rs b/codex-rs/tui/src/chatwidget/tests/helpers.rs
index e4cb315e71..3092a265b6 100644
--- a/codex-rs/tui/src/chatwidget/tests/helpers.rs
+++ b/codex-rs/tui/src/chatwidget/tests/helpers.rs
@@ -532,7 +532,30 @@ pub(super) fn handle_agent_message_delta(chat: &mut ChatWidget, delta: impl Into
);
}
+pub(super) fn handle_agent_reasoning_started(chat: &mut ChatWidget, id: impl Into<String>) {
+ chat.handle_server_notification(
+ ServerNotification::ItemStarted(ItemStartedNotification {
+ thread_id: thread_id(chat),
+ turn_id: chat
+ .turn_lifecycle
+ .last_turn_id
+ .clone()
+ .unwrap_or_else(|| "turn-1".to_string()),
+ started_at_ms: 0,
+ item: AppServerThreadItem::Reasoning {
+ id: id.into(),
+ summary: Vec::new(),
+ content: Vec::new(),
+ },
+ }),
+ /*replay_kind*/ None,
+ );
+}
+
pub(super) fn handle_agent_reasoning_delta(chat: &mut ChatWidget, delta: impl Into<String>) {
+ if chat.status_state.reasoning_item_id.is_none() {
+ handle_agent_reasoning_started(chat, "reasoning-1");
+ }
chat.handle_server_notification(
ServerNotification::ReasoningSummaryTextDelta(ReasoningSummaryTextDeltaNotification {
thread_id: thread_id(chat),
@@ -550,6 +573,9 @@ pub(super) fn handle_agent_reasoning_delta(chat: &mut ChatWidget, delta: impl In
}
pub(super) fn handle_agent_reasoning_final(chat: &mut ChatWidget) {
+ if chat.status_state.reasoning_item_id.is_none() {
+ handle_agent_reasoning_started(chat, "reasoning-1");
+ }
chat.handle_server_notification(
ServerNotification::ItemCompleted(ItemCompletedNotification {
thread_id: thread_id(chat),
diff --git a/codex-rs/tui/src/chatwidget/tests/history_replay.rs b/codex-rs/tui/src/chatwidget/tests/history_replay.rs
index 676bf7f0ba..d44f9da6a2 100644
--- a/codex-rs/tui/src/chatwidget/tests/history_replay.rs
+++ b/codex-rs/tui/src/chatwidget/tests/history_replay.rs
@@ -1386,6 +1386,8 @@ async fn live_reasoning_summary_is_not_rendered_twice_when_item_completes() {
);
let _ = drain_insert_history(&mut rx);
+ handle_agent_reasoning_started(&mut chat, "reasoning-1");
+
chat.handle_server_notification(
ServerNotification::ReasoningSummaryTextDelta(ReasoningSummaryTextDeltaNotification {
thread_id: "thread-1".to_string(),
@@ -1443,6 +1445,8 @@ async fn live_reasoning_summary_drops_empty_parts_without_losing_content() {
);
let _ = drain_insert_history(&mut rx);
+ handle_agent_reasoning_started(&mut chat, "reasoning-1");
+
for (summary_index, delta) in [
(0, "**Plan**\n\ndone"),
(1, "**Checking tests**\n\n<!-- -->"),
diff --git a/codex-rs/tui/src/chatwidget/tests/reasoning_status_tests.rs b/codex-rs/tui/src/chatwidget/tests/reasoning_status_tests.rs
new file mode 100644
index 0000000000..904cb25827
--- /dev/null
+++ b/codex-rs/tui/src/chatwidget/tests/reasoning_status_tests.rs
@@ -0,0 +1,317 @@
+//! Reasoning activity retains the latest usable line through empty items and status-row replacement.
+
+use super::*;
+use pretty_assertions::assert_eq;
+
+fn delta(chat: &mut ChatWidget, id: &str, text: &str) {
+ chat.handle_server_notification(
+ ServerNotification::ReasoningSummaryTextDelta(ReasoningSummaryTextDeltaNotification {
+ thread_id: "thread-1".to_string(),
+ turn_id: "turn-1".to_string(),
+ item_id: id.to_string(),
+ delta: text.to_string(),
+ summary_index: 0,
+ }),
+ /*replay_kind*/ None,
+ );
+}
+
+fn complete(chat: &mut ChatWidget, id: &str) {
+ chat.handle_server_notification(
+ ServerNotification::ItemCompleted(ItemCompletedNotification {
+ thread_id: "thread-1".to_string(),
+ turn_id: "turn-1".to_string(),
+ completed_at_ms: 0,
+ item: AppServerThreadItem::Reasoning {
+ id: id.to_string(),
+ summary: Vec::new(),
+ content: Vec::new(),
+ },
+ }),
+ /*replay_kind*/ None,
+ );
+}
+
+#[tokio::test]
+async fn reasoning_status_accepts_bold_text_with_a_plain_suffix() {
+ let (mut chat, _rx, _ops) = make_chatwidget_manual(/*model_override*/ None).await;
+ chat.on_task_started();
+ handle_agent_reasoning_started(&mut chat, "reasoning");
+
+ delta(&mut chat, "reasoning", "**Checking tests");
+ let before_close = chat
+ .bottom_pane
+ .status_widget()
+ .unwrap()
+ .header()
+ .to_string();
+ delta(&mut chat, "reasoning", "**: running suite");
+ let after_close = chat
+ .bottom_pane
+ .status_widget()
+ .unwrap()
+ .header()
+ .to_string();
+
+ insta::assert_debug_snapshot!(vec![before_close, after_close], @r###"
+ [
+ "Working",
+ "Checking tests: running suite",
+ ]
+ "###);
+}
+
+#[tokio::test]
+async fn reasoning_status_tracks_items_and_restores_after_tool_activity() {
+ let (mut chat, _rx, _ops) = make_chatwidget_manual(/*model_override*/ None).await;
+ chat.on_task_started();
+ let mut headers = Vec::new();
+ let capture = |chat: &ChatWidget, headers: &mut Vec<String>| {
+ headers.push(
+ chat.bottom_pane
+ .status_widget()
+ .expect("running status")
+ .header()
+ .to_string(),
+ );
+ };
+
+ handle_agent_reasoning_started(&mut chat, "first");
+ delta(&mut chat, "first", "**Researching backend");
+ capture(&chat, &mut headers);
+ delta(&mut chat, "first", " freshness**");
+ capture(&chat, &mut headers);
+ complete(&mut chat, "first");
+ delta(&mut chat, "first", "**Late old header**");
+ capture(&chat, &mut headers);
+
+ // A tool recreates the row after streamed commentary has hidden it.
+ chat.bottom_pane.hide_status_indicator();
+ begin_unified_exec_startup(&mut chat, "tool-1", "process-1", "sleep 2");
+ capture(&chat, &mut headers);
+
+ handle_agent_reasoning_started(&mut chat, "second");
+ capture(&chat, &mut headers);
+ chat.handle_server_notification(
+ ServerNotification::ReasoningSummaryPartAdded(
+ codex_app_server_protocol::ReasoningSummaryPartAddedNotification {
+ thread_id: "thread-1".to_string(),
+ turn_id: "turn-1".to_string(),
+ item_id: "first".to_string(),
+ summary_index: 1,
+ },
+ ),
+ /*replay_kind*/ None,
+ );
+ complete(&mut chat, "first");
+ delta(&mut chat, "first", "**Stale heading**");
+ delta(&mut chat, "second", "No summary heading is available.");
+ capture(&chat, &mut headers);
+ delta(&mut chat, "second", "\n**Preparing evidence report**");
+ capture(&chat, &mut headers);
+
+ insta::assert_debug_snapshot!(headers);
+ let mut timer = crate::status_indicator_widget::StatusTimer::default();
+ timer.pause_at(std::time::Instant::now());
+ timer.reset(std::time::Duration::from_secs(/*secs*/ 42));
+ for width in [80, 40] {
+ let mut terminal =
+ ratatui::Terminal::new(ratatui::backend::TestBackend::new(width, /*height*/ 1))
+ .expect("terminal");
+ terminal
+ .draw(|frame| {
+ chat.bottom_pane
+ .status_widget()
+ .expect("running status")
+ .with_timer(&timer)
+ .render(frame.area(), frame.buffer_mut());
+ })
+ .expect("render reasoning status");
+ assert_chatwidget_snapshot!(
+ format!("reasoning_activity_row_{width}"),
+ terminal.backend()
+ );
+ }
+ chat.on_interrupted_turn(TurnAbortReason::Interrupted);
+ delta(&mut chat, "second", "**After interruption**");
+ assert_eq!(chat.status_state.reasoning_item_id, None);
+ assert_eq!(chat.reasoning_header, None);
+ assert!(!chat.bottom_pane.status_indicator_visible());
+ chat.on_task_started();
+ assert_eq!(
+ chat.bottom_pane.status_widget().unwrap().header(),
+ "Working"
+ );
+}
+
+#[tokio::test]
+async fn voice_handoff_preserves_typed_reasoning_and_ignores_private_items() {
+ let (mut chat, _rx, _ops) = make_chatwidget_manual(/*model_override*/ None).await;
+ chat.on_task_started();
+ handle_agent_reasoning_started(&mut chat, "typed");
+ delta(&mut chat, "typed", "**Checking repository**");
+
+ chat.remember_realtime_delegated_reasoning_turn("turn-1");
+ handle_agent_reasoning_started(&mut chat, "private");
+ delta(&mut chat, "private", "**Private voice reasoning**");
+ complete(&mut chat, "private");
+ assert_eq!(
+ chat.status_state.reasoning_item_id.as_deref(),
+ Some("typed")
+ );
+ assert_eq!(
+ chat.bottom_pane.status_widget().unwrap().header(),
+ "Checking repository"
+ );
+
+ delta(&mut chat, "typed", "\n**Verifying changes**");
+ assert_eq!(
+ chat.bottom_pane.status_widget().unwrap().header(),
+ "Verifying changes"
+ );
+ complete(&mut chat, "typed");
+ assert_eq!(chat.status_state.reasoning_item_id, None);
+}
+
+#[tokio::test]
+async fn reasoning_status_preserves_an_explicit_wait_and_restores_the_heading() {
+ let (mut chat, _rx, _ops) = make_chatwidget_manual(/*model_override*/ None).await;
+ chat.on_task_started();
+ chat.status_state
+ .pending_guardian_review_status
+ .start_or_update("review-1".to_string(), "Checking a command".to_string());
+ chat.set_status_header("Reviewing approval request".to_string());
+ handle_agent_reasoning_started(&mut chat, "first");
+ delta(&mut chat, "first", "**Choosing the missing-data fix**");
+ complete(&mut chat, "first");
+ assert_eq!(
+ chat.bottom_pane.status_widget().unwrap().header(),
+ "Reviewing approval request"
+ );
+ chat.status_state
+ .pending_guardian_review_status
+ .finish("review-1");
+ chat.restore_reasoning_status_header();
+ assert_eq!(
+ chat.bottom_pane.status_widget().unwrap().header(),
+ "Choosing the missing-data fix"
+ );
+}
+
+#[tokio::test]
+async fn reasoning_status_replay_retains_last_usable_heading() {
+ let (mut chat, _rx, _ops) = make_chatwidget_manual(/*model_override*/ None).await;
+ chat.on_task_started();
+ for (id, summary, expected) in [
+ (
+ "first",
+ vec!["**First heading**".to_string()],
+ "First heading",
+ ),
+ (
+ "second",
+ vec!["**Second heading**".to_string()],
+ "Second heading",
+ ),
+ ("third", Vec::new(), "Second heading"),
+ ] {
+ chat.handle_thread_item(
+ AppServerThreadItem::Reasoning {
+ id: id.to_string(),
+ summary,
+ content: Vec::new(),
+ },
+ "turn-1".to_string(),
+ ThreadItemRenderSource::Replay(ReplayKind::ThreadSnapshot),
+ );
+ assert_eq!(chat.bottom_pane.status_widget().unwrap().header(), expected);
+ }
+}
+
+#[tokio::test]
+async fn reasoning_status_accepts_plain_lines_and_ignores_empty_sections() {
+ let (mut chat, _rx, _ops) = make_chatwidget_manual(/*model_override*/ None).await;
+ chat.on_task_started();
+ handle_agent_reasoning_started(&mut chat, "first");
+ delta(
+ &mut chat,
+ "first",
+ "# Checking files\n<!-- progress -->\nPreparing response",
+ );
+ assert_eq!(
+ chat.bottom_pane.status_widget().unwrap().header(),
+ "Preparing response"
+ );
+ complete(&mut chat, "first");
+ handle_agent_reasoning_started(&mut chat, "second");
+ delta(&mut chat, "second", "<!-- no public update -->");
+ assert_eq!(
+ chat.bottom_pane.status_widget().unwrap().header(),
+ "Preparing response"
+ );
+ delta(&mut chat, "second", "\n**Verifying results**");
+ assert_eq!(
+ chat.bottom_pane.status_widget().unwrap().header(),
+ "Verifying results"
+ );
+}
+
+#[tokio::test]
+async fn completed_reasoning_stays_in_expanded_transcript_for_live_and_replay() {
+ let mut renders = Vec::new();
+ for replay in [false, true] {
+ let (mut chat, mut rx, _ops) = make_chatwidget_manual(/*model_override*/ None).await;
+ chat.on_task_started();
+ for (id, summary) in [
+ ("first", "**Inspecting repository structure**"),
+ ("second", "Mapping the app structure"),
+ (
+ "third",
+ "**Tracing terminal components**\n\nThe playback clock preserves elapsed time.",
+ ),
+ ] {
+ if replay {
+ chat.handle_thread_item(
+ AppServerThreadItem::Reasoning {
+ id: id.to_string(),
+ summary: vec![summary.to_string()],
+ content: Vec::new(),
+ },
+ "turn-1".to_string(),
+ ThreadItemRenderSource::Replay(ReplayKind::ThreadSnapshot),
+ );
+ } else {
+ handle_agent_reasoning_started(&mut chat, id);
+ delta(&mut chat, id, summary);
+ complete(&mut chat, id);
+ }
+ }
+ let mut compact = Vec::new();
+ let mut expanded = Vec::new();
+ while let Ok(event) = rx.try_recv() {
+ if let AppEvent::InsertHistoryCell(cell) = event {
+ compact.extend(cell.display_lines(/*width*/ 80));
+ expanded.extend(cell.transcript_lines(/*width*/ 80));
+ assert!(cell.raw_lines().is_empty());
+ }
+ }
+ let rendered = format!(
+ "Compact history:\n{}\nLive status:\n{}\nExpanded transcript:\n{}",
+ ratatui::text::Text::from(compact),
+ chat.bottom_pane.status_widget().unwrap().header(),
+ ratatui::text::Text::from(expanded),
+ );
+ renders.push(rendered);
+ }
+ assert_eq!(renders[0], renders[1]);
+ insta::assert_snapshot!(renders[0], @r"
+ Compact history:
+
+ Live status:
+ The playback clock preserves elapsed time.
+ Expanded transcript:
+ • Inspecting repository structure
+ • Mapping the app structure
+ • The playback clock preserves elapsed time.
+ ");
+}
diff --git a/codex-rs/tui/src/chatwidget/tests/snapshots/codex_tui__chatwidget__tests__reasoning_status_tests__reasoning_status_tracks_items_and_restores_after_tool_activity.snap b/codex-rs/tui/src/chatwidget/tests/snapshots/codex_tui__chatwidget__tests__reasoning_status_tests__reasoning_status_tracks_items_and_restores_after_tool_activity.snap
new file mode 100644
index 0000000000..dbc3101857
--- /dev/null
+++ b/codex-rs/tui/src/chatwidget/tests/snapshots/codex_tui__chatwidget__tests__reasoning_status_tests__reasoning_status_tracks_items_and_restores_after_tool_activity.snap
@@ -0,0 +1,14 @@
+---
+source: tui/src/chatwidget/tests/reasoning_status_tests.rs
+assertion_line: 84
+expression: headers
+---
+[
+ "Working",
+ "Researching backend freshness",
+ "Researching backend freshness",
+ "Researching backend freshness",
+ "Researching backend freshness",
+ "No summary heading is available.",
+ "Preparing evidence report",
+]
diff --git a/codex-rs/tui/src/chatwidget/tests/status_and_layout.rs b/codex-rs/tui/src/chatwidget/tests/status_and_layout.rs
index 8de9141a6f..0569ae223b 100644
--- a/codex-rs/tui/src/chatwidget/tests/status_and_layout.rs
+++ b/codex-rs/tui/src/chatwidget/tests/status_and_layout.rs
@@ -4744,29 +4744,29 @@ async fn regular_commit_tick_clears_orphaned_plan_stream_tail() {
}
#[tokio::test]
-async fn reasoning_delta_redraws_only_when_header_becomes_visible() {
+async fn reasoning_delta_redraws_when_latest_usable_line_changes() {
let (mut chat, _rx, _op_rx) = make_chatwidget_manual(/*model_override*/ None).await;
let (frame_requester, mut draw_rx) = FrameRequester::test_channel();
chat.frame_requester = frame_requester;
- chat.on_agent_reasoning_delta("still looking".to_string());
+ chat.on_agent_reasoning_delta("**Checking".to_string());
assert!(matches!(
draw_rx.try_recv(),
Err(tokio::sync::mpsc::error::TryRecvError::Empty)
));
assert_eq!(chat.reasoning_header, None);
- chat.on_agent_reasoning_delta(" **Checking".to_string());
- assert!(matches!(
- draw_rx.try_recv(),
- Err(tokio::sync::mpsc::error::TryRecvError::Empty)
- ));
-
chat.on_agent_reasoning_delta(" files**".to_string());
assert!(draw_rx.try_recv().is_ok());
assert_eq!(chat.reasoning_header.as_deref(), Some("Checking files"));
- chat.on_agent_reasoning_delta(" and preparing a response".to_string());
+ chat.on_agent_reasoning_delta("\nPreparing a response".to_string());
+ assert!(draw_rx.try_recv().is_ok());
+ assert_eq!(
+ chat.reasoning_header.as_deref(),
+ Some("Preparing a response")
+ );
+ chat.on_agent_reasoning_delta("".to_string());
assert!(matches!(
draw_rx.try_recv(),
Err(tokio::sync::mpsc::error::TryRecvError::Empty)
@@ -4813,7 +4813,7 @@ async fn reasoning_delta_restores_recreated_status_indicator_header() {
.bottom_pane
.status_widget()
.expect("status indicator should be recreated");
- assert_eq!(status.header(), "Working");
+ assert_eq!(status.header(), "Checking files");
chat.on_agent_reasoning_delta(" and preparing a response".to_string());
@@ -4821,7 +4821,7 @@ async fn reasoning_delta_restores_recreated_status_indicator_header() {
.bottom_pane
.status_widget()
.expect("status indicator should remain visible");
- assert_eq!(status.header(), "Checking files");
+ assert_eq!(status.header(), "Checking files and preparing a response");
let width: u16 = 80;
let height = chat.desired_height(width);
diff --git a/codex-rs/tui/src/chatwidget/tool_requests.rs b/codex-rs/tui/src/chatwidget/tool_requests.rs
index 6f35d0c08f..1131064e2a 100644
--- a/codex-rs/tui/src/chatwidget/tool_requests.rs
+++ b/codex-rs/tui/src/chatwidget/tool_requests.rs
@@ -142,12 +142,12 @@ impl ChatWidget {
status.details_max_lines,
);
} else if self.status_state.current_status.is_guardian_review() {
- self.set_status_header(String::from("Working"));
+ self.restore_reasoning_status_header();
}
} else if self.status_state.pending_guardian_review_status.is_empty()
&& self.status_state.current_status.is_guardian_review()
{
- self.set_status_header(String::from("Working"));
+ self.restore_reasoning_status_header();
}
if ev.status == GuardianAssessmentStatus::Approved {
diff --git a/codex-rs/tui/src/chatwidget/turn_runtime.rs b/codex-rs/tui/src/chatwidget/turn_runtime.rs
index e52dc9118b..388af9dffc 100644
--- a/codex-rs/tui/src/chatwidget/turn_runtime.rs
+++ b/codex-rs/tui/src/chatwidget/turn_runtime.rs
@@ -103,6 +103,8 @@ impl ChatWidget {
self.reasoning_summary_parts.clear();
self.reasoning_buffer.clear();
self.reasoning_header = None;
+ self.status_state.reasoning_item_id = None;
+ self.status_state.reasoning_resume_turn_id = None;
self.set_ambient_pet_notification(
crate::pets::PetNotificationKind::Running,
/*body*/ None,
@@ -116,6 +118,9 @@ impl ChatWidget {
completion: Option<history_cell::FinalMessageSeparator>,
from_replay: bool,
) {
+ if self.status_state.reasoning_resume_turn_id.is_some() {
+ self.on_agent_reasoning_final();
+ }
self.input_queue.submit_pending_steers_after_interrupt = false;
let sanitized_last_agent_message = last_agent_message.as_deref().map(|message| {
parse_assistant_markdown(message, self.config.cwd.as_path()).visible_markdown
@@ -174,6 +179,9 @@ impl ChatWidget {
// Mark task stopped and request redraw now that all content is in history.
self.clear_context_compaction();
self.status_state.pending_status_indicator_restore = false;
+ self.status_state.reasoning_item_id = None;
+ self.status_state.reasoning_resume_turn_id = None;
+ self.reasoning_header = None;
self.input_queue.user_turn_pending_start = false;
self.clear_active_hook_cell();
self.clear_guardian_review_status();
@@ -314,6 +322,12 @@ impl ChatWidget {
/// This does not clear MCP startup tracking, because MCP startup can overlap with turn cleanup
/// and should continue to drive the bottom-pane running indicator while it is in progress.
pub(super) fn finalize_turn(&mut self) {
+ if self.status_state.reasoning_resume_turn_id.is_some() {
+ self.on_agent_reasoning_final();
+ }
+ self.status_state.reasoning_item_id = None;
+ self.status_state.reasoning_resume_turn_id = None;
+ self.reasoning_header = None;
self.clear_context_compaction();
self.clear_safety_buffering();
// Drop preview-only stream tail content on any termination path before
diff --git a/codex-rs/tui/src/history_cell/messages.rs b/codex-rs/tui/src/history_cell/messages.rs
index ea74889d03..084c4fffac 100644
--- a/codex-rs/tui/src/history_cell/messages.rs
+++ b/codex-rs/tui/src/history_cell/messages.rs
@@ -1,4 +1,5 @@
//! User, assistant, reasoning, and streaming message history cells.
+//! Completed reasoning is retained in the expanded transcript, not compact scrollback.
use super::markdown_render_cache::MarkdownRenderCache;
use super::*;
@@ -658,7 +659,8 @@ pub(crate) fn new_spoken_user_prompt(message: String) -> UserHistoryCell {
cell
}
-/// Create the reasoning history cell emitted at the end of a reasoning block.
+/// Retain a completed reasoning block in the expanded transcript only.
+/// Activity headings belong to the live status row and must not accumulate in scrollback.
///
/// The helper snapshots `cwd` into the returned cell so local file links render the same way they
/// did while the turn was live, even if rendering happens after other app state has advanced. Part
@@ -669,16 +671,8 @@ pub(crate) fn new_reasoning_summary_block(
cwd: &Path,
) -> Box<dyn HistoryCell> {
let (header, content) = split_reasoning_summary_parts(&reasoning_parts);
- let title_only = content
- .strip_prefix("**")
- .and_then(|content| content.strip_suffix("**"))
- .is_some_and(|content| !content.is_empty() && !content.contains("**"));
- let transcript_only = header.is_empty() && !title_only;
Box::new(ReasoningSummaryCell::new(
- header,
- content,
- cwd,
- transcript_only,
+ header, content, cwd, /*transcript_only*/ true,
))
}
diff --git a/codex-rs/tui/src/history_cell/tests.rs b/codex-rs/tui/src/history_cell/tests.rs
index 6374f75949..138c9b5b94 100644
--- a/codex-rs/tui/src/history_cell/tests.rs
+++ b/codex-rs/tui/src/history_cell/tests.rs
@@ -2670,7 +2670,7 @@ fn reasoning_summary_block() {
);
let rendered_display = render_lines(&cell.display_lines(/*width*/ 80));
- assert_eq!(rendered_display, vec!["• Detailed reasoning goes here."]);
+ assert_eq!(rendered_display, Vec::<String>::new());
let rendered_transcript = render_transcript(cell.as_ref());
assert_eq!(rendered_transcript, vec!["• Detailed reasoning goes here."]);
@@ -2742,7 +2742,7 @@ async fn reasoning_summary_block_respects_config_overrides() {
);
let rendered_display = render_lines(&cell.display_lines(/*width*/ 80));
- assert_eq!(rendered_display, vec!["• Detailed reasoning goes here."]);
+ assert_eq!(rendered_display, Vec::<String>::new());
}
#[test]
@@ -2776,17 +2776,14 @@ fn reasoning_summary_block_falls_back_when_summary_is_missing() {
}
#[test]
-fn reasoning_summary_block_displays_title_only_summary() {
+fn reasoning_summary_block_keeps_title_only_summary_in_expanded_transcript() {
let cell = new_reasoning_summary_block(
vec!["**Confirming backend JSONL source**".to_string()],
&test_cwd(),
);
let rendered_display = render_lines(&cell.display_lines(/*width*/ 80));
- insta::assert_snapshot!(
- rendered_display.join("\n"),
- @"• Confirming backend JSONL source"
- );
+ assert_eq!(rendered_display, Vec::<String>::new());
let rendered_transcript = render_transcript(cell.as_ref());
assert_eq!(
@@ -2803,7 +2800,7 @@ fn reasoning_summary_block_splits_header_and_summary_when_present() {
);
let rendered_display = render_lines(&cell.display_lines(/*width*/ 80));
- assert_eq!(rendered_display, vec!["• We should fix the bug next."]);
+ assert_eq!(rendered_display, Vec::<String>::new());
let rendered_transcript = render_transcript(cell.as_ref());
assert_eq!(rendered_transcript, vec!["• We should fix the bug next."]);
@@ -2820,7 +2817,7 @@ fn reasoning_summary_block_hides_empty_html_comment_parts() {
);
let rendered_display = render_lines(&cell.display_lines(/*width*/ 80));
- insta::assert_snapshot!(rendered_display.join("\n"), @"");
+ assert_eq!(rendered_display, Vec::<String>::new());
let rendered_transcript = render_transcript(cell.as_ref());
assert_eq!(rendered_transcript, Vec::<String>::new());
@@ -2838,7 +2835,7 @@ fn reasoning_summary_block_preserves_bold_content_after_empty_html_comment_part(
);
let rendered_display = render_lines(&cell.display_lines(/*width*/ 80));
- insta::assert_snapshot!(rendered_display.join("\n"), @"• Important conclusion");
+ assert_eq!(rendered_display, Vec::<String>::new());
let rendered_transcript = render_transcript(cell.as_ref());
assert_eq!(rendered_transcript, vec!["• Important conclusion"]);
@@ -2866,7 +2863,7 @@ fn reasoning_summary_block_strips_header_after_leading_empty_part() {
);
let rendered_display = render_lines(&cell.display_lines(/*width*/ 80));
- insta::assert_snapshot!(rendered_display.join("\n"), @"• Tests passed");
+ assert_eq!(rendered_display, Vec::<String>::new());
let rendered_transcript = render_transcript(cell.as_ref());
assert_eq!(rendered_transcript, vec!["• Tests passed"]);
@@ -2883,7 +2880,7 @@ fn reasoning_summary_block_drops_empty_part_after_real_content() {
);
let rendered_display = render_lines(&cell.display_lines(/*width*/ 80));
- insta::assert_snapshot!(rendered_display.join("\n"), @"• done");
+ assert_eq!(rendered_display, Vec::<String>::new());
let rendered_transcript = render_transcript(cell.as_ref());
assert_eq!(rendered_transcript, vec!["• done"]);
@@ -2897,7 +2894,7 @@ fn reasoning_summary_block_preserves_literal_html_comment() {
);
let rendered_display = render_lines(&cell.display_lines(/*width*/ 80));
- insta::assert_snapshot!(rendered_display.join("\n"), @"• Use <!-- --> in JSX.");
+ assert_eq!(rendered_display, Vec::<String>::new());
let rendered_transcript = render_transcript(cell.as_ref());
assert_eq!(rendered_transcript, vec!["• Use <!-- --> in JSX."]);
diff --git a/codex-rs/tui/src/snapshots/codex_tui__status_indicator_widget__summary_shimmer__tests__short_and_long_labels_sweep_smoothly_in_both_themes.snap b/codex-rs/tui/src/snapshots/codex_tui__status_indicator_widget__summary_shimmer__tests__short_and_long_labels_sweep_smoothly_in_both_themes.snap
new file mode 100644
index 0000000000..482ec825dc
--- /dev/null
+++ b/codex-rs/tui/src/snapshots/codex_tui__status_indicator_widget__summary_shimmer__tests__short_and_long_labels_sweep_smoothly_in_both_themes.snap
@@ -0,0 +1,35 @@
+---
+source: tui/src/summary_shimmer_tests.rs
+assertion_line: 27
+expression: "frames.join(\"\\n\")"
+---
+dark Working 0ms: [128, 128, 128, 128, 128, 128, 128]
+dark Working 500ms: [238, 198, 144, 128, 128, 128, 128]
+dark Working 1000ms: [128, 156, 212, 240, 212, 156, 128]
+dark Working 1500ms: [128, 128, 128, 128, 144, 198, 238]
+dark Working 2000ms: [128, 128, 128, 128, 128, 128, 128]
+dark Preparing bootstrap diagnostics 0ms: [128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128]
+dark Preparing bootstrap diagnostics 500ms: [128, 128, 128, 132, 175, 226, 237, 198, 145, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128]
+dark Preparing bootstrap diagnostics 1000ms: [128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 159, 213, 240, 213, 159, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128]
+dark Preparing bootstrap diagnostics 1500ms: [128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 145, 198, 237, 226, 175, 132, 128, 128, 128]
+dark Preparing bootstrap diagnostics 2000ms: [128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128]
+dark 界é界 0ms: [128, 128, 128]
+dark 界é界 500ms: [198, 129, 128]
+dark 界é界 1000ms: [184, 240, 184]
+dark 界é界 1500ms: [128, 129, 198]
+dark 界é界 2000ms: [128, 128, 128]
+light Working 0ms: [128, 128, 128, 128, 128, 128, 128]
+light Working 500ms: [17, 57, 111, 128, 128, 128, 128]
+light Working 1000ms: [128, 100, 44, 16, 44, 100, 128]
+light Working 1500ms: [128, 128, 128, 128, 111, 57, 17]
+light Working 2000ms: [128, 128, 128, 128, 128, 128, 128]
+light Preparing bootstrap diagnostics 0ms: [128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128]
+light Preparing bootstrap diagnostics 500ms: [128, 128, 128, 123, 80, 29, 18, 57, 110, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128]
+light Preparing bootstrap diagnostics 1000ms: [128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 127, 96, 42, 16, 42, 96, 127, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128]
+light Preparing bootstrap diagnostics 1500ms: [128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 110, 57, 18, 29, 80, 123, 128, 128, 128]
+light Preparing bootstrap diagnostics 2000ms: [128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128]
+light 界é界 0ms: [128, 128, 128]
+light 界é界 500ms: [57, 126, 128]
+light 界é界 1000ms: [72, 16, 72]
+light 界é界 1500ms: [128, 126, 57]
+light 界é界 2000ms: [128, 128, 128]
diff --git a/codex-rs/tui/src/status_indicator_widget.rs b/codex-rs/tui/src/status_indicator_widget.rs
index 19b0fa2cb0..a6cfe78f7b 100644
--- a/codex-rs/tui/src/status_indicator_widget.rs
+++ b/codex-rs/tui/src/status_indicator_widget.rs
@@ -28,7 +28,6 @@ use crate::line_truncation::truncate_line_with_ellipsis_if_overflow;
use crate::motion::MotionMode;
use crate::motion::ReducedMotionIndicator;
use crate::motion::activity_indicator;
-use crate::motion::shimmer_text;
use crate::render::renderable::Renderable;
use crate::text_formatting::capitalize_first;
use crate::tui::FrameRequester;
@@ -39,6 +38,10 @@ use crate::wrapping::word_wrap_lines;
mod timer;
pub(crate) use timer::StatusTimer;
+#[path = "summary_shimmer.rs"]
+mod summary_shimmer;
+use summary_shimmer::summary_shimmer;
+
pub(crate) const STATUS_DETAILS_DEFAULT_MAX_LINES: usize = 3;
const DETAILS_PREFIX: &str = " └ ";
@@ -52,6 +55,7 @@ pub(crate) enum StatusDetailsCapitalization {
pub(crate) struct StatusIndicatorWidget {
/// Animated header text (defaults to "Working").
header: String,
+ header_started_at: Instant,
details: Option<String>,
details_max_lines: usize,
/// Optional suffix rendered after the elapsed/interrupt segment.
@@ -91,6 +95,7 @@ impl StatusIndicatorWidget {
) -> Self {
Self {
header: String::from("Working"),
+ header_started_at: Instant::now(),
details: None,
details_max_lines: STATUS_DETAILS_DEFAULT_MAX_LINES,
inline_message: None,
@@ -109,7 +114,10 @@ impl StatusIndicatorWidget {
/// Update the animated header label (left of the brackets).
pub(crate) fn update_header(&mut self, header: String) {
- self.header = header;
+ if self.header != header {
+ self.header = header;
+ self.header_started_at = Instant::now();
+ }
}
/// Update the details text shown below the header.
@@ -227,7 +235,11 @@ impl StatusIndicator<'_> {
spans.push(indicator);
spans.push(" ".into());
}
- spans.extend(shimmer_text(&row.header, motion_mode));
+ spans.extend(summary_shimmer(
+ &row.header,
+ now.saturating_duration_since(row.header_started_at),
+ motion_mode,
+ ));
if !spans.is_empty() {
spans.push(" ".into());
}
@@ -308,6 +320,22 @@ mod tests {
use pretty_assertions::assert_eq;
+ #[test]
+ fn changed_summary_restarts_shimmer_but_repeated_summary_keeps_phase() {
+ let (tx, _rx) = unbounded_channel();
+ let mut row = StatusIndicatorWidget::new(
+ AppEventSender::new(tx),
+ FrameRequester::test_dummy(),
+ /*animations_enabled*/ true,
+ );
+ let previous = Instant::now() - Duration::from_secs(/*secs*/ 1);
+ row.header_started_at = previous;
+ row.update_header("Working".to_owned());
+ assert_eq!(row.header_started_at, previous);
+ row.update_header("Mapping the app structure".to_owned());
+ assert!(row.header_started_at > previous);
+ }
+
#[test]
fn fmt_elapsed_compact_formats_seconds_minutes_hours() {
assert_eq!(fmt_elapsed_compact(/*elapsed_secs*/ 0), "0s");
diff --git a/codex-rs/tui/src/summary_shimmer.rs b/codex-rs/tui/src/summary_shimmer.rs
new file mode 100644
index 0000000000..16fab1f580
--- /dev/null
+++ b/codex-rs/tui/src/summary_shimmer.rs
@@ -0,0 +1,56 @@
+//! Smooth, whole-grapheme status shimmer with a two-second sweep.
+//!
+//! Only brightness changes: the moving band uses the terminal foreground, while
+//! the remaining text blends halfway into the background. The wave spans at
+//! least six terminal columns so short labels do not flash one letter at a time.
+//! Unknown palettes use static dim text instead of a stepped animation.
+
+use std::time::Duration;
+
+use ratatui::style::Style;
+use ratatui::text::Span;
+use unicode_segmentation::UnicodeSegmentation;
+use unicode_width::UnicodeWidthStr;
+
+use crate::color::blend;
+use crate::motion::MotionMode;
+use crate::terminal_palette::StdoutColorLevel;
+use crate::terminal_palette::default_bg;
+use crate::terminal_palette::default_fg;
+use crate::terminal_palette::effective_stdout_color_level;
+use crate::terminal_palette::rgb_color;
+
+pub(crate) fn summary_shimmer(
+ text: &str,
+ elapsed: Duration,
+ motion: MotionMode,
+) -> Vec<Span<'static>> {
+ if motion == MotionMode::Reduced {
+ return vec![text.to_owned().into()];
+ }
+ let (StdoutColorLevel::TrueColor, Some(fg), Some(bg)) =
+ (effective_stdout_color_level(), default_fg(), default_bg())
+ else {
+ return vec![Span::styled(text.to_owned(), Style::default().dim())];
+ };
+ let width = text.width() as f64;
+ let half_width = (width * 0.1).max(/*other*/ 3.0);
+ let position = (elapsed.as_secs_f64() % 2.0) / 2.0 * (width + 2.0 * half_width) - half_width;
+ let mut column = 0.0;
+ text.graphemes(/*is_extended*/ true)
+ .map(|grapheme| {
+ let glyph_width = grapheme.width() as f64;
+ let center = column + glyph_width / 2.0;
+ column += glyph_width;
+ let distance = ((center - position).abs() / half_width).min(/*other*/ 1.0);
+ let intensity = 0.5 * (1.0 + (std::f64::consts::PI * distance).cos());
+ let alpha = (0.5 + 0.5 * intensity) as f32;
+ let style = Style::default().fg(rgb_color(blend(fg, bg, alpha)));
+ Span::styled(grapheme.to_owned(), style)
+ })
+ .collect()
+}
+
+#[cfg(test)]
+#[path = "summary_shimmer_tests.rs"]
+mod tests;
diff --git a/codex-rs/tui/src/summary_shimmer_tests.rs b/codex-rs/tui/src/summary_shimmer_tests.rs
new file mode 100644
index 0000000000..a14cd8cc38
--- /dev/null
+++ b/codex-rs/tui/src/summary_shimmer_tests.rs
@@ -0,0 +1,114 @@
+use super::*;
+use pretty_assertions::assert_eq;
+
+use crate::terminal_palette::with_test_default_colors;
+use crate::terminal_probe::DefaultColors;
+
+#[test]
+fn short_and_long_labels_sweep_smoothly_in_both_themes() {
+ let mut frames = Vec::new();
+ for (theme, colors) in [
+ (
+ "dark",
+ DefaultColors {
+ fg: (240, 240, 240),
+ bg: (16, 16, 16),
+ },
+ ),
+ (
+ "light",
+ DefaultColors {
+ fg: (16, 16, 16),
+ bg: (240, 240, 240),
+ },
+ ),
+ ] {
+ with_test_default_colors(colors, || {
+ for text in ["Working", "Preparing bootstrap diagnostics", "界e\u{301}界"] {
+ for ms in [0, 500, 1000, 1500, 2000] {
+ let spans =
+ summary_shimmer(text, Duration::from_millis(ms), MotionMode::Animated);
+ let levels = spans
+ .iter()
+ .map(|span| match span.style.fg {
+ Some(ratatui::style::Color::Rgb(level, _, _)) => level,
+ color => panic!("expected interpolated RGB, got {color:?}"),
+ })
+ .collect::<Vec<_>>();
+ frames.push(format!("{theme} {text} {ms}ms: {levels:?}"));
+ }
+ }
+ });
+ }
+ insta::assert_snapshot!(frames.join("\n"));
+}
+
+#[test]
+fn working_has_overlapping_highlights_without_frame_to_frame_flashes() {
+ with_test_default_colors(
+ DefaultColors {
+ fg: (240, 240, 240),
+ bg: (16, 16, 16),
+ },
+ || {
+ let mut previous = Vec::new();
+ for ms in (0..=2000).step_by(/*step*/ 16) {
+ let spans =
+ summary_shimmer("Working", Duration::from_millis(ms), MotionMode::Animated);
+ let brightness = spans
+ .iter()
+ .map(|span| match span.style.fg {
+ Some(ratatui::style::Color::Rgb(r, _, _)) => r,
+ color => panic!("expected interpolated RGB, got {color:?}"),
+ })
+ .collect::<Vec<_>>();
+ if brightness.iter().any(|value| *value > 220) {
+ assert!(brightness.iter().filter(|value| **value > 160).count() >= 2);
+ }
+ for (current, previous) in brightness.iter().zip(&previous) {
+ assert!(u8::abs_diff(*current, *previous) <= 7);
+ }
+ previous = brightness;
+ }
+ let midpoint = summary_shimmer(
+ "Working",
+ Duration::from_secs(/*secs*/ 1),
+ MotionMode::Animated,
+ );
+ let expected = "Working"
+ .chars()
+ .zip([128, 156, 212, 240, 212, 156, 128])
+ .map(|(ch, level)| {
+ Span::styled(
+ ch.to_string(),
+ Style::default().fg(rgb_color((level, level, level))),
+ )
+ })
+ .collect::<Vec<_>>();
+ assert_eq!(midpoint, expected);
+ },
+ );
+}
+
+#[test]
+fn sweep_preserves_combining_characters_and_emoji_clusters() {
+ let text = "e\u{301}👨‍👩‍👧‍👦界";
+ let spans = with_test_default_colors(
+ DefaultColors {
+ fg: (240, 240, 240),
+ bg: (16, 16, 16),
+ },
+ || summary_shimmer(text, Duration::ZERO, MotionMode::Animated),
+ );
+ assert_eq!(
+ spans
+ .iter()
+ .map(|span| span.content.as_ref())
+ .collect::<Vec<_>>(),
+ vec!["e\u{301}", "👨‍👩‍👧‍👦", "界"]
+ );
+ assert_eq!(
+ summary_shimmer(text, Duration::from_secs(/*secs*/ 1), MotionMode::Reduced),
+ vec![Span::from(text.to_owned())]
+ );
+}