Lightweight coding agent that runs in your terminal
Rust
Add voice mute shortcut and recording activity indicators (#43651)
Benjamin Carlsson4b0d9669cc46
diff --git a/codex-rs/tui/src/chatwidget.rs b/codex-rs/tui/src/chatwidget.rsindex 7ee4b88baf..cb8ff353e0 100644--- a/codex-rs/tui/src/chatwidget.rs+++ b/codex-rs/tui/src/chatwidget.rs@@ -408,6 +408,7 @@ mod reset_credits;pub(crate) use self::rate_limits::limit_label_for_window;mod completion;mod realtime;+mod realtime_split_flap;pub(crate) use realtime::MAX_REPLAY_TRANSCRIPT_CELLS;pub(crate) use realtime::MAX_TRANSCRIPT_BYTES;pub(crate) use realtime::RealtimeTranscriptRecord;diff --git a/codex-rs/tui/src/chatwidget/interaction.rs b/codex-rs/tui/src/chatwidget/interaction.rsindex e669e135be..959a5771d3 100644--- a/codex-rs/tui/src/chatwidget/interaction.rs+++ b/codex-rs/tui/src/chatwidget/interaction.rs@@ -60,6 +60,10 @@ impl ChatWidget {return;}+ if self.handle_realtime_microphone_shortcut(key_event) {+ return;+ }+match key_event {KeyEvent {code: KeyCode::Char(c),diff --git a/codex-rs/tui/src/chatwidget/realtime.rs b/codex-rs/tui/src/chatwidget/realtime.rsindex c37a4e2565..48beb9ec90 100644--- a/codex-rs/tui/src/chatwidget/realtime.rs+++ b/codex-rs/tui/src/chatwidget/realtime.rs@@ -1,12 +1,16 @@//! TUI orchestration for an app-server-signaled, locally owned WebRTC voice session.//! Completed captions and both speakers' partials stay bounded across widget replacement.+mod recording_controls;+use super::ChatWidget;use super::HistoryCell;use super::PARENT_OWNED_INPUT_MESSAGE;+use super::realtime_split_flap::VoiceAmplitudeHistory;use crate::app_command::AppCommand;use crate::app_event::AppEvent;use crate::history_cell;+use crate::key_hint;use codex_app_server_protocol::ThreadItem;use codex_app_server_protocol::UserInput;use codex_features::Feature;@@ -15,6 +19,9 @@ use codex_protocol::models::MessagePhase;use codex_realtime_webrtc::RealtimeWebrtcSession;use codex_realtime_webrtc::RealtimeWebrtcSessionHandle;use codex_realtime_webrtc::StartedRealtimeWebrtcSession;+use crossterm::event::KeyCode;+use crossterm::event::KeyEvent;+use crossterm::event::KeyEventKind;use futures::future::AbortHandle;use std::collections::HashMap;use std::collections::VecDeque;@@ -42,8 +49,11 @@ const MAX_SPEAKABLE_FINAL_TOKENS: usize = 990;const AUDIO_METER_SEGMENTS: usize = 5;const AUDIO_METER_NOISE_FLOOR: u16 = 512;const AUDIO_METER_FULL_SCALE: u16 = 8192;+const MAX_REALTIME_AUDIO_METER_FRAMES: usize = 24;const MICROPHONE_METER_INTERVAL: Duration = Duration::from_millis(100);const SPEAKER_ACTIVITY_HOLD: Duration = Duration::from_millis(500);+const INTERRUPTION_ACKNOWLEDGMENT: Duration = Duration::from_millis(400);+const REALTIME_MICROPHONE_SHORTCUT: key_hint::KeyBinding = key_hint::ctrl(KeyCode::Char('x'));static NEXT_REALTIME_ATTEMPT_ID: AtomicU64 = AtomicU64::new(1);static NEXT_REALTIME_SPEECH_DELIVERY_ID: AtomicU64 = AtomicU64::new(1);@@ -128,7 +138,11 @@ pub(super) struct RealtimeConversationUiState {microphone_muted: bool,microphone_level: usize,speaker_level: usize,+ microphone_history: VoiceAmplitudeHistory,+ speaker_history: VoiceAmplitudeHistory,+ audio_meter_history: VecDeque<(VoiceAmplitudeHistory, VoiceAmplitudeHistory)>,speaker_active_until: Option<Instant>,+ interruption_acknowledged_until: Option<Instant>,speaker_suppression_generation: Option<u64>,transcript_role: Option<String>,transcript: String,@@ -301,6 +315,7 @@ impl ChatWidget {if let Some(handle) = self.realtime_conversation.handle.take() {handle.close();self.realtime_conversation.phase = RealtimeConversationPhase::Stopping;+ self.refresh_terminal_title();self.set_footer_hint_override(/*items*/ None);let Some(thread_id) = self.realtime_conversation.thread_id else {self.reset_realtime_conversation();@@ -317,23 +332,6 @@ impl ChatWidget {self.request_redraw();}- pub(super) fn toggle_realtime_microphone(&mut self) {- let muted = !self.realtime_conversation.microphone_muted;- if let Some(handle) = self.realtime_conversation.handle.as_ref() {- if let Err(error) = handle.set_microphone_muted(muted) {- self.on_realtime_error(format!("Failed to update microphone: {error}"));- return;- }- } else if self.realtime_conversation.phase != RealtimeConversationPhase::Starting {- self.add_error_message("Start voice mode before muting the microphone.".to_string());- return;- }-- self.realtime_conversation.microphone_muted = muted;- self.realtime_conversation.microphone_level = 0;- self.update_realtime_footer();- }-pub(crate) fn on_realtime_webrtc_offer_created(&mut self,thread_id: ThreadId,@@ -365,6 +363,8 @@ impl ChatWidget {return;}self.realtime_conversation.handle = Some(offer.handle);+ self.update_realtime_footer();+ self.refresh_terminal_title();self.frame_requester.schedule_frame_in(MICROPHONE_METER_INTERVAL);if !self.submit_op(AppCommand::RealtimeConversationStart {@@ -425,6 +425,7 @@ impl ChatWidget {}self.realtime_conversation.phase = RealtimeConversationPhase::Stopping;self.realtime_conversation.startup_retry = StartupRetry::WaitingForStop;+ self.refresh_terminal_title();if !self.submit_op(AppCommand::RealtimeConversationStop { thread_id }) {self.reset_realtime_conversation();} else {@@ -536,37 +537,6 @@ impl ChatWidget {}}- fn release_realtime_speaker(&mut self) {- self.realtime_conversation.speaker_suppression_generation = None;- if let Some(handle) = self.realtime_conversation.handle.as_ref() {- handle.set_speaker_suppressed(/*suppressed*/ false);- }- }-- fn suppress_realtime_speaker(&mut self) {- self.realtime_conversation.speaker_suppression_generation =- Some(self.realtime_conversation.input_generation);- if let Some(handle) = self.realtime_conversation.handle.as_ref() {- handle.set_speaker_suppressed(/*suppressed*/ true);- }- self.realtime_conversation.speaker_level = 0;- self.realtime_conversation.speaker_active_until = None;- self.update_realtime_footer();- }-- fn resume_realtime_speaker_for(&mut self, role: &str, text: &str) {- if role == "assistant"- && !text.trim().is_empty()- && self.realtime_conversation.assistant_transcript_generation- == Some(self.realtime_conversation.input_generation)- && self.realtime_conversation.latest_input_was_voice- && self.realtime_conversation.speaker_suppression_generation- == Some(self.realtime_conversation.input_generation)- {- self.release_realtime_speaker();- }- }-pub(super) fn note_realtime_user_item_started(&mut self, turn_id: &str, items: &[UserInput]) {if !matches!(self.realtime_conversation.phase,@@ -1193,12 +1163,24 @@ impl ChatWidget {.transcript_input_generation.is_none(){+ let interrupted = self.realtime_conversation.phase == RealtimeConversationPhase::Active+ && !self.realtime_conversation.microphone_muted+ && !delta.trim().is_empty()+ && (self.realtime_conversation.speaker_level > 0+ || self+ .realtime_conversation+ .speaker_active_until+ .is_some_and(|deadline| deadline > Instant::now()));self.realtime_conversation.input_generation = self.realtime_conversation.input_generation.wrapping_add(/*rhs*/ 1);self.realtime_conversation.transcript_input_generation =Some(self.realtime_conversation.input_generation);+ if interrupted && self.config.animations {+ self.realtime_conversation.interruption_acknowledged_until =+ Some(Instant::now() + INTERRUPTION_ACKNOWLEDGMENT);+ }self.suppress_realtime_speaker();}if active@@ -1593,6 +1575,9 @@ impl ChatWidget {}pub(crate) fn reset_realtime_conversation(&mut self) -> Option<ThreadId> {+ let should_refresh_terminal_title = self.realtime_conversation.phase+ != RealtimeConversationPhase::Inactive+ && self.last_terminal_title.is_some();self.restore_all_undelivered_realtime_speech();// A delegated item is hidden until the turn completes so it can be spoken.// If voice ends first, let the later turn completion render it normally.@@ -1684,102 +1669,9 @@ impl ChatWidget {}self.set_footer_hint_override(/*items*/ None);self.flush_realtime_transcript_history();- backend_thread_id- }-- pub(super) fn refresh_realtime_microphone_level(&mut self) {- if !matches!(- self.realtime_conversation.phase,- RealtimeConversationPhase::Starting | RealtimeConversationPhase::Active- ) {- return;- }- let Some(handle) = self.realtime_conversation.handle.as_ref() else {- return;- };- if let Some(error) = handle.take_error() {- self.on_realtime_error(format!("Voice conversation failed: {error}"));- return;- }- if self.realtime_conversation.phase == RealtimeConversationPhase::Starting {- self.frame_requester- .schedule_frame_in(MICROPHONE_METER_INTERVAL);- return;- }- let microphone_level = if self.realtime_conversation.microphone_muted {- 0- } else {- audio_meter_level(handle.take_microphone_peak())- };- let speaker_level = audio_meter_level(handle.take_speaker_peak());- let mut changed = self.realtime_conversation.microphone_level != microphone_level- || self.realtime_conversation.speaker_level != speaker_level;- if speaker_level > 0 {- self.realtime_conversation.speaker_active_until =- Some(Instant::now() + SPEAKER_ACTIVITY_HOLD);- } else {- changed |= self- .realtime_conversation- .speaker_active_until- .take_if(|deadline| *deadline <= Instant::now())- .is_some();- }- self.realtime_conversation.microphone_level = microphone_level;- self.realtime_conversation.speaker_level = speaker_level;- if changed {- self.update_realtime_footer();- }- self.frame_requester- .schedule_frame_in(MICROPHONE_METER_INTERVAL);- }-- fn update_realtime_footer(&mut self) {- let status = if self.realtime_conversation.phase == RealtimeConversationPhase::Starting {- "◌ connecting"- } else if self.realtime_conversation.microphone_muted {- "◌ muted"- } else if self.realtime_conversation.speaker_level > 0- || self- .realtime_conversation- .speaker_active_until- .is_some_and(|deadline| deadline > Instant::now())- {- "● speaking"- } else {- "● listening"- };- let mut hints = vec![- ("voice".to_string(), status.to_string()),- ("/voice".to_string(), "stop".to_string()),- ];- if self.realtime_conversation.phase == RealtimeConversationPhase::Active {- let microphone = if self.realtime_conversation.microphone_muted {- "off".to_string()- } else {- audio_meter_bar(self.realtime_conversation.microphone_level)- };- let speaker = audio_meter_bar(self.realtime_conversation.speaker_level);- hints.push(("mic".to_string(), format!("{microphone} codex {speaker}")));+ if should_refresh_terminal_title {+ self.refresh_terminal_title();}- hints.push(("/voice".to_string(), "mute".to_string()));- self.set_footer_hint_override(Some(hints));+ backend_thread_id}}--fn audio_meter_level(peak: u16) -> usize {- usize::from(peak.saturating_sub(AUDIO_METER_NOISE_FLOOR))- .saturating_mul(AUDIO_METER_SEGMENTS)- .div_ceil(usize::from(- AUDIO_METER_FULL_SCALE - AUDIO_METER_NOISE_FLOOR,- ))- .min(AUDIO_METER_SEGMENTS)-}--fn audio_meter_bar(level: usize) -> String {- let level = level.min(AUDIO_METER_SEGMENTS);- format!(- "{}{}",- "█".repeat(level),- "░".repeat(AUDIO_METER_SEGMENTS - level)- )-}diff --git a/codex-rs/tui/src/chatwidget/realtime/recording_controls.rs b/codex-rs/tui/src/chatwidget/realtime/recording_controls.rsnew file mode 100644index 0000000000..d51187bc1a--- /dev/null+++ b/codex-rs/tui/src/chatwidget/realtime/recording_controls.rs@@ -0,0 +1,223 @@+//! Live voice capture controls, activity meters, and interruption presentation.+//! Meter samples remain bounded and the current thread owns every shortcut.++use super::*;++impl ChatWidget {+ pub(in crate::chatwidget) fn toggle_realtime_microphone(&mut self) {+ let muted = !self.realtime_conversation.microphone_muted;+ if let Some(handle) = self.realtime_conversation.handle.as_ref() {+ if let Err(error) = handle.set_microphone_muted(muted) {+ self.on_realtime_error(format!("Failed to update microphone: {error}"));+ return;+ }+ } else if self.realtime_conversation.phase != RealtimeConversationPhase::Starting {+ self.add_error_message("Start voice mode before muting the microphone.".to_string());+ return;+ }++ self.realtime_conversation.microphone_muted = muted;+ self.realtime_conversation.microphone_level = 0;+ if muted {+ self.realtime_conversation.microphone_history = VoiceAmplitudeHistory::default();+ self.realtime_conversation.audio_meter_history.clear();+ self.realtime_conversation.interruption_acknowledged_until = None;+ }+ self.update_realtime_footer();+ self.refresh_terminal_title();+ }++ pub(in crate::chatwidget) fn handle_realtime_microphone_shortcut(+ &mut self,+ key_event: KeyEvent,+ ) -> bool {+ if key_event.kind != KeyEventKind::Press+ || !REALTIME_MICROPHONE_SHORTCUT.is_press(key_event)+ || self.realtime_conversation.phase != RealtimeConversationPhase::Active+ || self.realtime_conversation.thread_id.is_none()+ || self.realtime_conversation.thread_id != self.thread_id()+ || !self.bottom_pane.no_modal_or_popup_active()+ {+ return false;+ }++ self.toggle_realtime_microphone();+ true+ }++ pub(in crate::chatwidget) fn realtime_microphone_is_listening(&self) -> bool {+ !self.realtime_conversation.microphone_muted+ && self.realtime_conversation.thread_id.is_some()+ && self.realtime_conversation.thread_id == self.thread_id()+ && match self.realtime_conversation.phase {+ RealtimeConversationPhase::Active => true,+ RealtimeConversationPhase::Starting => self.realtime_conversation.handle.is_some(),+ RealtimeConversationPhase::Inactive | RealtimeConversationPhase::Stopping => false,+ }+ }++ pub(super) fn release_realtime_speaker(&mut self) {+ let acknowledged = self+ .realtime_conversation+ .interruption_acknowledged_until+ .take()+ .is_some();+ self.realtime_conversation.speaker_suppression_generation = None;+ if let Some(handle) = self.realtime_conversation.handle.as_ref() {+ handle.set_speaker_suppressed(/*suppressed*/ false);+ }+ if acknowledged {+ self.update_realtime_footer();+ }+ }++ pub(super) fn suppress_realtime_speaker(&mut self) {+ self.realtime_conversation.speaker_suppression_generation =+ Some(self.realtime_conversation.input_generation);+ if let Some(handle) = self.realtime_conversation.handle.as_ref() {+ handle.set_speaker_suppressed(/*suppressed*/ true);+ }+ self.realtime_conversation.speaker_level = 0;+ self.realtime_conversation.speaker_active_until = None;+ self.update_realtime_footer();+ }++ pub(super) fn resume_realtime_speaker_for(&mut self, role: &str, text: &str) {+ if role == "assistant"+ && !text.trim().is_empty()+ && self.realtime_conversation.assistant_transcript_generation+ == Some(self.realtime_conversation.input_generation)+ && self.realtime_conversation.latest_input_was_voice+ && self.realtime_conversation.speaker_suppression_generation+ == Some(self.realtime_conversation.input_generation)+ {+ self.release_realtime_speaker();+ }+ }++ pub(in crate::chatwidget) fn refresh_realtime_microphone_level(&mut self) {+ if !matches!(+ self.realtime_conversation.phase,+ RealtimeConversationPhase::Starting | RealtimeConversationPhase::Active+ ) {+ return;+ }+ let Some(handle) = self.realtime_conversation.handle.as_ref() else {+ return;+ };+ if let Some(error) = handle.take_error() {+ self.on_realtime_error(format!("Voice conversation failed: {error}"));+ return;+ }+ if self.realtime_conversation.phase == RealtimeConversationPhase::Starting {+ self.frame_requester+ .schedule_frame_in(MICROPHONE_METER_INTERVAL);+ return;+ }+ let microphone_level = if self.realtime_conversation.microphone_muted {+ 0+ } else {+ audio_meter_level(handle.take_microphone_peak())+ };+ let speaker_level = audio_meter_level(handle.take_speaker_peak());+ let previous_microphone_history = self.realtime_conversation.microphone_history;+ let previous_speaker_history = self.realtime_conversation.speaker_history;+ let mut changed = self.realtime_conversation.microphone_level != microphone_level+ || self.realtime_conversation.speaker_level != speaker_level;+ if speaker_level > 0 {+ self.realtime_conversation.speaker_active_until =+ Some(Instant::now() + SPEAKER_ACTIVITY_HOLD);+ } else {+ changed |= self+ .realtime_conversation+ .speaker_active_until+ .take_if(|deadline| *deadline <= Instant::now())+ .is_some();+ }+ changed |= self+ .realtime_conversation+ .interruption_acknowledged_until+ .take_if(|deadline| *deadline <= Instant::now())+ .is_some();+ self.realtime_conversation.microphone_level = microphone_level;+ self.realtime_conversation.speaker_level = speaker_level;+ self.realtime_conversation+ .microphone_history+ .push(microphone_level);+ self.realtime_conversation+ .speaker_history+ .push(speaker_level);+ if self.realtime_conversation.audio_meter_history.len() >= MAX_REALTIME_AUDIO_METER_FRAMES {+ self.realtime_conversation.audio_meter_history.pop_front();+ }+ self.realtime_conversation.audio_meter_history.push_back((+ self.realtime_conversation.microphone_history,+ self.realtime_conversation.speaker_history,+ ));+ changed |= previous_microphone_history != self.realtime_conversation.microphone_history+ || previous_speaker_history != self.realtime_conversation.speaker_history;+ if changed {+ self.update_realtime_footer();+ }+ self.frame_requester+ .schedule_frame_in(MICROPHONE_METER_INTERVAL);+ }++ pub(super) fn update_realtime_footer(&mut self) {+ let status = if self.realtime_conversation.phase == RealtimeConversationPhase::Starting {+ "◌ connecting"+ } else if self.realtime_conversation.microphone_muted {+ "◌ muted"+ } else if self+ .realtime_conversation+ .interruption_acknowledged_until+ .is_some_and(|deadline| deadline > Instant::now())+ {+ "● heard"+ } else if self.realtime_conversation.speaker_level > 0+ || self+ .realtime_conversation+ .speaker_active_until+ .is_some_and(|deadline| deadline > Instant::now())+ {+ "● speaking"+ } else {+ "● listening"+ };+ let mut hints = vec![+ ("voice".to_string(), status.to_string()),+ ("/voice".to_string(), "stop".to_string()),+ ];+ if self.realtime_conversation.phase == RealtimeConversationPhase::Active {+ let microphone = if self.realtime_conversation.microphone_muted {+ "off".to_string()+ } else {+ audio_meter_braille(self.realtime_conversation.microphone_history)+ };+ let speaker = audio_meter_braille(self.realtime_conversation.speaker_history);+ hints.push(("mic".to_string(), format!("{microphone} codex {speaker}")));+ }+ let mute_shortcut = REALTIME_MICROPHONE_SHORTCUT+ .display_label()+ .replace(" + ", "+");+ hints.push(("/voice".to_string(), format!("mute {mute_shortcut}")));+ self.set_footer_hint_override(Some(hints));+ }+}++pub(super) fn audio_meter_level(peak: u16) -> usize {+ usize::from(peak.saturating_sub(AUDIO_METER_NOISE_FLOOR))+ .saturating_mul(AUDIO_METER_SEGMENTS)+ .div_ceil(usize::from(+ AUDIO_METER_FULL_SCALE - AUDIO_METER_NOISE_FLOOR,+ ))+ .min(AUDIO_METER_SEGMENTS)+}++fn audio_meter_braille(samples: VoiceAmplitudeHistory) -> String {+ if samples.peak() == 0 {+ "⠄⠄".to_string()+ } else {+ samples.glyphs()+ }+}diff --git a/codex-rs/tui/src/chatwidget/realtime/recording_controls_tests.rs b/codex-rs/tui/src/chatwidget/realtime/recording_controls_tests.rsnew file mode 100644index 0000000000..334ddf4e90--- /dev/null+++ b/codex-rs/tui/src/chatwidget/realtime/recording_controls_tests.rs@@ -0,0 +1,412 @@+//! Rendering and key routing regressions for live recording controls.++use super::*;+use crossterm::event::KeyCode;+use crossterm::event::KeyEvent;+use crossterm::event::KeyEventKind;+use crossterm::event::KeyModifiers;+use pretty_assertions::assert_eq;++#[tokio::test]+async fn voice_mute_shortcut_only_handles_active_current_thread_presses() {+ let (mut chat, _sender, mut events, mut ops) = make_chatwidget_manual_with_sender().await;+ let thread_id = activate_voice(&mut chat);+ let shortcut = KeyEvent::new(KeyCode::Char('x'), KeyModifiers::CONTROL);++ assert!(!chat.handle_realtime_microphone_shortcut(KeyEvent::new(+ KeyCode::Char('m'),+ KeyModifiers::CONTROL,+ )));+ for kind in [KeyEventKind::Repeat, KeyEventKind::Release] {+ assert!(!chat.handle_realtime_microphone_shortcut(KeyEvent { kind, ..shortcut }));+ }+ for phase in [+ RealtimeConversationPhase::Inactive,+ RealtimeConversationPhase::Starting,+ RealtimeConversationPhase::Stopping,+ ] {+ chat.realtime_conversation.phase = phase;+ assert!(!chat.handle_realtime_microphone_shortcut(shortcut));+ }+ chat.realtime_conversation.phase = RealtimeConversationPhase::Active;+ chat.thread_id = Some(ThreadId::new());+ assert!(!chat.handle_realtime_microphone_shortcut(shortcut));+ chat.thread_id = Some(thread_id);+ assert!(events.try_recv().is_err());++ assert!(chat.handle_realtime_microphone_shortcut(shortcut));++ let Ok(AppEvent::InsertHistoryCell(cell)) = events.try_recv() else {+ panic!("a missing microphone handle should fail closed with the existing voice error");+ };+ assert!(+ cell.display_lines(/*width*/ 80)+ .iter()+ .any(|line| line.to_string().contains("Start voice mode before muting"))+ );+ assert!(!chat.realtime_conversation.microphone_muted);+ assert!(ops.try_recv().is_err());+}++#[tokio::test]+async fn voice_mute_shortcut_accepts_raw_terminal_control_bytes() {+ let (mut chat, _sender, mut events, mut ops) = make_chatwidget_manual_with_sender().await;+ activate_voice(&mut chat);++ assert!(chat.handle_realtime_microphone_shortcut(KeyEvent::new(+ KeyCode::Char('\u{18}'),+ KeyModifiers::NONE,+ )));+ assert!(events.try_recv().is_ok());+ assert!(!chat.realtime_conversation.microphone_muted);+ assert!(ops.try_recv().is_err());+}++#[tokio::test]+async fn voice_composer_preserves_normal_colors_across_microphone_states() {+ use crate::render::renderable::Renderable;+ use ratatui::prelude::Buffer;+ use ratatui::prelude::Color;+ use ratatui::prelude::Rect;++ let (mut chat, _sender, _events, _ops) = make_chatwidget_manual_with_sender().await;+ let thread_id = activate_voice(&mut chat);+ chat.bottom_pane+ .set_composer_text("typed".to_string(), Vec::new(), Vec::new());+ let check = |chat: &mut ChatWidget, recording| {+ chat.update_realtime_footer();+ let area = Rect::new(+ /*x*/ 0, /*y*/ 0, /*width*/ 24, /*height*/ 4,+ );+ let mut buffer = Buffer::empty(area);+ chat.bottom_pane.render(area, &mut buffer);+ assert_eq!(chat.realtime_microphone_is_listening(), recording);+ assert!(buffer.content.iter().all(|cell| cell.bg != Color::Red));+ buffer+ .content+ .iter()+ .find(|cell| cell.symbol() == "t")+ .unwrap()+ .fg+ };+ let foreground = check(&mut chat, /*recording*/ true);+ chat.config.animations = false;+ assert_eq!(check(&mut chat, /*recording*/ true), foreground);+ chat.realtime_conversation.microphone_muted = true;+ assert_eq!(check(&mut chat, /*recording*/ false), foreground);+ chat.realtime_conversation.microphone_muted = false;+ chat.thread_id = Some(ThreadId::new());+ assert_eq!(check(&mut chat, /*recording*/ false), foreground);+ chat.thread_id = Some(thread_id);+ chat.realtime_conversation.phase = RealtimeConversationPhase::Stopping;+ assert_eq!(check(&mut chat, /*recording*/ false), foreground);+}++#[tokio::test]+async fn voice_preserves_the_normal_composer_prompt() {+ let (mut chat, _sender, _events, _ops) = make_chatwidget_manual_with_sender().await;+ let thread_id = activate_voice(&mut chat);+ let prompt = |chat: &mut ChatWidget| {+ chat.update_realtime_footer();+ render_bottom_popup(chat, /*width*/ 80).chars().next()+ };+ for level in 0..=5 {+ chat.realtime_conversation.microphone_level = level;+ assert_eq!(prompt(&mut chat), Some('›'));+ }+ for (muted, animations) in [(true, true), (false, false), (false, true)] {+ chat.realtime_conversation.microphone_muted = muted;+ chat.config.animations = animations;+ assert_eq!(prompt(&mut chat), Some('›'));+ }+ chat.thread_id = Some(ThreadId::new());+ assert_eq!(prompt(&mut chat), Some('›'));+ chat.thread_id = Some(thread_id);+ chat.bottom_pane+ .set_composer_text("!".to_string(), Vec::new(), Vec::new());+ assert_eq!(prompt(&mut chat), Some('!'));+ chat.bottom_pane+ .handle_key_event(KeyEvent::new(KeyCode::Esc, KeyModifiers::NONE));+ assert_eq!(prompt(&mut chat), Some('›'));+ chat.reset_realtime_conversation();+ assert_eq!(+ render_bottom_popup(&chat, /*width*/ 80).chars().next(),+ Some('›')+ );+}++#[tokio::test]+async fn voice_footer_renders_the_main_conversation_states() {+ let (mut chat, _sender, _events, _ops) = make_chatwidget_manual_with_sender().await;+ activate_voice(&mut chat);+ let mut states = Vec::new();++ for (label, phase, muted, level, speaker_level, role, transcript) in [+ (+ "connecting",+ RealtimeConversationPhase::Starting,+ false,+ 0,+ 0,+ None,+ "",+ ),+ (+ "listening",+ RealtimeConversationPhase::Active,+ false,+ 0,+ 0,+ None,+ "",+ ),+ (+ "speaking",+ RealtimeConversationPhase::Active,+ false,+ 4,+ 5,+ None,+ "",+ ),+ (+ "muted",+ RealtimeConversationPhase::Active,+ true,+ 4,+ 4,+ None,+ "",+ ),+ (+ "transcript",+ RealtimeConversationPhase::Active,+ false,+ 2,+ 2,+ Some("assistant"),+ "Hello there",+ ),+ ] {+ chat.realtime_conversation.phase = phase;+ chat.realtime_conversation.microphone_muted = muted;+ chat.realtime_conversation.microphone_level = level;+ chat.realtime_conversation.speaker_level = speaker_level;+ chat.realtime_conversation.microphone_history =+ super::super::VoiceAmplitudeHistory::default();+ chat.realtime_conversation.speaker_history = super::super::VoiceAmplitudeHistory::default();+ for _ in 0..4 {+ chat.realtime_conversation.microphone_history.push(level);+ chat.realtime_conversation+ .speaker_history+ .push(speaker_level);+ }+ chat.realtime_conversation.transcript_role = role.map(str::to_string);+ chat.realtime_conversation.transcript = transcript.to_string();+ chat.update_realtime_footer();+ states.push(format!(+ "{label}:\n{}",+ render_bottom_popup(&chat, /*width*/ 80)+ ));+ }++ chat.realtime_conversation.speaker_level = 0;+ chat.realtime_conversation.speaker_history = super::super::VoiceAmplitudeHistory::default();+ chat.realtime_conversation.interruption_acknowledged_until =+ Some(std::time::Instant::now() + super::super::INTERRUPTION_ACKNOWLEDGMENT);+ chat.update_realtime_footer();+ states.push(format!(+ "interrupted:\n{}",+ render_bottom_popup(&chat, /*width*/ 80)+ ));++ insta::assert_snapshot!(states.join("\n\n"));+}++#[tokio::test]+async fn narrow_voice_footer_keeps_the_stop_control_before_meters() {+ let (mut chat, _sender, _events, _ops) = make_chatwidget_manual_with_sender().await;+ chat.config.animations = true;+ activate_voice(&mut chat);+ chat.realtime_conversation.speaker_active_until =+ Some(std::time::Instant::now() + super::super::SPEAKER_ACTIVITY_HOLD);+ chat.update_realtime_footer();++ let footer = render_bottom_popup(&chat, /*width*/ 45);+ assert!(footer.contains("voice ● speaking"));+ assert!(footer.contains("/voice stop"));+ chat.realtime_conversation.speaker_active_until = None;+ chat.realtime_conversation.speaker_level = 1;+ chat.on_realtime_transcript_delta("user".to_string(), "stop".to_string());+ assert_eq!(chat.realtime_conversation.speaker_level, 0);+ assert_eq!(chat.realtime_conversation.speaker_active_until, None);+ let interrupted = render_bottom_popup(&chat, /*width*/ 45);+ assert!(interrupted.contains("voice ● heard"));+ assert!(interrupted.contains("/voice stop"));+ chat.realtime_conversation.interruption_acknowledged_until =+ Some(std::time::Instant::now() - super::super::INTERRUPTION_ACKNOWLEDGMENT);+ chat.realtime_conversation.speaker_active_until =+ Some(std::time::Instant::now() - super::super::SPEAKER_ACTIVITY_HOLD);+ chat.update_realtime_footer();+ assert!(render_bottom_popup(&chat, /*width*/ 45).contains("voice ● listening"));+ for (peak, expected) in [+ (0, 0),+ (1, 0),+ (511, 0),+ (512, 0),+ (513, 1),+ (4096, 3),+ (6144, 4),+ (6656, 4),+ (6657, 5),+ (8192, 5),+ (32768, 5),+ (u16::MAX, 5),+ ] {+ assert_eq!(+ super::super::recording_controls::audio_meter_level(peak),+ expected+ );+ }+}++#[tokio::test]+async fn voice_acknowledges_only_a_real_interruption_once() {+ let (mut chat, _sender, _events, _ops) = make_chatwidget_manual_with_sender().await;+ chat.config.animations = true;+ activate_voice(&mut chat);++ chat.on_realtime_transcript_delta("user".to_string(), "hello".to_string());+ assert!(+ chat.realtime_conversation+ .interruption_acknowledged_until+ .is_none()+ );+ chat.on_realtime_transcript_done("user".to_string(), "hello".to_string());+ chat.on_realtime_transcript_delta("assistant".to_string(), "speaking".to_string());+ chat.realtime_conversation.speaker_level = 3;+ chat.on_realtime_transcript_delta("user".to_string(), "wait".to_string());+ let acknowledged = chat.realtime_conversation.interruption_acknowledged_until;+ assert!(acknowledged.is_some());+ chat.on_realtime_transcript_delta("user".to_string(), " please".to_string());+ assert_eq!(+ chat.realtime_conversation.interruption_acknowledged_until,+ acknowledged+ );+ chat.on_realtime_transcript_done("user".to_string(), "wait please".to_string());+ chat.on_realtime_transcript_done("assistant".to_string(), "speaking".to_string());+ chat.on_realtime_transcript_delta("assistant".to_string(), "sure".to_string());+ assert!(+ chat.realtime_conversation+ .interruption_acknowledged_until+ .is_none()+ );++ chat.config.animations = false;+ chat.realtime_conversation.speaker_level = 3;+ chat.on_realtime_transcript_delta("user".to_string(), "stop".to_string());+ assert!(+ chat.realtime_conversation+ .interruption_acknowledged_until+ .is_none()+ );+}++#[tokio::test]+async fn voice_terminal_title_tracks_capture_activity_and_user_settings() {+ let (mut chat, _sender, _events, _ops) = make_chatwidget_manual_with_sender().await;+ let thread_id = activate_voice(&mut chat);+ chat.local_settings.tui.animations = false;+ let check = |chat: &mut ChatWidget, expected: &str| {+ chat.refresh_terminal_title();+ assert_eq!(chat.last_terminal_title.as_deref(), Some(expected));+ };+ check(&mut chat, "● project");+ chat.bottom_pane.set_task_running(/*running*/ true);+ chat.local_settings.tui.animations = true;+ chat.refresh_terminal_title();+ assert!(chat.last_terminal_title.as_deref().is_some_and(|title| {+ title.starts_with("● ") && title.ends_with(" project") && title != "● project"+ }));+ chat.local_settings.tui.animations = false;+ check(&mut chat, "● project");+ chat.local_settings.tui.terminal_title = Some(vec!["project-name".to_string()]);+ check(&mut chat, "project");+ chat.local_settings.tui.terminal_title = None;+ use RealtimeConversationPhase as Phase;+ for phase in [Phase::Starting, Phase::Stopping, Phase::Inactive] {+ chat.realtime_conversation.phase = phase;+ check(&mut chat, "project");+ }+ chat.realtime_conversation.phase = RealtimeConversationPhase::Active;+ chat.realtime_conversation.microphone_muted = true;+ check(&mut chat, "project");+ chat.realtime_conversation.microphone_muted = false;+ chat.thread_id = Some(ThreadId::new());+ check(&mut chat, "project");+ chat.thread_id = Some(thread_id);+ check(&mut chat, "● project");+ chat.reset_realtime_conversation();+ assert_eq!(chat.last_terminal_title.as_deref(), Some("project"));+ activate_voice(&mut chat);+ check(&mut chat, "● project");+ chat.clear_managed_terminal_title().expect("title clears");+ chat.reset_realtime_conversation();+ assert!(chat.last_terminal_title.is_none());+}++#[tokio::test]+async fn stopping_voice_clears_recording_title_without_restoring_cleared_titles() {+ for (thread_title, clear_title) in [(true, false), (false, false), (true, true)] {+ let (mut chat, _sender, _events, _ops) = make_chatwidget_manual_with_sender().await;+ chat.local_settings.tui.animations = false;+ chat.thread_name = Some("voice session".to_string());+ let mut items = vec!["activity".to_string()];+ if thread_title {+ items.push("thread-title".to_string());+ }+ chat.local_settings.tui.terminal_title = Some(items);+ activate_voice(&mut chat);+ chat.refresh_terminal_title();+ let recording = if thread_title {+ "● voice session"+ } else {+ "●"+ };+ assert_eq!(chat.last_terminal_title.as_deref(), Some(recording));+ if clear_title {+ chat.clear_managed_terminal_title().expect("title clears");+ }+ chat.realtime_conversation.phase = RealtimeConversationPhase::Stopping;+ chat.on_realtime_conversation_closed(/*reason*/ Some("requested".into()));+ assert_eq!(+ chat.last_terminal_title.as_deref(),+ (thread_title && !clear_title).then_some("voice session")+ );+ }+}++#[tokio::test]+async fn startup_timeout_clears_recording_title_before_backend_closes() {+ let (mut chat, _sender, _events, mut ops) = make_chatwidget_manual_with_sender().await;+ activate_voice(&mut chat);+ chat.local_settings.tui.animations = false;+ chat.refresh_terminal_title();+ assert_eq!(chat.last_terminal_title.as_deref(), Some("● project"));++ chat.realtime_conversation.phase = RealtimeConversationPhase::Starting;+ chat.on_realtime_webrtc_connected(+ /*attempt_id*/ chat.realtime_conversation.attempt_id,+ Err(codex_realtime_webrtc::ConnectionError::NegotiationTimedOut),+ );++ assert!(matches!(+ ops.try_recv(),+ Ok(AppCommand::RealtimeConversationStop { .. })+ ));+ assert_eq!(+ chat.realtime_conversation.phase,+ RealtimeConversationPhase::Stopping+ );+ assert_eq!(chat.last_terminal_title.as_deref(), Some("project"));+}diff --git a/codex-rs/tui/src/chatwidget/realtime/snapshots/codex_tui__chatwidget__realtime__tests__recording_controls_tests__voice_footer_renders_the_main_conversation_states.snap b/codex-rs/tui/src/chatwidget/realtime/snapshots/codex_tui__chatwidget__realtime__tests__recording_controls_tests__voice_footer_renders_the_main_conversation_states.snapnew file mode 100644index 0000000000..9da849000d--- /dev/null+++ b/codex-rs/tui/src/chatwidget/realtime/snapshots/codex_tui__chatwidget__realtime__tests__recording_controls_tests__voice_footer_renders_the_main_conversation_states.snap@@ -0,0 +1,33 @@+---+source: tui/src/chatwidget/realtime/recording_controls_tests.rs+expression: "states.join(\"\\n\\n\")"+---+connecting:+› Ask Codex to do anything++ voice ◌ connecting /voice stop /voice mute ctrl+x++listening:+› Ask Codex to do anything++ voice ● listening /voice stop mic ⠄⠄ codex ⠄⠄ /voice mute ctrl+x++speaking:+› Ask Codex to do anything++ voice ● speaking /voice stop mic ⣿⣿ codex ⣿⣿ /voice mute ctrl+x++muted:+› Ask Codex to do anything++ voice ◌ muted /voice stop mic off codex ⣿⣿ /voice mute ctrl+x++transcript:+› Ask Codex to do anything++ voice ● speaking /voice stop mic ⣤⣤ codex ⣤⣤ /voice mute ctrl+x++interrupted:+› Ask Codex to do anything++ voice ● heard /voice stop mic ⣤⣤ codex ⠄⠄ /voice mute ctrl+xdiff --git a/codex-rs/tui/src/chatwidget/realtime_split_flap.rs b/codex-rs/tui/src/chatwidget/realtime_split_flap.rsnew file mode 100644index 0000000000..cff8ef47a9--- /dev/null+++ b/codex-rs/tui/src/chatwidget/realtime_split_flap.rs@@ -0,0 +1,33 @@+//! Bounded real amplitude histories for voice recording controls.++#[cfg(test)]+#[path = "realtime_split_flap_tests.rs"]+mod tests;++/// Four bounded, calibrated amplitude samples; this is not frequency analysis.+#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]+pub(super) struct VoiceAmplitudeHistory([usize; 4]);++impl VoiceAmplitudeHistory {+ pub(super) fn push(&mut self, level: usize) {+ self.0.rotate_left(/*mid*/ 1);+ self.0[3] = level.min(/*other*/ 5);+ }++ pub(super) fn glyphs(&self) -> String {+ const LEFT_DOTS: [u32; 6] = [0, 0x40, 0x44, 0x46, 0x47, 0x47];+ const RIGHT_DOTS: [u32; 6] = [0, 0x80, 0xa0, 0xb0, 0xb8, 0xb8];++ self.0+ .chunks_exact(/*chunk_size*/ 2)+ .map(|levels| {+ char::from_u32(0x2800 | LEFT_DOTS[levels[0]] | RIGHT_DOTS[levels[1]])+ .unwrap_or('\u{2800}')+ })+ .collect()+ }++ pub(super) fn peak(&self) -> usize {+ self.0.iter().copied().max().unwrap_or_default()+ }+}diff --git a/codex-rs/tui/src/chatwidget/realtime_split_flap_tests.rs b/codex-rs/tui/src/chatwidget/realtime_split_flap_tests.rsnew file mode 100644index 0000000000..1214e12b54--- /dev/null+++ b/codex-rs/tui/src/chatwidget/realtime_split_flap_tests.rs@@ -0,0 +1,13 @@+//! Regressions for bounded state used by realtime voice presentation.+//! Retained history must preserve ordering without growing beyond its limits.++use super::VoiceAmplitudeHistory;+use pretty_assertions::assert_eq;++#[test]+fn voice_meter_shows_four_real_amplitude_samples_in_two_braille_cells() {+ let samples = VoiceAmplitudeHistory([1, 4, 2, 5]);+ insta::assert_snapshot!(samples.glyphs(), @"⣸⣼");+ assert_eq!(samples.peak(), 5);+ assert_eq!(VoiceAmplitudeHistory::default().peak(), 0);+}diff --git a/codex-rs/tui/src/chatwidget/realtime_tests.rs b/codex-rs/tui/src/chatwidget/realtime_tests.rsindex 4df28cfe83..8c02ea7f6d 100644--- a/codex-rs/tui/src/chatwidget/realtime_tests.rs+++ b/codex-rs/tui/src/chatwidget/realtime_tests.rs@@ -1,6 +1,9 @@//! Regression coverage for thread-owned voice sessions and transcript/handoff safety.//! Synthetic events preserve typed turns and reject stale session generations.+#[path = "realtime/recording_controls_tests.rs"]+mod recording_controls_tests;+use super::RealtimeConversationPhase;use crate::app_command::AppCommand;use crate::app_event::AppEvent;diff --git a/codex-rs/tui/src/chatwidget/realtime_tests/lifecycle.rs b/codex-rs/tui/src/chatwidget/realtime_tests/lifecycle.rsindex 0b3ef3a0d4..fe39a83754 100644--- a/codex-rs/tui/src/chatwidget/realtime_tests/lifecycle.rs+++ b/codex-rs/tui/src/chatwidget/realtime_tests/lifecycle.rs@@ -80,114 +80,6 @@ async fn voice_cannot_start_on_a_parent_owned_thread() {));}-#[tokio::test]-async fn voice_footer_renders_the_main_conversation_states() {- let (mut chat, _sender, _events, _ops) = make_chatwidget_manual_with_sender().await;- let mut states = Vec::new();-- for (label, phase, muted, level, speaker_level, role, transcript) in [- (- "connecting",- RealtimeConversationPhase::Starting,- false,- 0,- 0,- None,- "",- ),- (- "listening",- RealtimeConversationPhase::Active,- false,- 0,- 0,- None,- "",- ),- (- "speaking",- RealtimeConversationPhase::Active,- false,- 4,- 5,- None,- "",- ),- (- "muted",- RealtimeConversationPhase::Active,- true,- 4,- 4,- None,- "",- ),- (- "transcript",- RealtimeConversationPhase::Active,- false,- 2,- 2,- Some("assistant"),- "Hello there",- ),- ] {- chat.realtime_conversation.phase = phase;- chat.realtime_conversation.microphone_muted = muted;- chat.realtime_conversation.microphone_level = level;- chat.realtime_conversation.speaker_level = speaker_level;- chat.realtime_conversation.transcript_role = role.map(str::to_string);- chat.realtime_conversation.transcript = transcript.to_string();- chat.update_realtime_footer();- states.push(format!(- "{label}:\n{}",- render_bottom_popup(&chat, /*width*/ 80)- ));- }-- insta::assert_snapshot!(states.join("\n\n"));-}--#[tokio::test]-async fn narrow_voice_footer_keeps_the_stop_control_before_meters() {- let (mut chat, _sender, _events, _ops) = make_chatwidget_manual_with_sender().await;- activate_voice(&mut chat);- chat.realtime_conversation.speaker_active_until =- Some(std::time::Instant::now() + super::super::SPEAKER_ACTIVITY_HOLD);- chat.update_realtime_footer();-- let footer = render_bottom_popup(&chat, /*width*/ 45);- assert!(footer.contains("voice ● speaking"));- assert!(footer.contains("/voice stop"));- chat.realtime_conversation.speaker_active_until = None;- chat.realtime_conversation.speaker_level = 1;- chat.on_realtime_transcript_delta("user".to_string(), "stop".to_string());- assert_eq!(chat.realtime_conversation.speaker_level, 0);- assert_eq!(chat.realtime_conversation.speaker_active_until, None);- chat.realtime_conversation.speaker_active_until =- Some(std::time::Instant::now() - super::super::SPEAKER_ACTIVITY_HOLD);- chat.update_realtime_footer();- assert!(render_bottom_popup(&chat, /*width*/ 45).contains("voice ● listening"));- for (peak, expected) in [- (0, 0),- (1, 0),- (511, 0),- (512, 0),- (513, 1),- (4096, 3),- (6144, 4),- (6656, 4),- (6657, 5),- (8192, 5),- (32768, 5),- (u16::MAX, 5),- ] {- assert_eq!(super::super::audio_meter_level(peak), expected);- }- assert_eq!(super::super::audio_meter_bar(/*level*/ 0), "░░░░░");- assert_eq!(super::super::audio_meter_bar(/*level*/ 5), "█████");-}-#[tokio::test]async fn stopping_while_the_offer_is_pending_resets_the_session() {let (mut chat, _sender, _events, mut ops) = make_chatwidget_manual_with_sender().await;diff --git a/codex-rs/tui/src/chatwidget/realtime_tests/snapshots/codex_tui__chatwidget__realtime__tests__lifecycle__voice_footer_renders_the_main_conversation_states.snap b/codex-rs/tui/src/chatwidget/realtime_tests/snapshots/codex_tui__chatwidget__realtime__tests__lifecycle__voice_footer_renders_the_main_conversation_states.snapdeleted file mode 100644index 6960dba6f1..0000000000--- a/codex-rs/tui/src/chatwidget/realtime_tests/snapshots/codex_tui__chatwidget__realtime__tests__lifecycle__voice_footer_renders_the_main_conversation_states.snap+++ /dev/null@@ -1,29 +0,0 @@-----source: tui/src/chatwidget/realtime_tests/lifecycle.rs-assertion_line: 176-expression: "states.join(\"\\n\\n\")"-----connecting:-› Ask Codex to do anything-- voice ◌ connecting /voice stop /voice mute--listening:-› Ask Codex to do anything-- voice ● listening /voice stop mic ░░░░░ codex ░░░░░ /voice mute--speaking:-› Ask Codex to do anything-- voice ● speaking /voice stop mic ████░ codex █████ /voice mute--muted:-› Ask Codex to do anything-- voice ◌ muted /voice stop mic off codex ████░ /voice mute--transcript:-› Ask Codex to do anything-- voice ● speaking /voice stop mic ██░░░ codex ██░░░ /voice mutediff --git a/codex-rs/tui/src/chatwidget/snapshots/codex_tui__chatwidget__tests__voice_live_transcript_and_stream.snap b/codex-rs/tui/src/chatwidget/snapshots/codex_tui__chatwidget__tests__voice_live_transcript_and_stream.snapindex 61937b7844..6ce009e557 100644--- a/codex-rs/tui/src/chatwidget/snapshots/codex_tui__chatwidget__tests__voice_live_transcript_and_stream.snap+++ b/codex-rs/tui/src/chatwidget/snapshots/codex_tui__chatwidget__tests__voice_live_transcript_and_stream.snap@@ -13,4 +13,4 @@ expression: rendered" ""› Ask Codex to do anything "" "-" voice ● listening /voice stop mic ░░░░░ codex ░░░░░ "+" voice ● listening /voice stop mic ⠄⠄ codex ⠄⠄ /voi"diff --git a/codex-rs/tui/src/chatwidget/status_surfaces.rs b/codex-rs/tui/src/chatwidget/status_surfaces.rsindex 17f437c488..1059d7886d 100644--- a/codex-rs/tui/src/chatwidget/status_surfaces.rs+++ b/codex-rs/tui/src/chatwidget/status_surfaces.rs@@ -327,7 +327,12 @@ impl ChatWidget {now: Instant,) -> Option<String> {if self.terminal_title_shows_action_required_with_selections(selections) {- return Some(self.action_required_terminal_title_text(selections, now));+ let title = self.action_required_terminal_title_text(selections, now);+ return Some(if self.realtime_microphone_is_listening() {+ format!("● {title}")+ } else {+ title+ });}let mut previous = None;@@ -1001,15 +1006,17 @@ impl ChatWidget {}pub(super) fn terminal_title_spinner_text_at(&self, now: Instant) -> Option<String> {- if !self.local_settings.tui.animations {- return None;- }-- if !self.terminal_title_has_active_progress() {- return None;+ let spinner = (self.local_settings.tui.animations+ && self.terminal_title_has_active_progress())+ .then(|| self.terminal_title_spinner_frame_at(now));+ if self.realtime_microphone_is_listening() {+ return Some(match spinner {+ Some(frame) => format!("● {frame}"),+ None => "●".to_string(),+ });}- Some(self.terminal_title_spinner_frame_at(now).to_string())+ spinner.map(str::to_string)}pub(super) fn terminal_title_spinner_frame_at(&self, now: Instant) -> &'static str {