@phenx-inc/ctlsurf 0.6.0 → 0.8.0

package/src/renderer/components/FloatingMic.tsx

@@ -0,0 +1,128 @@
+import { useCallback, useEffect, useRef, useState } from 'react'
+import { VoiceInput } from './VoiceInput'
+
+// 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
+// (drag handle + hide button) and positioning live here.
+
+const POS_KEY = 'ctlsurf.floatingMicPos'
+
+interface Pos { x: number; y: number }
+
+interface FloatingMicProps {
+  onTranscript: (text: string) => void
+  onHide: () => void
+}
+
+// Keep the button clear of the 38px titlebar and 24px status bar.
+const EDGE = 20
+const TOP_MIN = 46
+const BOTTOM_GAP = 36
+
+function loadPos(): Pos | null {
+  try {
+    const raw = localStorage.getItem(POS_KEY)
+    if (raw) {
+      const p = JSON.parse(raw) as Partial<Pos>
+      if (typeof p.x === 'number' && typeof p.y === 'number') return { x: p.x, y: p.y }
+    }
+  } catch { /* ignore */ }
+  return null
+}
+
+export function FloatingMic({ onTranscript, onHide }: FloatingMicProps) {
+  const [pos, setPos] = useState<Pos | null>(loadPos)
+  const elRef = useRef<HTMLDivElement>(null)
+  // Pointer-to-element offset captured at drag start; null when not dragging.
+  const dragRef = useRef<{ dx: number; dy: number } | null>(null)
+
+  // 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
+    const w = el?.offsetWidth ?? 64
+    const h = el?.offsetHeight ?? 90
+    return {
+      x: Math.max(EDGE, Math.min(x, window.innerWidth - w - EDGE)),
+      y: Math.max(TOP_MIN, Math.min(y, window.innerHeight - h - BOTTOM_GAP)),
+    }
+  }, [])
+
+  // First mount with no saved position: default to bottom-right.
+  useEffect(() => {
+    if (pos) return
+    const el = elRef.current
+    const w = el?.offsetWidth ?? 64
+    const h = el?.offsetHeight ?? 90
+    setPos({
+      x: window.innerWidth - w - EDGE,
+      y: window.innerHeight - h - BOTTOM_GAP,
+    })
+  }, [pos])
+
+  // Keep it reachable if the window shrinks.
+  useEffect(() => {
+    const onResize = () => setPos((p) => (p ? clamp(p.x, p.y) : p))
+    window.addEventListener('resize', onResize)
+    return () => window.removeEventListener('resize', onResize)
+  }, [clamp])
+
+  const onHandleDown = useCallback((e: React.PointerEvent) => {
+    const el = elRef.current
+    if (!el) return
+    e.preventDefault()
+    const rect = el.getBoundingClientRect()
+    dragRef.current = { dx: e.clientX - rect.left, dy: e.clientY - rect.top }
+    e.currentTarget.setPointerCapture?.(e.pointerId)
+  }, [])
+
+  const onHandleMove = useCallback((e: React.PointerEvent) => {
+    const d = dragRef.current
+    if (!d) return
+    setPos(clamp(e.clientX - d.dx, e.clientY - d.dy))
+  }, [clamp])
+
+  const onHandleUp = useCallback((e: React.PointerEvent) => {
+    if (!dragRef.current) return
+    dragRef.current = null
+    e.currentTarget.releasePointerCapture?.(e.pointerId)
+    setPos((p) => {
+      if (p) {
+        try { localStorage.setItem(POS_KEY, JSON.stringify(p)) } catch { /* ignore */ }
+      }
+      return p
+    })
+  }, [])
+
+  // Render off-screen+hidden until the first position is computed (no flash).
+  const style: React.CSSProperties = pos
+    ? { left: pos.x, top: pos.y }
+    : { left: -9999, top: -9999, visibility: 'hidden' }
+
+  return (
+    <div ref={elRef} className="floating-mic" style={style}>
+      <div
+        className="floating-mic-handle"
+        onPointerDown={onHandleDown}
+        onPointerMove={onHandleMove}
+        onPointerUp={onHandleUp}
+        onPointerCancel={onHandleUp}
+        title="Drag to move"
+        aria-label="Drag floating mic"
+      >
+        <span className="floating-mic-grip" aria-hidden="true">⠿</span>
+        <button
+          type="button"
+          className="floating-mic-hide"
+          // Don't let a click on the hide button start a drag.
+          onPointerDown={(e) => e.stopPropagation()}
+          onClick={onHide}
+          title="Hide floating mic"
+          aria-label="Hide floating mic"
+        >
+          ×
+        </button>
+      </div>
+      <VoiceInput variant="floating" onTranscript={onTranscript} />
+    </div>
+  )
+}

package/src/renderer/components/SpeakControls.tsx

@@ -0,0 +1,235 @@
+import { useCallback, useEffect, useRef, useState } from 'react'
+import {
+  speech,
+  getEngine,
+  setEngine as persistEngine,
+  getVoiceURI,
+  setVoiceURI as persistVoiceURI,
+  getRate,
+  setRate as persistRate,
+  listWebVoices,
+  type TtsEngineId,
+  type TtsModelProgress,
+} from '../lib/speech'
+
+// Titlebar control for "speak agent replies" (Electron desktop only). A speaker
+// toggle drives the main-process speakReplies setting (which runs the transcript
+// tailer); a ▾ dropdown picks the engine, voice, and rate.
+
+const SAMPLE = 'This is how spoken agent replies will sound.'
+
+export function SpeakControls() {
+  const [enabled, setEnabled] = useState(false)
+  const [engine, setEngineState] = useState<TtsEngineId>(getEngine)
+  const [voices, setVoices] = useState<SpeechSynthesisVoice[]>([])
+  const [voiceURI, setVoiceURIState] = useState<string | null>(getVoiceURI)
+  const [rate, setRateState] = useState<number>(getRate)
+  const [showMenu, setShowMenu] = useState(false)
+  const [modelPct, setModelPct] = useState<number | null>(null)
+  const [speaking, setSpeaking] = useState(false)
+  const [error, setError] = useState<string | null>(null)
+  const wrapRef = useRef<HTMLDivElement>(null)
+
+  // Reflect the persisted main-process setting on mount.
+  useEffect(() => {
+    let alive = true
+    window.worker.getSpeakReplies().then((r) => { if (alive) setEnabled(!!r.enabled) }).catch(() => {})
+    return () => { alive = false }
+  }, [])
+
+  // Speak replies as they arrive. Main only forwards when the setting is on, so
+  // this is a no-op while disabled.
+  useEffect(() => {
+    const off = window.worker.onAgentMessage((text) => speech.enqueue(text))
+    return off
+  }, [])
+
+  // Surface neural-model download/transcribe progress on the button.
+  useEffect(() => {
+    speech.onModelProgress = (p: TtsModelProgress | null) => {
+      if (p && p.status === 'progress' && typeof p.progress === 'number') {
+        setModelPct(Math.min(100, Math.round(p.progress)))
+      } else if (!p) {
+        setModelPct(null)
+      }
+    }
+    speech.onActivityChange = (a) => setSpeaking(a)
+    speech.onError = (msg) => setError(msg)
+    return () => {
+      speech.onModelProgress = null
+      speech.onActivityChange = null
+      speech.onError = null
+    }
+  }, [])
+
+  // Auto-dismiss the error chip.
+  useEffect(() => {
+    if (!error) return
+    const t = setTimeout(() => setError(null), 4000)
+    return () => clearTimeout(t)
+  }, [error])
+
+  // Web Speech voices populate asynchronously.
+  useEffect(() => {
+    const load = () => setVoices(listWebVoices())
+    load()
+    if (typeof speechSynthesis !== 'undefined') {
+      speechSynthesis.addEventListener('voiceschanged', load)
+      return () => speechSynthesis.removeEventListener('voiceschanged', load)
+    }
+  }, [])
+
+  // Close the menu on an outside click.
+  useEffect(() => {
+    if (!showMenu) return
+    const onDown = (e: MouseEvent) => {
+      if (!wrapRef.current?.contains(e.target as Node)) setShowMenu(false)
+    }
+    document.addEventListener('mousedown', onDown)
+    return () => document.removeEventListener('mousedown', onDown)
+  }, [showMenu])
+
+  const toggle = useCallback(async () => {
+    const next = !enabled
+    setEnabled(next)
+    // Prime the audio context from this click so neural playback isn't blocked
+    // by autoplay policy when a reply later arrives without a gesture.
+    if (next) speech.unlock()
+    else speech.stop()
+    try { await window.worker.setSpeakReplies(next) } catch { /* ignore */ }
+  }, [enabled])
+
+  const chooseEngine = useCallback((id: TtsEngineId) => {
+    persistEngine(id)
+    setEngineState(id)
+    speech.stop()
+    // Preload the neural model so the first reply isn't slowed by download.
+    if (id === 'neural') speech.warmup()
+  }, [])
+
+  const chooseVoice = useCallback((uri: string) => {
+    const v = uri || null
+    persistVoiceURI(v)
+    setVoiceURIState(v)
+  }, [])
+
+  const changeRate = useCallback((r: number) => {
+    persistRate(r)
+    setRateState(r)
+  }, [])
+
+  const testVoice = useCallback(() => {
+    speech.unlock()
+    speech.stop()
+    speech.enqueue(SAMPLE)
+  }, [])
+
+  const title = enabled ? 'Spoken replies on — click to mute' : 'Speak agent replies (off)'
+
+  return (
+    <div className="speak-controls" ref={wrapRef}>
+      <button
+        type="button"
+        className={`titlebar-btn titlebar-icon-btn speak-btn ${enabled ? 'active' : ''}`}
+        onClick={toggle}
+        title={title}
+        aria-label="Toggle spoken agent replies"
+        aria-pressed={enabled}
+      >
+        <svg viewBox="0 0 24 24" width="13" height="13" 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" />
+          {enabled ? (
+            <>
+              <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" />
+            </>
+          ) : (
+            <line x1="23" y1="9" x2="17" y2="15" />
+          )}
+        </svg>
+        {modelPct !== null && <span className="speak-pct">{modelPct}%</span>}
+      </button>
+      {speaking && (
+        <button
+          type="button"
+          className="titlebar-btn titlebar-icon-btn speak-stop"
+          onClick={() => speech.stop()}
+          title="Stop speaking"
+          aria-label="Stop speaking"
+        >
+          <svg viewBox="0 0 24 24" width="11" height="11" fill="currentColor" aria-hidden="true">
+            <rect x="5" y="5" width="14" height="14" rx="2" />
+          </svg>
+        </button>
+      )}
+      <button
+        type="button"
+        className="titlebar-btn speak-caret"
+        onClick={() => setShowMenu((v) => !v)}
+        title="Voice options"
+        aria-label="Voice options"
+        aria-expanded={showMenu}
+      >
+        ▾
+      </button>
+
+      {showMenu && (
+        <div className="speak-menu" role="menu">
+          <div className="speak-menu-head">Engine</div>
+          <button
+            type="button"
+            className={`speak-menu-item ${engine === 'web' ? 'active' : ''}`}
+            onClick={() => chooseEngine('web')}
+          >
+            <span className="speak-menu-check">{engine === 'web' ? '✓' : ''}</span>
+            <span>System voice (instant)</span>
+          </button>
+          <button
+            type="button"
+            className={`speak-menu-item ${engine === 'neural' ? 'active' : ''}`}
+            onClick={() => chooseEngine('neural')}
+          >
+            <span className="speak-menu-check">{engine === 'neural' ? '✓' : ''}</span>
+            <span>Neural voice (downloads)</span>
+          </button>
+
+          {engine === 'web' && (
+            <>
+              <div className="speak-menu-head">Voice</div>
+              <select
+                className="speak-select"
+                value={voiceURI || ''}
+                onChange={(e) => chooseVoice(e.target.value)}
+              >
+                <option value="">System default</option>
+                {voices.map((v) => (
+                  <option key={v.voiceURI} value={v.voiceURI}>
+                    {v.name} {v.lang ? `(${v.lang})` : ''}
+                  </option>
+                ))}
+              </select>
+            </>
+          )}
+
+          <div className="speak-menu-head">Rate · {rate.toFixed(1)}×</div>
+          <input
+            className="speak-rate"
+            type="range"
+            min={0.5}
+            max={2}
+            step={0.1}
+            value={rate}
+            onChange={(e) => changeRate(Number(e.target.value))}
+          />
+
+          <div className="speak-menu-row">
+            <button type="button" className="speak-menu-btn" onClick={testVoice}>Test</button>
+            <button type="button" className="speak-menu-btn" onClick={() => speech.stop()}>Stop</button>
+          </div>
+        </div>
+      )}
+      {error && <div className="speak-error">{error}</div>}
+    </div>
+  )
+}

package/src/renderer/components/VoiceInput.tsx

@@ -43,6 +43,12 @@ 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.
+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 =
@@ -76,9 +82,12 @@ function describeMicError(err: unknown): string {
 interface VoiceInputProps {
   // Called once per push-to-talk session with the final transcribed text.
   onTranscript: (text: string) => void
+  // 'titlebar' (default) renders the compact titlebar pill; 'floating' renders
+  // a round FAB used by the draggable on-canvas mic (see FloatingMic).
+  variant?: 'titlebar' | 'floating'
 }
 
-export function VoiceInput({ onTranscript }: VoiceInputProps) {
+export function VoiceInput({ onTranscript, variant = 'titlebar' }: VoiceInputProps) {
   const [engine, setEngine] = useState<Engine>(loadInitialEngine)
   const [phase, setPhase] = useState<Phase>('idle')
   const [interim, setInterim] = useState('')
@@ -86,6 +95,14 @@ export function VoiceInput({ onTranscript }: VoiceInputProps) {
   const [error, setError] = useState<string | null>(null)
   const [notice, setNotice] = useState<string | null>(null)
 
+  // Mic source selection (local engine only)
+  const [devices, setDevices] = useState<MediaDeviceInfo[]>([])
+  const [selectedDeviceId, setSelectedDeviceId] = useState<string | null>(loadDeviceId)
+  const [showDevicePicker, setShowDevicePicker] = useState(false)
+  const selectedDeviceIdRef = useRef(selectedDeviceId)
+  useEffect(() => { selectedDeviceIdRef.current = selectedDeviceId }, [selectedDeviceId])
+  const wrapRef = useRef<HTMLDivElement>(null)
+
   // Web Speech refs
   const recognitionRef = useRef<SpeechRecognitionLike | null>(null)
   const finalRef = useRef('')
@@ -125,6 +142,88 @@ export function VoiceInput({ onTranscript }: VoiceInputProps) {
     streamRef.current = null
   }, [])
 
+  // ─── Mic source selection ──────────────────────────
+
+  const refreshDevices = useCallback(async () => {
+    if (!navigator.mediaDevices?.enumerateDevices) return
+    try {
+      const all = await navigator.mediaDevices.enumerateDevices()
+      setDevices(all.filter((d) => d.kind === 'audioinput'))
+    } catch { /* ignore */ }
+  }, [])
+
+  // Device labels are blank until mic permission is granted, so when the user
+  // opens the picker we request a one-shot permission to populate names.
+  const ensureDeviceLabels = useCallback(async () => {
+    if (!navigator.mediaDevices?.enumerateDevices) return
+    try {
+      const all = await navigator.mediaDevices.enumerateDevices()
+      const inputs = all.filter((d) => d.kind === 'audioinput')
+      if (inputs.length && inputs.every((d) => !d.label)) {
+        const s = await navigator.mediaDevices.getUserMedia({ audio: true })
+        s.getTracks().forEach((t) => t.stop())
+      }
+    } catch { /* permission denied → we'll show generic names */ }
+    await refreshDevices()
+  }, [refreshDevices])
+
+  const toggleDevicePicker = useCallback(() => {
+    setShowDevicePicker((open) => !open)
+  }, [])
+
+  // Populate device labels whenever the picker opens (needs mic permission).
+  useEffect(() => {
+    if (showDevicePicker) void ensureDeviceLabels()
+  }, [showDevicePicker, ensureDeviceLabels])
+
+  const chooseDevice = useCallback((id: string | null) => {
+    setSelectedDeviceId(id)
+    try {
+      if (id) localStorage.setItem(DEVICE_KEY, id)
+      else localStorage.removeItem(DEVICE_KEY)
+    } catch { /* ignore */ }
+    setShowDevicePicker(false)
+  }, [])
+
+  // Acquire a stream honoring the saved device, gracefully falling back to the
+  // OS default if that device was unplugged since it was chosen.
+  const getStream = useCallback(async (): Promise<MediaStream> => {
+    const id = selectedDeviceIdRef.current
+    try {
+      return await navigator.mediaDevices.getUserMedia({
+        audio: id ? { deviceId: { exact: id } } : true,
+      })
+    } catch (err) {
+      if (id && (err as { name?: string })?.name === 'OverconstrainedError') {
+        try { localStorage.removeItem(DEVICE_KEY) } catch { /* ignore */ }
+        setSelectedDeviceId(null)
+        setNotice('Saved microphone unavailable — using system default.')
+        return navigator.mediaDevices.getUserMedia({ audio: true })
+      }
+      throw err
+    }
+  }, [])
+
+  // Keep the list fresh when devices are plugged/unplugged.
+  useEffect(() => {
+    const md = navigator.mediaDevices
+    if (!md?.addEventListener) return
+    const onChange = () => { void refreshDevices() }
+    md.addEventListener('devicechange', onChange)
+    void refreshDevices()
+    return () => md.removeEventListener('devicechange', onChange)
+  }, [refreshDevices])
+
+  // Close the picker on an outside click.
+  useEffect(() => {
+    if (!showDevicePicker) return
+    const onDocDown = (e: MouseEvent) => {
+      if (!wrapRef.current?.contains(e.target as Node)) setShowDevicePicker(false)
+    }
+    document.addEventListener('mousedown', onDocDown)
+    return () => document.removeEventListener('mousedown', onDocDown)
+  }, [showDevicePicker])
+
   // ─── Web Speech engine ─────────────────────────────
 
   const startWebSpeech = useCallback(() => {
@@ -204,6 +303,7 @@ export function VoiceInput({ onTranscript }: VoiceInputProps) {
     try {
       const text = await transcribeBlob(blob, handleModelProgress)
       if (text) onTranscriptRef.current(text)
+      else setNotice('No speech detected — check the mic source (▾).')
     } catch (err) {
       setError('On-device transcription failed')
       console.error('[voice] local transcription failed', err)
@@ -217,7 +317,7 @@ export function VoiceInput({ onTranscript }: VoiceInputProps) {
     setError(null); setNotice(null); setInterim('')
     cancelGestureRef.current = false
     try {
-      const stream = await navigator.mediaDevices.getUserMedia({ audio: true })
+      const stream = await getStream()
       // Released during the permission/await — don't record anything.
       if (cancelGestureRef.current) {
         stream.getTracks().forEach((t) => t.stop())
@@ -238,7 +338,7 @@ export function VoiceInput({ onTranscript }: VoiceInputProps) {
       setError(describeMicError(err))
       console.error('[voice] getUserMedia failed', err)
     }
-  }, [runLocalTranscription, stopStream])
+  }, [runLocalTranscription, stopStream, getStream])
 
   const stopLocal = useCallback(() => {
     cancelGestureRef.current = true
@@ -291,11 +391,31 @@ export function VoiceInput({ onTranscript }: VoiceInputProps) {
   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…' }
 
+  const floating = variant === 'floating'
+  const btnClass = floating
+    ? `voice-btn voice-btn-floating ${listening ? 'listening' : ''} ${busy ? 'busy' : ''}`
+    : `titlebar-btn titlebar-icon-btn voice-btn ${listening ? 'listening' : ''} ${busy ? 'busy' : ''}`
+
+  // Hide Chromium's synthetic "default"/"communications" aggregate entries from
+  // the list; we expose our own "System default" item instead.
+  const realDevices = devices.filter(
+    (d) => d.deviceId && d.deviceId !== 'default' && d.deviceId !== 'communications',
+  )
+  const rawDefault = devices.find((d) => d.deviceId === 'default')?.label
+  const defaultLabel = rawDefault
+    ? `System default · ${rawDefault.replace(/^Default\s*-\s*/i, '')}`
+    : 'System default'
+  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 (
-    <div className="voice-input-wrap">
+    <div className="voice-input-wrap" ref={wrapRef}>
       <button
         type="button"
-        className={`titlebar-btn titlebar-icon-btn voice-btn ${listening ? 'listening' : ''} ${busy ? 'busy' : ''}`}
+        className={btnClass}
         disabled={!ANY_SUPPORTED}
         onPointerDown={handlePointerDown}
         onPointerUp={handlePointerUp}
@@ -307,7 +427,51 @@ export function VoiceInput({ onTranscript }: VoiceInputProps) {
         <span className="voice-icon" aria-hidden="true">🎤</span>
         <span className={`voice-dot ${listening ? 'on' : busy ? 'busy' : 'off'}`} />
       </button>
-      {chip && <div className={`voice-chip ${chip.kind}`}>{chip.text}</div>}
+      {showSourcePicker && (
+        <button
+          type="button"
+          className="voice-source-btn"
+          onPointerDown={(e) => e.stopPropagation()}
+          onClick={toggleDevicePicker}
+          title={`Mic source: ${activeLabel}`}
+          aria-label="Choose microphone source"
+          aria-expanded={showDevicePicker}
+        >
+          ▾
+        </button>
+      )}
+      {showSourcePicker && showDevicePicker && (
+        <div className="voice-source-menu" role="menu">
+          <div className="voice-source-head">Microphone source</div>
+          <button
+            type="button"
+            role="menuitemradio"
+            aria-checked={selectedDeviceId === null}
+            className={`voice-source-item ${selectedDeviceId === null ? 'active' : ''}`}
+            onClick={() => chooseDevice(null)}
+          >
+            <span className="voice-source-check">{selectedDeviceId === null ? '✓' : ''}</span>
+            <span className="voice-source-label">{defaultLabel}</span>
+          </button>
+          {realDevices.map((d, i) => (
+            <button
+              key={d.deviceId}
+              type="button"
+              role="menuitemradio"
+              aria-checked={selectedDeviceId === d.deviceId}
+              className={`voice-source-item ${selectedDeviceId === d.deviceId ? 'active' : ''}`}
+              onClick={() => chooseDevice(d.deviceId)}
+            >
+              <span className="voice-source-check">{selectedDeviceId === d.deviceId ? '✓' : ''}</span>
+              <span className="voice-source-label">{d.label || `Microphone ${i + 1}`}</span>
+            </button>
+          ))}
+          {realDevices.length === 0 && (
+            <div className="voice-source-empty">No microphones found</div>
+          )}
+        </div>
+      )}
+      {chip && <div className={`voice-chip ${chip.kind} ${floating ? 'voice-chip-floating' : ''}`}>{chip.text}</div>}
     </div>
   )
 }

package/src/renderer/lib/localWhisper.ts

@@ -6,6 +6,37 @@
 const MODEL = 'Xenova/whisper-base'
 const TARGET_SAMPLE_RATE = 16000
 
+// Whisper hallucinates filler tokens ("you", "Thank you.", "Thanks for
+// watching.") when fed silence. Two guards below tame that:
+//  - Below SILENCE_RMS we treat the clip as silent and skip the model entirely.
+//  - Between SILENCE_RMS and LOW_CONFIDENCE_RMS we still run the model but drop
+//    the result if it's *only* a known filler phrase (likely a hallucination on
+//    a quiet clip rather than real speech).
+const SILENCE_RMS = 0.008
+const LOW_CONFIDENCE_RMS = 0.02
+const FILLER_PHRASES = new Set([
+  'you',
+  'thank you',
+  'thank you very much',
+  'thank you for watching',
+  'thanks for watching',
+  'please subscribe',
+])
+
+// Root-mean-square amplitude of the clip — a cheap loudness proxy. Normalized
+// speech sits around 0.05–0.15; a silent room is well under 0.005.
+function computeRms(pcm: Float32Array): number {
+  if (pcm.length === 0) return 0
+  let sum = 0
+  for (let i = 0; i < pcm.length; i++) sum += pcm[i] * pcm[i]
+  return Math.sqrt(sum / pcm.length)
+}
+
+function isFillerOnly(text: string): boolean {
+  const norm = text.toLowerCase().replace(/[.!?,…"']/g, '').replace(/\s+/g, ' ').trim()
+  return FILLER_PHRASES.has(norm)
+}
+
 export interface ModelProgress {
   status: string
   file?: string
@@ -77,12 +108,25 @@ async function blobToPcm16k(blob: Blob): Promise<Float32Array | null> {
 }
 
 export async function transcribeBlob(blob: Blob, onProgress?: (p: ModelProgress) => void): Promise<string> {
-  const transcriber = await loadTranscriber(onProgress)
+  // Decode first so a silent clip never triggers the (one-time, ~75MB) model
+  // download just to be thrown away below.
   const pcm = await blobToPcm16k(blob)
   if (!pcm) return ''
+  const rms = computeRms(pcm)
+  if (rms < SILENCE_RMS) {
+    console.info(`[voice] near-silent clip (rms=${rms.toFixed(4)}); skipping transcription`)
+    return ''
+  }
+
+  const transcriber = await loadTranscriber(onProgress)
   const result = await transcriber(pcm)
-  const text = Array.isArray(result)
+  const text = (Array.isArray(result)
     ? result.map((r) => r.text).join(' ')
-    : result?.text
-  return (text || '').trim()
+    : result?.text || '').trim()
+
+  if (text && rms < LOW_CONFIDENCE_RMS && isFillerOnly(text)) {
+    console.info(`[voice] dropping filler-only output "${text}" from quiet clip (rms=${rms.toFixed(4)})`)
+    return ''
+  }
+  return text
 }