fix(core): commit PttTrayState + PttTranslated plumbing

These were referenced by already-committed voice_ptt.rs / voice.rs code
but the enum + trait method + event variant lived only in local working
tree, breaking every CI build for v2.0.0-beta.2.

- platform.rs: add PttTrayState {Idle, Recording, Processing, NoteMode}
  and default Platform::set_ptt_tray_state() trait method.
- voice_otoji.rs: parse ptt_translated events + forward to
  PttSession::on_ptt_translated. Enable translation args
  (--ptt-translate-to / --ptt-tts-source) when the CLX_TRANSLATE_*
  env vars are set. Wire polish=openai (→ Cloudflare) + tts=gemini.
- voice_ptt.rs: instrumentation logs in start_spinner and
  replace_displayed to diagnose the reported "spinner slows with
  long utterances" bug.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: snomiao

rs/core/src/modules/voice_otoji.rs

@@ -24,6 +24,7 @@ enum AsrEvent {
     PttPartial { text: String },
     PttFinal { text: String },
     PttUpgrade { text: String },
+    PttTranslated { text: String, lang: String },
     Other,
 }
 
@@ -45,9 +46,13 @@ fn parse_event(line: &str) -> AsrEvent {
         "final"   => AsrEvent::Final   { text: get("text").unwrap_or_default() },
         "status"      => AsrEvent::Status      { message: get("message").unwrap_or_default() },
         "error"       => AsrEvent::Error       { message: get("message").unwrap_or_default() },
-        "ptt_partial" => AsrEvent::PttPartial  { text: get("text").unwrap_or_default() },
-        "ptt_final"   => AsrEvent::PttFinal    { text: get("text").unwrap_or_default() },
-        "ptt_upgrade" => AsrEvent::PttUpgrade  { text: get("text").unwrap_or_default() },
+        "ptt_partial"    => AsrEvent::PttPartial    { text: get("text").unwrap_or_default() },
+        "ptt_final"      => AsrEvent::PttFinal      { text: get("text").unwrap_or_default() },
+        "ptt_upgrade"    => AsrEvent::PttUpgrade    { text: get("text").unwrap_or_default() },
+        "ptt_translated" => AsrEvent::PttTranslated {
+            text: get("text").unwrap_or_default(),
+            lang: get("lang").unwrap_or_default(),
+        },
         _ => AsrEvent::Other,
     }
 }
@@ -127,17 +132,41 @@ impl OtojiBackend {
         // opening the mic itself. CLX has mic permission; otoji may not.
         let mut cmd = Command::new("otoji");
         let ctx_path = super::voice_ptt::ptt_context_file_path();
-        cmd.args([
-            "listen", "--plain", "-",
-            "--ptt-polish", "auto",  // fix punctuation (e.g. `.` → `?` for questions)
-            "--ptt-tts", "auto",     // speak the polished text back for pronunciation feedback
-            "--ptt-context-file", &ctx_path,
-        ])
-        .stdout(Stdio::piped())
-        .stderr(Stdio::piped())
-        .stdin(Stdio::piped())
-        .env("OTOJI_RELAUNCHED", "1")
-        .env("OTOJI_REBUILDING", "1"); // prevent auto-rebuild + exec which breaks pipes
+        let mut args: Vec<String> = vec![
+            "listen".into(), "--plain".into(), "-".into(),
+            // "openai" route goes through OpenAiPolisher which honors the
+            // OTOJI_POLISH_BASE_URL / _API_KEY / _MODEL env vars. Default
+            // in .env.local points to Cloudflare Workers AI (edge inference,
+            // ~200-500ms TTFB). Falls back to Gemini if those env vars are
+            // unset thanks to `resolve_polisher`'s "auto" chain.
+            "--ptt-polish".into(), "openai".into(),
+            // Gemini handles multilingual (en/zh/ja) — "auto" would pick Piper
+            // which is English-only and mangles CJK text.
+            "--ptt-tts".into(), "gemini".into(),
+            "--ptt-context-file".into(), ctx_path,
+        ];
+        // Translation (Phase 1: env-driven).
+        // CLX_TRANSLATE_TO: target language BCP-47 code (e.g. "en"). Empty = off.
+        // CLX_TRANSLATE_TTS_SOURCE: "original" or "translated" (default original).
+        if let Ok(to) = std::env::var("CLX_TRANSLATE_TO") {
+            if !to.is_empty() {
+                args.push("--ptt-translate-to".into());
+                args.push(to);
+            }
+        }
+        if let Ok(src) = std::env::var("CLX_TRANSLATE_TTS_SOURCE") {
+            if !src.is_empty() {
+                args.push("--ptt-tts-source".into());
+                args.push(src);
+            }
+        }
+
+        cmd.args(&args)
+            .stdout(Stdio::piped())
+            .stderr(Stdio::piped())
+            .stdin(Stdio::piped())
+            .env("OTOJI_RELAUNCHED", "1")
+            .env("OTOJI_REBUILDING", "1"); // prevent auto-rebuild + exec which breaks pipes
 
         // NOTE: process_group(0) was disabled — it may interfere with signal
         // delivery from parent to child on macOS. We kill otoji explicitly
@@ -362,6 +391,11 @@ impl OtojiBackend {
                                     p.on_ptt_upgrade(&text);
                                 }
                             }
+                            AsrEvent::PttTranslated { text, lang } => {
+                                if let Some(ref p) = ptt {
+                                    p.on_ptt_translated(&text, &lang);
+                                }
+                            }
                             AsrEvent::Status { message } => {
                                 platform.update_voice_subtitle(&format!("[{}]", message));
                             }

rs/core/src/modules/voice_ptt.rs

@@ -416,6 +416,9 @@ impl PttSession {
             .name("ptt-spinner".into())
             .spawn(move || {
                 let mut i = 0usize;
+                let spin_start = Instant::now();
+                let mut iter_no = 0u64;
+                let mut last_iter_end = spin_start;
                 // Type the initial frame under the lock.
                 {
                     let mut s = this.spinner.lock().unwrap();
@@ -426,19 +429,36 @@ impl PttSession {
                 }
                 loop {
                     std::thread::sleep(Duration::from_millis(SPINNER_INTERVAL_MS));
+                    let loop_top = Instant::now();
                     let mut s = this.spinner.lock().unwrap();
+                    let got_lock = Instant::now();
                     if !s.active { return; }
                     i = (i + 1) % SPINNER_FRAMES.len();
                     // Backspace old frame, type new. Under lock so stop_spinner
                     // can't race during the swap.
+                    let inject_start = Instant::now();
                     if let Some(old) = s.current.take() {
                         for _ in old.chars() {
                             this.platform.key_tap(KeyCode::Backspace);
                         }
                     }
                     let frame = SPINNER_FRAMES[i];
                     this.platform.type_text(frame);
+                    let inject_end = Instant::now();
                     s.current = Some(frame.to_string());
+                    drop(s);
+
+                    iter_no += 1;
+                    let gap = loop_top.duration_since(last_iter_end).as_millis();
+                    let lock_wait = got_lock.duration_since(loop_top).as_millis();
+                    let inject_ms = inject_end.duration_since(inject_start).as_millis();
+                    let since_start = loop_top.duration_since(spin_start).as_millis();
+                    // Log every iteration for now (we can throttle later once
+                    // the cause is clear).
+                    eprintln!(
+                        "[CLX] ptt-spin #{iter_no} t+{since_start}ms gap={gap}ms lock_wait={lock_wait}ms inject={inject_ms}ms"
+                    );
+                    last_iter_end = inject_end;
                 }
             })
             .ok();
@@ -504,7 +524,9 @@ impl PttSession {
 
     /// Replace displayed text at cursor using diff (common prefix optimization).
     fn replace_displayed(&self, new_text: &str) {
+        let t0 = Instant::now();
         let mut displayed = self.displayed.lock().unwrap();
+        let t_lock = Instant::now();
         let old = &**displayed;
 
         let common: usize = old.chars().zip(new_text.chars())
@@ -513,13 +535,25 @@ impl PttSession {
 
         let old_tail_chars = old.chars().count() - common;
         let new_tail: String = new_text.chars().skip(common).collect();
+        let new_tail_chars = new_tail.chars().count();
 
+        let t_inject_start = Instant::now();
         for _ in 0..old_tail_chars {
             self.platform.key_tap(KeyCode::Backspace);
         }
         if !new_tail.is_empty() {
             self.platform.type_text(&new_tail);
         }
+        let t_end = Instant::now();
+
+        eprintln!(
+            "[CLX] ptt-partial old_len={} new_len={} common={} bs={} type={} | lock={}ms inject={}ms total={}ms",
+            old.chars().count(), new_text.chars().count(), common,
+            old_tail_chars, new_tail_chars,
+            t_lock.duration_since(t0).as_millis(),
+            t_end.duration_since(t_inject_start).as_millis(),
+            t_end.duration_since(t0).as_millis(),
+        );
 
         *displayed = new_text.to_string();
     }

rs/core/src/platform.rs

@@ -27,6 +27,15 @@ pub trait SystemAudioStream: Send {
     fn sample_rate(&self) -> u32;
 }
 
+/// Menu bar / tray icon state for voice features.
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub enum PttTrayState {
+    Idle,
+    Recording,
+    Processing,
+    NoteMode,
+}
+
 pub trait Platform: Send + Sync + 'static {
     // ── Keyboard output ───────────────────────────────────────────────────────
 
@@ -191,6 +200,8 @@ pub trait Platform: Send + Sync + 'static {
     fn hide_voice_overlay(&self) {}
     fn update_voice_overlay(&self, _mic_levels: &[f32], _mic_vad: bool, _sys_levels: &[f32], _sys_vad: bool) {}
     fn update_voice_subtitle(&self, _text: &str) {}
+    /// Update the menu bar tray icon to reflect PTT / voice state.
+    fn set_ptt_tray_state(&self, _state: PttTrayState) {}
 
     // ── Brainstorm overlay (optional, default = no-op) ─────────────────────