Skip to content

armgit / codex

Public Imported from GitHub
0

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.rs
index 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.rs
index 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.rs
index 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.rs
new file mode 100644
index 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.rs
new file mode 100644
index 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.snap
new file mode 100644
index 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+x
diff --git a/codex-rs/tui/src/chatwidget/realtime_split_flap.rs b/codex-rs/tui/src/chatwidget/realtime_split_flap.rs
new file mode 100644
index 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.rs
new file mode 100644
index 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.rs
index 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.rs
index 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.snap
deleted file mode 100644
index 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 mute
diff --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.snap
index 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.rs
index 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 {