@phenx-inc/ctlsurf 0.8.0 → 0.10.0

package/src/main/transcripts.ts

@@ -339,3 +339,137 @@ function capLength(str: string): string {
   if (str.length <= MAX_ENTRY_CHARS) return str
   return str.slice(0, MAX_ENTRY_CHARS) + `… [truncated, ${str.length} total chars]`
 }
+
+// ─── One-shot latest-reply read (on-demand "read aloud") ──────────
+//
+// Unlike the tailer, this does a single synchronous scan to return the most
+// recent assistant reply for an agent + cwd, independent of whether the tailer
+// is running. Used by the "read last response aloud" button so it works even
+// when the speak-replies setting is off. Returns null when there's no
+// transcript or no assistant message yet.
+export function readLatestAssistantReply(opts: {
+  agentId: TranscriptAgentId
+  cwd: string
+  claudeProjectsDir?: string
+  codexSessionsDir?: string
+}): string | null {
+  try {
+    const cwd = stripTrailingSep(opts.cwd)
+    if (opts.agentId === 'claude') {
+      const file = mostRecentClaudeFile(cwd, opts.claudeProjectsDir)
+      if (!file) return null
+      const text = lastClaudeAssistant(file, cwd)
+      return text ? capLength(text) : null
+    }
+    // Codex: the active session is the most recently written rollout for this cwd.
+    const codexRoot = opts.codexSessionsDir || path.join(os.homedir(), '.codex', 'sessions')
+    for (const file of recentCodexRollouts(codexRoot)) {
+      const text = lastCodexAgentMessage(file, cwd)
+      if (text) return capLength(text)
+    }
+    return null
+  } catch {
+    return null
+  }
+}
+
+// Whole-file read is fine here: transcripts are at most a few MB and we only do
+// this on an explicit button click, not on a poll.
+function readLines(file: string): string[] {
+  try {
+    return fs.readFileSync(file, 'utf-8').split('\n')
+  } catch {
+    return []
+  }
+}
+
+function mostRecentClaudeFile(cwd: string, root?: string): string | null {
+  const projectsRoot = root || path.join(os.homedir(), '.claude', 'projects')
+  const slug = cwd.replace(/[^a-zA-Z0-9]/g, '-')
+  const dir = path.join(projectsRoot, slug)
+  let names: string[]
+  try {
+    names = fs.readdirSync(dir)
+  } catch {
+    return null
+  }
+  let best: string | null = null
+  let bestMs = -Infinity
+  for (const name of names) {
+    if (!name.endsWith('.jsonl')) continue
+    const fp = path.join(dir, name)
+    try {
+      const ms = fs.statSync(fp).mtimeMs
+      if (ms > bestMs) { bestMs = ms; best = fp }
+    } catch { /* ignore */ }
+  }
+  return best
+}
+
+function recentCodexRollouts(root: string): string[] {
+  // Today and yesterday's session dirs (covers sessions spanning midnight),
+  // newest file first.
+  const dirs = new Set<string>()
+  const now = Date.now()
+  for (const ms of [now, now - 24 * 60 * 60 * 1000]) {
+    const d = new Date(ms)
+    const yyyy = String(d.getFullYear())
+    const mm = String(d.getMonth() + 1).padStart(2, '0')
+    const dd = String(d.getDate()).padStart(2, '0')
+    dirs.add(path.join(root, yyyy, mm, dd))
+  }
+  const files: Array<{ fp: string; ms: number }> = []
+  for (const dir of dirs) {
+    let names: string[]
+    try { names = fs.readdirSync(dir) } catch { continue }
+    for (const name of names) {
+      if (!name.startsWith('rollout-') || !name.endsWith('.jsonl')) continue
+      const fp = path.join(dir, name)
+      try { files.push({ fp, ms: fs.statSync(fp).mtimeMs }) } catch { /* ignore */ }
+    }
+  }
+  return files.sort((a, b) => b.ms - a.ms).map((f) => f.fp)
+}
+
+function lastClaudeAssistant(file: string, cwd: string): string | null {
+  const lines = readLines(file)
+  for (let i = lines.length - 1; i >= 0; i--) {
+    const trimmed = lines[i].trim()
+    if (!trimmed) continue
+    let obj: any
+    try { obj = JSON.parse(trimmed) } catch { continue }
+    if (!obj || typeof obj !== 'object') continue
+    if (obj.isMeta || obj.isSidechain || obj.type !== 'assistant') continue
+    if (typeof obj.cwd === 'string' && stripTrailingSep(obj.cwd) !== cwd) continue
+    const text = extractClaudeText(obj.message?.content, false)
+    if (text) return text
+  }
+  return null
+}
+
+function lastCodexAgentMessage(file: string, cwd: string): string | null {
+  const lines = readLines(file)
+  // The date dir is shared across projects, so confirm this rollout belongs to
+  // our cwd via its session_meta before trusting any of its messages.
+  for (const line of lines) {
+    const trimmed = line.trim()
+    if (!trimmed) continue
+    let obj: any
+    try { obj = JSON.parse(trimmed) } catch { continue }
+    if (obj?.type === 'session_meta') {
+      const metaCwd = obj.payload?.cwd
+      if (typeof metaCwd === 'string' && stripTrailingSep(metaCwd) !== cwd) return null
+      break
+    }
+  }
+  for (let i = lines.length - 1; i >= 0; i--) {
+    const trimmed = lines[i].trim()
+    if (!trimmed) continue
+    let obj: any
+    try { obj = JSON.parse(trimmed) } catch { continue }
+    if (obj?.type !== 'event_msg' || obj.payload?.type !== 'agent_message') continue
+    const text = typeof obj.payload.message === 'string' ? obj.payload.message.trim() : ''
+    if (text && !isCodexNoise(text)) return text
+  }
+  return null
+}

package/src/preload/index.ts

@@ -119,6 +119,17 @@ const api = {
     ipcRenderer.on('agent:message', listener)
     return () => ipcRenderer.removeListener('agent:message', listener)
   },
+  // Real-time agent activity state for an in-app indicator dot.
+  // state: 'idle' | 'busy' | 'awaiting_input' | 'awaiting_decision'
+  onAgentState: (callback: (tabId: string, state: string, anyAwaiting: boolean) => void) => {
+    const listener = (_event: Electron.IpcRendererEvent, tabId: string, state: string, anyAwaiting: boolean) =>
+      callback(tabId, state, anyAwaiting)
+    ipcRenderer.on('agent:state', listener)
+    return () => ipcRenderer.removeListener('agent:state', listener)
+  },
+  // Latest assistant reply from the active tab's transcript (null if none).
+  getLastReply: (): Promise<string | null> =>
+    ipcRenderer.invoke('agent:getLastReply'),
 
   // Filesystem
   readDir: (dirPath: string): Promise<Array<{ name: string; path: string; isDirectory: boolean }>> =>

package/src/renderer/App.tsx

@@ -60,6 +60,8 @@ declare global {
       getSpeakReplies: () => Promise<{ enabled: boolean }>
       setSpeakReplies: (enabled: boolean) => Promise<{ enabled: boolean }>
       onAgentMessage: (callback: (text: string) => void) => () => void
+      onAgentState: (callback: (tabId: string, state: string, anyAwaiting: boolean) => void) => () => void
+      getLastReply: () => Promise<string | null>
       createProject: () => Promise<{ ok: boolean; folder_id?: string; error?: string }>
       getWebviewInfo: () => Promise<{
         frontendUrl: string; pageUrl?: string; authenticated: boolean;
@@ -136,6 +138,9 @@ export default function App() {
   })
   const [activeTabId, setActiveTabId] = useState<string>(tabs[0].id)
   const [trackingActive, setTrackingActive] = useState(false)
+  // Per-tab agent activity ('busy' | 'awaiting_input' | 'awaiting_decision' | 'idle'),
+  // driven by the main process. Powers the awaiting-input dot on each tab.
+  const [agentStates, setAgentStates] = useState<Record<string, string>>({})
   const [showTicketPanel, setShowTicketPanel] = useState(false)
   // Draggable on-canvas push-to-talk mic; visibility persists across launches.
   const [showFloatingMic, setShowFloatingMic] = useState<boolean>(() => {
@@ -155,16 +160,22 @@ export default function App() {
 
   useEffect(() => {
     async function init() {
-      const list = await window.worker.listAgents()
-      setAgents(list)
-      const status = await window.worker.getWorkerStatus()
-      setWsStatus(status)
-      // Load initial cwd for the picker
-      const initialCwd = await window.worker.getCwd().catch(() => window.worker.getHomePath())
-      setCwd(initialCwd)
-      cwdRef.current = initialCwd
-      // Connected ctlsurf project name for the header (null until a worker registers)
-      window.worker.getProjectName().then(setProjectName).catch(() => { /* ignore */ })
+      try {
+        const list = await window.worker.listAgents()
+        setAgents(list)
+        const status = await window.worker.getWorkerStatus()
+        setWsStatus(status)
+        // Load initial cwd for the picker
+        const initialCwd = await window.worker.getCwd().catch(() => window.worker.getHomePath())
+        setCwd(initialCwd)
+        cwdRef.current = initialCwd
+        // Connected ctlsurf project name for the header (null until a worker registers)
+        window.worker.getProjectName().then(setProjectName).catch(() => { /* ignore */ })
+      } finally {
+        // Dismiss the boot splash painted by index.html now that startup IPC has
+        // settled. In `finally` so a failed IPC call never leaves it stuck on.
+        ;(window as unknown as { __dismissSplash?: () => void }).__dismissSplash?.()
+      }
     }
     init()
   }, [])
@@ -195,6 +206,16 @@ export default function App() {
     return unsub
   }, [])
 
+  // Track each tab's agent activity for the awaiting-input dot. The aggregate-
+  // only signal arrives with an empty tabId, which we ignore here.
+  useEffect(() => {
+    const unsub = window.worker.onAgentState((tabId, state) => {
+      if (!tabId) return
+      setAgentStates(prev => (prev[tabId] === state ? prev : { ...prev, [tabId]: state }))
+    })
+    return unsub
+  }, [])
+
   // Reflect tracking state for the active tab; refresh on tab switch and poll
   // periodically so the UI catches changes (e.g. a session ending naturally).
   useEffect(() => {
@@ -225,8 +246,15 @@ export default function App() {
   const handleVoiceTranscript = useCallback((text: string) => {
     const trimmed = text.trim()
     if (!trimmed) return
-    window.worker.writePty(activeTabId, trimmed + '\r')
+    // Send the text and the submit Enter as TWO separate writes. A long transcript
+    // glued to its trailing \r arrives as one fast burst, which the agent's input
+    // box treats as a paste and turns the carriage return into a literal newline
+    // instead of submitting. Delaying the Enter lets the text be consumed first so
+    // \r registers as a real submit keystroke. (80ms is the tunable knob if very
+    // long input ever needs more time to drain.)
+    window.worker.writePty(activeTabId, trimmed)
     focusTerminal(activeTabId)
+    setTimeout(() => window.worker.writePty(activeTabId, '\r'), 80)
   }, [activeTabId])
 
   const cwdRef = useRef<string | null>(null)
@@ -410,8 +438,15 @@ export default function App() {
               >
                 <span className="terminal-tab-label">
                   {tab.agent ? tab.agent.name : tab.label}
-                  {tab.agentStatus === 'active' && <span className="terminal-tab-dot active" />}
-                  {tab.agentStatus === 'exited' && <span className="terminal-tab-dot exited" />}
+                  {tab.agentStatus === 'exited' ? (
+                    <span className="terminal-tab-dot exited" />
+                  ) : agentStates[tab.id] === 'awaiting_decision' ? (
+                    <span className="terminal-tab-dot decision" title="Awaiting your approval" />
+                  ) : agentStates[tab.id] === 'awaiting_input' ? (
+                    <span className="terminal-tab-dot awaiting" title="Awaiting your input" />
+                  ) : tab.agentStatus === 'active' ? (
+                    <span className="terminal-tab-dot active" />
+                  ) : null}
                 </span>
                 {tabs.length > 1 && (
                   <button

package/src/renderer/components/FloatingMic.tsx

@@ -1,5 +1,6 @@
 import { useCallback, useEffect, useRef, useState } from 'react'
 import { VoiceInput } from './VoiceInput'
+import { speech } from '../lib/speech'
 
 // A draggable, dismissable push-to-talk mic that floats over the panes. It wraps
 // the same <VoiceInput> push-to-talk logic used in the titlebar; only the chrome
@@ -36,6 +37,29 @@ export function FloatingMic({ onTranscript, onHide }: FloatingMicProps) {
   // Pointer-to-element offset captured at drag start; null when not dragging.
   const dragRef = useRef<{ dx: number; dy: number } | null>(null)
 
+  // Read-aloud (TTS) of the last agent reply. `speaking` mirrors the shared
+  // speech singleton; `note` is a transient message (e.g. nothing to read yet).
+  const [speaking, setSpeaking] = useState(false)
+  const [note, setNote] = useState<string | null>(null)
+  useEffect(() => speech.onActivity(setSpeaking), [])
+  useEffect(() => {
+    if (!note) return
+    const t = setTimeout(() => setNote(null), 3000)
+    return () => clearTimeout(t)
+  }, [note])
+
+  const onReadAloud = useCallback(async () => {
+    // Toggle: a second click while speaking stops it.
+    if (speaking) { speech.stop(); return }
+    // Prime the audio context from this click (synchronously, before the await)
+    // so neural playback isn't blocked by the autoplay policy.
+    speech.unlock()
+    let text: string | null = null
+    try { text = await window.worker.getLastReply() } catch { /* ignore */ }
+    if (text) speech.enqueue(text)
+    else setNote('No reply to read yet')
+  }, [speaking])
+
   // Keep the button fully inside the viewport (used on drag, mount, and resize).
   const clamp = useCallback((x: number, y: number): Pos => {
     const el = elRef.current
@@ -123,6 +147,30 @@ export function FloatingMic({ onTranscript, onHide }: FloatingMicProps) {
         </button>
       </div>
       <VoiceInput variant="floating" onTranscript={onTranscript} />
+      <button
+        type="button"
+        className={`floating-mic-read ${speaking ? 'speaking' : ''}`}
+        // Don't let a click on the button start a drag.
+        onPointerDown={(e) => e.stopPropagation()}
+        onClick={onReadAloud}
+        title={speaking ? 'Stop reading' : 'Read last agent reply aloud'}
+        aria-label={speaking ? 'Stop reading' : 'Read last agent reply aloud'}
+        aria-pressed={speaking}
+      >
+        {speaking ? (
+          <svg viewBox="0 0 24 24" width="14" height="14" fill="currentColor" aria-hidden="true">
+            <rect x="6" y="6" width="12" height="12" rx="2" />
+          </svg>
+        ) : (
+          <svg viewBox="0 0 24 24" width="15" height="15" fill="none" stroke="currentColor"
+            strokeWidth="2" strokeLinecap="round" strokeLinejoin="round" aria-hidden="true">
+            <polygon points="11 5 6 9 2 9 2 15 6 15 11 19 11 5" />
+            <path d="M15.54 8.46a5 5 0 0 1 0 7.07" />
+            <path d="M19.07 4.93a10 10 0 0 1 0 14.14" />
+          </svg>
+        )}
+      </button>
+      {note && <div className="floating-mic-note">{note}</div>}
     </div>
   )
 }

package/src/renderer/components/VoiceInput.tsx

@@ -1,76 +1,26 @@
 import { useCallback, useEffect, useRef, useState } from 'react'
 import { transcribeBlob, type ModelProgress } from '../lib/localWhisper'
 
-// ─── Minimal Web Speech API typings ──────────────────
-// webkitSpeechRecognition isn't in the standard DOM lib, so declare just the
-// surface we use. This API is frequently unavailable inside Electron (Chromium
-// ships without Google's speech backend); when it fails we fall back to a local
-// Whisper model (see ../lib/localWhisper).
-
-interface SpeechRecognitionResult {
-  isFinal: boolean
-  0: { transcript: string }
-}
-interface SpeechRecognitionEvent {
-  resultIndex: number
-  results: { length: number;[index: number]: SpeechRecognitionResult }
-}
-interface SpeechRecognitionErrorEvent { error: string }
-interface SpeechRecognitionLike {
-  lang: string
-  continuous: boolean
-  interimResults: boolean
-  start: () => void
-  stop: () => void
-  abort: () => void
-  onresult: ((e: SpeechRecognitionEvent) => void) | null
-  onerror: ((e: SpeechRecognitionErrorEvent) => void) | null
-  onend: (() => void) | null
-}
-type SpeechRecognitionCtor = new () => SpeechRecognitionLike
+// ─── Capabilities ────────────────────────────────────
+// Speech is transcribed entirely on-device via a local Whisper model (see
+// ../lib/localWhisper). The browser's Web Speech API is intentionally not used:
+// it's a cloud service whose Google backend is unreachable inside Electron
+// (Chromium ships without the API key), so it never works in this app.
 
-function getRecognitionCtor(): SpeechRecognitionCtor | null {
-  const w = window as unknown as {
-    SpeechRecognition?: SpeechRecognitionCtor
-    webkitSpeechRecognition?: SpeechRecognitionCtor
-  }
-  return w.SpeechRecognition || w.webkitSpeechRecognition || null
-}
-
-// ─── Capabilities & engine selection ─────────────────
-
-type Engine = 'web-speech' | 'local'
 type Phase = 'idle' | 'listening' | 'transcribing'
 
-const ENGINE_KEY = 'ctlsurf.voiceEngine'
-// Persisted audioinput deviceId for the local engine; null/absent = OS default.
+// Persisted audioinput deviceId; null/absent = OS default.
 const DEVICE_KEY = 'ctlsurf.voiceDeviceId'
 
 function loadDeviceId(): string | null {
   try { return localStorage.getItem(DEVICE_KEY) || null } catch { return null }
 }
 
-const WEB_SPEECH_SUPPORTED = getRecognitionCtor() !== null
 const LOCAL_SUPPORTED =
   typeof navigator !== 'undefined' &&
   !!navigator.mediaDevices?.getUserMedia &&
   typeof MediaRecorder !== 'undefined' &&
   typeof OfflineAudioContext !== 'undefined'
-const ANY_SUPPORTED = WEB_SPEECH_SUPPORTED || LOCAL_SUPPORTED
-
-function loadInitialEngine(): Engine {
-  if (!WEB_SPEECH_SUPPORTED && LOCAL_SUPPORTED) return 'local'
-  try {
-    if (localStorage.getItem(ENGINE_KEY) === 'local' && LOCAL_SUPPORTED) return 'local'
-  } catch { /* ignore */ }
-  return WEB_SPEECH_SUPPORTED ? 'web-speech' : 'local'
-}
-
-// Web Speech errors that mean the engine itself is unreachable (vs. a mic
-// permission/hardware problem, which would also break the local fallback).
-function isEngineUnavailable(code: string): boolean {
-  return code === 'network' || code === 'service-not-allowed'
-}
 
 function describeMicError(err: unknown): string {
   const name = (err as { name?: string })?.name
@@ -88,14 +38,14 @@ interface VoiceInputProps {
 }
 
 export function VoiceInput({ onTranscript, variant = 'titlebar' }: VoiceInputProps) {
-  const [engine, setEngine] = useState<Engine>(loadInitialEngine)
   const [phase, setPhase] = useState<Phase>('idle')
-  const [interim, setInterim] = useState('')
   const [modelPct, setModelPct] = useState<number | null>(null)
+  // Transcript-so-far streamed from the model during transcription (live preview).
+  const [partial, setPartial] = useState('')
   const [error, setError] = useState<string | null>(null)
   const [notice, setNotice] = useState<string | null>(null)
 
-  // Mic source selection (local engine only)
+  // Mic source selection
   const [devices, setDevices] = useState<MediaDeviceInfo[]>([])
   const [selectedDeviceId, setSelectedDeviceId] = useState<string | null>(loadDeviceId)
   const [showDevicePicker, setShowDevicePicker] = useState(false)
@@ -103,19 +53,13 @@ export function VoiceInput({ onTranscript, variant = 'titlebar' }: VoiceInputPro
   useEffect(() => { selectedDeviceIdRef.current = selectedDeviceId }, [selectedDeviceId])
   const wrapRef = useRef<HTMLDivElement>(null)
 
-  // Web Speech refs
-  const recognitionRef = useRef<SpeechRecognitionLike | null>(null)
-  const finalRef = useRef('')
-  // Local (Whisper) refs
+  // Recording refs
   const streamRef = useRef<MediaStream | null>(null)
   const recorderRef = useRef<MediaRecorder | null>(null)
   const chunksRef = useRef<Blob[]>([])
   // Set true when the user releases before getUserMedia resolves (quick tap).
   const cancelGestureRef = useRef(false)
 
-  const engineRef = useRef(engine)
-  useEffect(() => { engineRef.current = engine }, [engine])
-
   const onTranscriptRef = useRef(onTranscript)
   useEffect(() => { onTranscriptRef.current = onTranscript }, [onTranscript])
 
@@ -131,12 +75,6 @@ export function VoiceInput({ onTranscript, variant = 'titlebar' }: VoiceInputPro
     return () => clearTimeout(t)
   }, [notice])
 
-  const switchToLocal = useCallback((reason: string) => {
-    try { localStorage.setItem(ENGINE_KEY, 'local') } catch { /* ignore */ }
-    setEngine('local')
-    setNotice(reason)
-  }, [])
-
   const stopStream = useCallback(() => {
     streamRef.current?.getTracks().forEach((t) => t.stop())
     streamRef.current = null
@@ -224,66 +162,7 @@ export function VoiceInput({ onTranscript, variant = 'titlebar' }: VoiceInputPro
     return () => document.removeEventListener('mousedown', onDocDown)
   }, [showDevicePicker])
 
-  // ─── Web Speech engine ─────────────────────────────
-
-  const startWebSpeech = useCallback(() => {
-    const Ctor = getRecognitionCtor()
-    if (!Ctor || recognitionRef.current) return
-    setError(null); setNotice(null); setInterim('')
-    finalRef.current = ''
-
-    const rec = new Ctor()
-    rec.lang = navigator.language || 'en-US'
-    rec.continuous = true
-    rec.interimResults = true
-
-    rec.onresult = (event) => {
-      let finalText = ''
-      let interimText = ''
-      for (let i = 0; i < event.results.length; i++) {
-        const res = event.results[i]
-        if (res.isFinal) finalText += res[0].transcript
-        else interimText += res[0].transcript
-      }
-      finalRef.current = finalText
-      setInterim(interimText)
-    }
-
-    rec.onerror = (event) => {
-      if (isEngineUnavailable(event.error) && LOCAL_SUPPORTED) {
-        // The streamed audio is gone; switch engines and ask for a retry.
-        finalRef.current = ''
-        switchToLocal('Voice service unavailable — switched to on-device. Press again.')
-      } else if (event.error !== 'no-speech' && event.error !== 'aborted') {
-        setError(event.error === 'not-allowed' ? 'Microphone access denied' : `Voice error: ${event.error}`)
-      }
-    }
-
-    rec.onend = () => {
-      const text = finalRef.current.trim()
-      recognitionRef.current = null
-      setPhase('idle')
-      setInterim('')
-      if (text) onTranscriptRef.current(text)
-    }
-
-    recognitionRef.current = rec
-    try {
-      rec.start()
-      setPhase('listening')
-    } catch (err) {
-      recognitionRef.current = null
-      setPhase('idle')
-      setError('Could not start microphone')
-      console.error('[voice] web speech start failed', err)
-    }
-  }, [switchToLocal])
-
-  const stopWebSpeech = useCallback(() => {
-    try { recognitionRef.current?.stop() } catch { /* already stopped */ }
-  }, [])
-
-  // ─── Local (Whisper) engine ────────────────────────
+  // ─── On-device (Whisper) transcription ─────────────
 
   const handleModelProgress = useCallback((p: ModelProgress) => {
     if (p.status === 'progress' && typeof p.progress === 'number') {
@@ -299,9 +178,14 @@ export function VoiceInput({ onTranscript, variant = 'titlebar' }: VoiceInputPro
     if (blob.size === 0) { setPhase('idle'); return }
 
     setPhase('transcribing')
-    setInterim('')
+    setPartial('')
     try {
-      const text = await transcribeBlob(blob, handleModelProgress)
+      const text = await transcribeBlob(blob, handleModelProgress, (t) => {
+        // First streamed token means the model is loaded and decoding — drop the
+        // download indicator and start showing the live transcript.
+        setModelPct(null)
+        setPartial(t)
+      })
       if (text) onTranscriptRef.current(text)
       else setNotice('No speech detected — check the mic source (▾).')
     } catch (err) {
@@ -310,11 +194,12 @@ export function VoiceInput({ onTranscript, variant = 'titlebar' }: VoiceInputPro
     } finally {
       setPhase('idle')
       setModelPct(null)
+      setPartial('')
     }
   }, [stopStream, handleModelProgress])
 
   const startLocal = useCallback(async () => {
-    setError(null); setNotice(null); setInterim('')
+    setError(null); setNotice(null)
     cancelGestureRef.current = false
     try {
       const stream = await getStream()
@@ -351,21 +236,18 @@ export function VoiceInput({ onTranscript, variant = 'titlebar' }: VoiceInputPro
   // ─── Push-to-talk gesture ──────────────────────────
 
   const handlePointerDown = (e: React.PointerEvent) => {
-    if (!ANY_SUPPORTED || phase !== 'idle') return
+    if (!LOCAL_SUPPORTED || phase !== 'idle') return
     e.preventDefault()
     e.currentTarget.setPointerCapture?.(e.pointerId)
-    if (engineRef.current === 'web-speech' && WEB_SPEECH_SUPPORTED) startWebSpeech()
-    else if (LOCAL_SUPPORTED) void startLocal()
+    void startLocal()
   }
   const handlePointerUp = (e: React.PointerEvent) => {
     e.currentTarget.releasePointerCapture?.(e.pointerId)
-    if (engineRef.current === 'web-speech') stopWebSpeech()
-    else stopLocal()
+    stopLocal()
   }
 
   // Clean up on unmount.
   useEffect(() => () => {
-    try { recognitionRef.current?.abort() } catch { /* ignore */ }
     try { recorderRef.current?.stop() } catch { /* ignore */ }
     streamRef.current?.getTracks().forEach((t) => t.stop())
   }, [])
@@ -375,21 +257,27 @@ export function VoiceInput({ onTranscript, variant = 'titlebar' }: VoiceInputPro
   const listening = phase === 'listening'
   const busy = phase === 'transcribing'
 
-  const title = !ANY_SUPPORTED
+  const title = !LOCAL_SUPPORTED
     ? 'Voice typing not supported in this build'
     : listening
       ? 'Listening… release to insert'
       : busy
         ? 'Transcribing…'
-        : engine === 'local'
-          ? 'Hold to talk (on-device) — speech is typed into the terminal'
-          : 'Hold to talk — speech is typed into the terminal'
+        : 'Hold to talk (on-device) — speech is typed into the terminal'
 
   let chip: { kind: 'listening' | 'busy' | 'notice' | 'error'; text: string } | null = null
   if (error && phase === 'idle') chip = { kind: 'error', text: error }
   else if (notice && phase === 'idle') chip = { kind: 'notice', text: notice }
-  else if (listening) chip = { kind: 'listening', text: interim || (engine === 'local' ? 'Recording…' : 'Listening…') }
-  else if (busy) chip = { kind: 'busy', text: modelPct !== null ? `Downloading voice model… ${modelPct}%` : 'Transcribing…' }
+  else if (listening) chip = { kind: 'listening', text: 'Recording…' }
+  else if (busy) {
+    // Show the most recent ~90 chars of the live transcript as a ticker so a long
+    // dictation doesn't overflow the chip.
+    const preview = partial.length > 90 ? '…' + partial.slice(-90) : partial
+    chip = {
+      kind: 'busy',
+      text: modelPct !== null ? `Downloading voice model… ${modelPct}%` : (preview || 'Transcribing…'),
+    }
+  }
 
   const floating = variant === 'floating'
   const btnClass = floating
@@ -408,7 +296,6 @@ export function VoiceInput({ onTranscript, variant = 'titlebar' }: VoiceInputPro
   const activeLabel = selectedDeviceId
     ? (realDevices.find((d) => d.deviceId === selectedDeviceId)?.label || 'Selected microphone')
     : defaultLabel
-  // Source selection only affects the local (getUserMedia) engine.
   const showSourcePicker = floating && LOCAL_SUPPORTED
 
   return (
@@ -416,7 +303,7 @@ export function VoiceInput({ onTranscript, variant = 'titlebar' }: VoiceInputPro
       <button
         type="button"
         className={btnClass}
-        disabled={!ANY_SUPPORTED}
+        disabled={!LOCAL_SUPPORTED}
         onPointerDown={handlePointerDown}
         onPointerUp={handlePointerUp}
         onPointerCancel={handlePointerUp}