diff --git a/Cargo.lock b/Cargo.lock
index 32689b56..ae2fb99f 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -728,6 +728,7 @@ dependencies = [
  "coldvox-telemetry",
  "cpal",
  "dasp",
+ "libc",
  "parking_lot",
  "rtrb",
  "rubato",
@@ -2222,9 +2223,9 @@ checksum = "bbd2bcb4c963f2ddae06a2efc7e9f3591312473c50c6685e1f298068316e66fe"
 
 [[package]]
 name = "libc"
-version = "0.2.175"
+version = "0.2.176"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6a82ae493e598baaea5209805c49bbf2ea7de956d50d7da0da1164f9c6d28543"
+checksum = "58f929b4d672ea937a23a1ab494143d968337a5f47e56d0815df1e0890ddf174"
 
 [[package]]
 name = "libredox"
diff --git a/crates/app/src/audio/mod.rs b/crates/app/src/audio/mod.rs
index 7265496d..628e15d8 100644
--- a/crates/app/src/audio/mod.rs
+++ b/crates/app/src/audio/mod.rs
@@ -1,14 +1,2 @@
 pub mod vad_adapter;
 pub mod vad_processor;
-
-// Re-export modules from coldvox-audio crate
-pub use coldvox_audio::{
-    capture::CaptureStats,
-    chunker::{AudioChunker, ChunkerConfig, ResamplerQuality},
-    frame_reader::FrameReader,
-    ring_buffer::{AudioProducer, AudioRingBuffer},
-};
-
-pub use coldvox_audio::AudioFrame;
-pub use vad_adapter::*;
-pub use vad_processor::*;
diff --git a/crates/app/src/audio/vad_processor.rs b/crates/app/src/audio/vad_processor.rs
index b34417af..8a6971c5 100644
--- a/crates/app/src/audio/vad_processor.rs
+++ b/crates/app/src/audio/vad_processor.rs
@@ -86,7 +86,7 @@ impl VadProcessor {
                         timestamp_ms,
                         energy_db,
                     } => {
-                        info!(
+                        debug!(
                             "VAD: Speech started at {}ms (energy: {:.2} dB)",
                             timestamp_ms, energy_db
                         );
@@ -96,7 +96,7 @@ impl VadProcessor {
                         duration_ms,
                         energy_db,
                     } => {
-                        info!(
+                        debug!(
                             "VAD: Speech ended at {}ms (duration: {}ms, energy: {:.2} dB)",
                             timestamp_ms, duration_ms, energy_db
                         );
@@ -126,14 +126,14 @@ impl VadProcessor {
 
         self.frames_processed += 1;
 
-        if self.frames_processed % 100 == 0 {
+        if self.frames_processed.is_multiple_of(100) {
             tracing::debug!(
                 "VAD: Received {} frames, processing active",
                 self.frames_processed
             );
         }
 
-        if self.frames_processed % 1000 == 0 {
+        if self.frames_processed.is_multiple_of(1000) {
             debug!(
                 "VAD processor: {} frames processed, {} events generated, current state: {:?}",
                 self.frames_processed,
diff --git a/crates/app/src/lib.rs b/crates/app/src/lib.rs
index 8adec33c..09b82e3e 100644
--- a/crates/app/src/lib.rs
+++ b/crates/app/src/lib.rs
@@ -413,3 +413,6 @@ pub mod text_injection;
 #[cfg(feature = "tui")]
 pub mod tui;
 pub mod vad;
+
+#[cfg(test)]
+pub mod test_utils;
diff --git a/crates/app/src/main.rs b/crates/app/src/main.rs
index c98ac618..f39461ce 100644
--- a/crates/app/src/main.rs
+++ b/crates/app/src/main.rs
@@ -12,8 +12,8 @@ use clap::Parser;
 use tracing_appender::rolling::{RollingFileAppender, Rotation};
 use tracing_subscriber::{fmt, prelude::*, EnvFilter};
 
-use coldvox_app::runtime::{self as app_runtime, ActivationMode as RuntimeMode, AppRuntimeOptions};
 use coldvox_app::Settings;
+use coldvox_app::runtime::{self as app_runtime, ActivationMode as RuntimeMode, AppRuntimeOptions};
 use coldvox_audio::{DeviceManager, ResamplerQuality};
 use coldvox_foundation::{AppState, HealthMonitor, ShutdownHandler, StateManager};
 
@@ -205,6 +205,7 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
         resampler_quality,
         activation_mode,
         stt_selection,
+        enable_device_monitor: settings.enable_device_monitor,
         ..Default::default()
     };
     #[cfg(feature = "text-injection")]
@@ -212,14 +213,13 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
         opts.injection = if cfg!(feature = "text-injection") {
             Some(coldvox_app::runtime::InjectionOptions {
                 enable: true, // Assuming text injection is enabled if the feature is on
-                allow_ydotool: false, // Default to false, can be configured later
                 allow_kdotool: settings.injection.allow_kdotool,
                 allow_enigo: settings.injection.allow_enigo,
                 inject_on_unknown_focus: settings.injection.inject_on_unknown_focus,
-                restore_clipboard: true, // Default to true for safety
                 max_total_latency_ms: Some(settings.injection.max_total_latency_ms),
                 per_method_timeout_ms: Some(settings.injection.per_method_timeout_ms),
                 cooldown_initial_ms: Some(settings.injection.cooldown_initial_ms),
+                fail_fast: settings.injection.fail_fast,
             })
         } else {
             None
diff --git a/crates/coldvox-audio/Cargo.toml b/crates/coldvox-audio/Cargo.toml
index c9ad7ec0..5a4f0b79 100644
--- a/crates/coldvox-audio/Cargo.toml
+++ b/crates/coldvox-audio/Cargo.toml
@@ -18,6 +18,7 @@ tokio = { version = "1.35", features = ["sync", "rt"] }
 tracing = "0.1"
 anyhow = "1.0"
 thiserror = "2.0"
+libc = "0.2.176"
 
 [features]
 default = []
diff --git a/crates/coldvox-audio/docs/design-user-config.md b/crates/coldvox-audio/docs/design-user-config.md
index 5252d1f3..82d8c1d2 100644
--- a/crates/coldvox-audio/docs/design-user-config.md
+++ b/crates/coldvox-audio/docs/design-user-config.md
@@ -110,7 +110,6 @@ COLDVOX_STT_METRICS_LOG_INTERVAL_SECS=60
 ```bash
 # CLI
 --enable-text-injection
---allow-ydotool
 --allow-kdotool
 --allow-enigo
 
@@ -125,11 +124,11 @@ COLDVOX_ALLOW_ENIGO=true
 ```bash
 # CLI
 --inject-on-unknown-focus
---restore-clipboard
 
 # Environment
 COLDVOX_INJECT_ON_UNKNOWN_FOCUS=true
-COLDVOX_RESTORE_CLIPBOARD=true
+
+Note: clipboard restoration is automatic after injection; `COLDVOX_RESTORE_CLIPBOARD` is ignored.
 ```
 
 ### Performance Limits
@@ -276,4 +275,4 @@ RUST_LOG=debug \
 COLDVOX_STT_DEBUG_DUMP_EVENTS=true \
 COLDVOX_STT_METRICS_LOG_INTERVAL_SECS=10 \
 cargo run -- --tui
-```
\ No newline at end of file
+```
diff --git a/crates/coldvox-audio/src/capture.rs b/crates/coldvox-audio/src/capture.rs
index 480d6775..0b1e0ada 100644
--- a/crates/coldvox-audio/src/capture.rs
+++ b/crates/coldvox-audio/src/capture.rs
@@ -48,8 +48,9 @@ pub struct AudioCaptureThread {
 impl AudioCaptureThread {
     pub fn spawn(
         config: AudioConfig,
-        audio_producer: AudioProducer,
+        audio_producer: Arc<Mutex<AudioProducer>>,
         device_name: Option<String>,
+        enable_device_monitor: bool,
     ) -> Result<
         (
             Self,
@@ -59,7 +60,11 @@ impl AudioCaptureThread {
         ),
         AudioError,
     > {
-        let running = Arc::new(AtomicBool::new(false));
+        // Start in running state so the device monitor thread stays alive
+        // until we explicitly stop via `stop()`. Previously this was false,
+        // causing the monitor to exit immediately and the capture loop to
+        // detect a closed channel and terminate early.
+        let running = Arc::new(AtomicBool::new(true));
         let shutdown = running.clone();
         let device_config = Arc::new(RwLock::new(None::<DeviceConfig>));
         let device_config_clone = device_config.clone();
@@ -72,14 +77,21 @@ impl AudioCaptureThread {
         let (device_event_tx, device_event_rx) = tokio::sync::broadcast::channel(32);
         let device_event_tx_clone = device_event_tx.clone();
 
-        // Start device monitor
-        let (device_monitor, mut monitor_rx) = DeviceMonitor::new(Duration::from_millis(500))?;
+        // Start device monitor with 2-second interval to reduce false positives from CPAL enumeration glitches
         let monitor_running = running.clone();
-        let monitor_handle = device_monitor.start_monitoring(monitor_running);
+        let (monitor_rx_opt, monitor_handle) = if enable_device_monitor {
+            let (device_monitor, monitor_rx) = DeviceMonitor::new(Duration::from_secs(2))?;
+            let handle = device_monitor.start_monitoring(monitor_running);
+            (Some(monitor_rx), Some(handle))
+        } else {
+            tracing::debug!("Device monitor disabled; skipping hotplug polling");
+            (None, None)
+        };
 
         let handle = thread::Builder::new()
             .name("audio-capture".to_string())
             .spawn(move || {
+                let mut monitor_rx = monitor_rx_opt;
                 let mut capture = match AudioCapture::new(config, audio_producer, running.clone()) {
                     Ok(c) => c.with_config_channel(config_tx_clone)
                               .with_device_event_channel(device_event_tx_clone),
@@ -144,40 +156,42 @@ impl AudioCaptureThread {
                     let mut restart_reason = "unknown";
 
                     // Check for device monitor events
-                    match monitor_rx.try_recv() {
-                        Ok(event) => {
-                            tracing::debug!("Device event: {:?}", event);
-                            let _ = capture.device_event_tx.as_ref().map(|tx| tx.send(event.clone()));
-
-                            match event {
-                                DeviceEvent::CurrentDeviceDisconnected { name } => {
-                                    if capture.current_device_name.as_ref() == Some(&name) {
-                                        tracing::warn!("Current device {} disconnected, attempting recovery", name);
+                    if let Some(rx) = monitor_rx.as_mut() {
+                        match rx.try_recv() {
+                            Ok(event) => {
+                                tracing::debug!("Device event: {:?}", event);
+                                let _ = capture.device_event_tx.as_ref().map(|tx| tx.send(event.clone()));
+
+                                match event {
+                                    DeviceEvent::CurrentDeviceDisconnected { name } => {
+                                        if capture.current_device_name.as_ref() == Some(&name) {
+                                            tracing::warn!("Current device {} disconnected, attempting recovery", name);
+                                            needs_restart = true;
+                                            restart_reason = "device disconnected";
+                                        }
+                                    }
+                                    DeviceEvent::DeviceAdded { name } => {
+                                        tracing::info!("New device available: {}", name);
+                                        // Could implement automatic switching to preferred devices here
+                                    }
+                                    DeviceEvent::DeviceSwitchRequested { target } => {
+                                        tracing::info!("Manual device switch requested to: {}", target);
                                         needs_restart = true;
-                                        restart_reason = "device disconnected";
+                                        restart_reason = "manual device switch requested";
                                     }
+                                    _ => {}
                                 }
-                                DeviceEvent::DeviceAdded { name } => {
-                                    tracing::info!("New device available: {}", name);
-                                    // Could implement automatic switching to preferred devices here
-                                }
-                                DeviceEvent::DeviceSwitchRequested { target } => {
-                                    tracing::info!("Manual device switch requested to: {}", target);
-                                    needs_restart = true;
-                                    restart_reason = "manual device switch requested";
-                                }
-                                _ => {}
                             }
-                        }
-                        Err(tokio::sync::broadcast::error::TryRecvError::Empty) => {
-                            // No events, continue
-                        }
-                        Err(tokio::sync::broadcast::error::TryRecvError::Lagged(_)) => {
-                            tracing::warn!("Device monitor events lagged, some events may have been missed");
-                        }
-                        Err(tokio::sync::broadcast::error::TryRecvError::Closed) => {
-                            tracing::error!("Device monitor channel closed");
-                            break;
+                            Err(tokio::sync::broadcast::error::TryRecvError::Empty) => {
+                                // No events, continue
+                            }
+                            Err(tokio::sync::broadcast::error::TryRecvError::Lagged(_)) => {
+                                tracing::warn!("Device monitor events lagged, some events may have been missed");
+                            }
+                            Err(tokio::sync::broadcast::error::TryRecvError::Closed) => {
+                                tracing::error!("Device monitor channel closed");
+                                break;
+                            }
                         }
                     }
 
@@ -240,7 +254,7 @@ impl AudioCaptureThread {
                     thread::sleep(Duration::from_millis(100));
                 }
 
-                tracing::info!("Audio capture thread shutting down.");
+                tracing::debug!("Audio capture thread shutting down.");
                 capture.stop();
             })
             .map_err(|e| AudioError::Fatal(format!("Failed to spawn audio thread: {}", e)))?;
@@ -264,7 +278,7 @@ impl AudioCaptureThread {
             Self {
                 handle,
                 shutdown,
-                device_monitor_handle: Some(monitor_handle),
+                device_monitor_handle: monitor_handle,
             },
             cfg,
             config_rx,
@@ -303,13 +317,13 @@ pub struct CaptureStats {
 impl AudioCapture {
     pub fn new(
         config: AudioConfig,
-        audio_producer: AudioProducer,
+        audio_producer: Arc<Mutex<AudioProducer>>,
         running: Arc<AtomicBool>,
     ) -> Result<Self, AudioError> {
         let self_ = Self {
             device_manager: DeviceManager::new()?,
             stream: None,
-            audio_producer: Arc::new(Mutex::new(audio_producer)),
+            audio_producer,
             watchdog: WatchdogTimer::new(Duration::from_secs(5)),
             silence_detector: SilenceDetector::new(config.silence_threshold),
             stats: Arc::new(CaptureStats::default()),
diff --git a/crates/coldvox-audio/src/detector.rs b/crates/coldvox-audio/src/detector.rs
index b36f829e..e3abec8c 100644
--- a/crates/coldvox-audio/src/detector.rs
+++ b/crates/coldvox-audio/src/detector.rs
@@ -23,10 +23,18 @@ impl SilenceDetector {
         let sum: i64 = samples.iter().map(|&s| s as i64 * s as i64).sum();
         let rms = ((sum / samples.len() as i64) as f64).sqrt() as i16;
 
+        // Log RMS every time to see actual audio levels (use trace level to avoid spam)
+        tracing::trace!(
+            "SilenceDetector: RMS={}, threshold={}, samples={}",
+            rms,
+            self.threshold,
+            samples.len()
+        );
+
         if rms < self.threshold {
             if self.silence_start.is_none() {
                 self.silence_start = Some(Instant::now());
-                tracing::debug!(
+                tracing::info!(
                     "SilenceDetector: Silence started (RMS {} < threshold {})",
                     rms,
                     self.threshold
@@ -36,7 +44,7 @@ impl SilenceDetector {
         } else {
             if self.silence_start.is_some() {
                 let duration = self.silence_duration();
-                tracing::debug!(
+                tracing::info!(
                     "SilenceDetector: Silence ended after {:?} (RMS {} >= threshold {})",
                     duration,
                     rms,
diff --git a/crates/coldvox-audio/src/device.rs b/crates/coldvox-audio/src/device.rs
index 02c00d7f..6cacae26 100644
--- a/crates/coldvox-audio/src/device.rs
+++ b/crates/coldvox-audio/src/device.rs
@@ -2,21 +2,55 @@ use coldvox_foundation::AudioError;
 use cpal::traits::{DeviceTrait, HostTrait};
 use cpal::{Device, Host, StreamConfig};
 use std::process::Command;
+use std::sync::Mutex;
+use std::time::{Duration, Instant};
+
+#[cfg(unix)]
+use crate::stderr_suppressor::StderrSuppressor;
+
+const DEVICE_CACHE_TTL: Duration = Duration::from_secs(5);
+
+/// Helper to suppress stderr on Unix, no-op on other platforms
+#[cfg(unix)]
+fn with_stderr_suppressed<F, R>(f: F) -> R
+where
+    F: FnOnce() -> R,
+{
+    StderrSuppressor::with_suppressed(f)
+}
+
+#[cfg(not(unix))]
+fn with_stderr_suppressed<F, R>(f: F) -> R
+where
+    F: FnOnce() -> R,
+{
+    f()
+}
+
+struct DeviceCache {
+    devices: Vec<DeviceInfo>,
+    last_updated: Option<Instant>,
+}
 
 pub struct DeviceManager {
     host: Host,
     #[allow(dead_code)]
     preferred_device: Option<String>,
     current_device: Option<Device>,
+    cached_devices: Mutex<DeviceCache>,
 }
 
 impl DeviceManager {
     pub fn new() -> Result<Self, AudioError> {
-        let host = cpal::default_host();
+        let host = with_stderr_suppressed(cpal::default_host);
         Ok(Self {
             host,
             preferred_device: None,
             current_device: None,
+            cached_devices: Mutex::new(DeviceCache {
+                devices: Vec::new(),
+                last_updated: None,
+            }),
         })
     }
 
@@ -57,10 +91,36 @@ impl DeviceManager {
     }
 
     pub fn enumerate_devices(&self) -> Vec<DeviceInfo> {
+        {
+            let cache = self.cached_devices.lock().unwrap();
+            if let Some(last) = cache.last_updated {
+                if last.elapsed() < DEVICE_CACHE_TTL {
+                    return cache.devices.clone();
+                }
+            }
+        }
+
+        let devices = self.enumerate_devices_uncached();
+        let mut cache = self.cached_devices.lock().unwrap();
+        cache.devices = devices.clone();
+        cache.last_updated = Some(Instant::now());
+        devices
+    }
+
+    pub fn refresh_devices(&self) -> Vec<DeviceInfo> {
+        let devices = self.enumerate_devices_uncached();
+        let mut cache = self.cached_devices.lock().unwrap();
+        cache.devices = devices.clone();
+        cache.last_updated = Some(Instant::now());
+        devices
+    }
+
+    fn enumerate_devices_uncached(&self) -> Vec<DeviceInfo> {
         let mut devices = Vec::new();
 
-        // Input devices
-        if let Ok(inputs) = self.host.input_devices() {
+        // Input devices - suppress ALSA stderr spam about missing PCM plugins
+        let inputs = with_stderr_suppressed(|| self.host.input_devices());
+        if let Ok(inputs) = inputs {
             for device in inputs {
                 if let Ok(name) = device.name() {
                     let configs = self.get_supported_configs(&device);
@@ -75,8 +135,9 @@ impl DeviceManager {
             }
         }
 
-        // Mark default
-        if let Some(default) = self.host.default_input_device() {
+        // Mark default - suppress ALSA stderr spam
+        let default_device = with_stderr_suppressed(|| self.host.default_input_device());
+        if let Some(default) = default_device {
             if let Ok(default_name) = default.name() {
                 for device in &mut devices {
                     if device.name == default_name {
@@ -90,7 +151,9 @@ impl DeviceManager {
     }
 
     pub fn default_input_device_name(&self) -> Option<String> {
-        self.host.default_input_device().and_then(|d| d.name().ok())
+        with_stderr_suppressed(|| {
+            self.host.default_input_device().and_then(|d| d.name().ok())
+        })
     }
 
     /// Return candidate device names in a priority order suitable for Linux ALSA/PipeWire setups.
@@ -110,7 +173,12 @@ impl DeviceManager {
         }
 
         // 3) OS default input name if not already added
-        if let Some(def) = self.default_input_device_name() {
+        if let Some(def) = all
+            .iter()
+            .find(|d| d.is_default)
+            .map(|d| d.name.clone())
+            .or_else(|| self.default_input_device_name())
+        {
             if !out.iter().any(|n| n == &def) {
                 out.push(def);
             }
@@ -446,7 +514,7 @@ mod tests {
                 *first == "default"
                     || manager
                         .default_input_device_name()
-                        .map_or(false, |d| first == &d),
+                        .is_some_and(|d| first == &d),
                 "First should be 'default' or OS default"
             );
         }
diff --git a/crates/coldvox-audio/src/lib.rs b/crates/coldvox-audio/src/lib.rs
index 07db96bb..338f7dd0 100644
--- a/crates/coldvox-audio/src/lib.rs
+++ b/crates/coldvox-audio/src/lib.rs
@@ -6,6 +6,8 @@ pub mod frame_reader;
 pub mod monitor;
 pub mod resampler;
 pub mod ring_buffer;
+#[cfg(unix)]
+pub mod stderr_suppressor;
 pub mod watchdog;
 
 // Public API
diff --git a/crates/coldvox-audio/src/monitor.rs b/crates/coldvox-audio/src/monitor.rs
index cc946606..6093093c 100644
--- a/crates/coldvox-audio/src/monitor.rs
+++ b/crates/coldvox-audio/src/monitor.rs
@@ -17,6 +17,8 @@ pub struct DeviceMonitor {
     last_devices: HashMap<String, DeviceStatus>,
     current_device: Option<String>,
     preferred_devices: Vec<String>,
+    // Track how many consecutive scans a device has been missing
+    missing_count: HashMap<String, u32>,
 }
 
 impl DeviceMonitor {
@@ -33,6 +35,7 @@ impl DeviceMonitor {
             last_devices: HashMap::new(),
             current_device: None,
             preferred_devices: Vec::new(),
+            missing_count: HashMap::new(),
         };
 
         Ok((monitor, event_rx))
@@ -67,7 +70,7 @@ impl DeviceMonitor {
                     thread::sleep(self.monitor_interval);
                 }
 
-                info!("Device monitor stopping");
+                debug!("Device monitor stopping");
             })
             .expect("Failed to spawn device monitor thread")
     }
@@ -120,21 +123,44 @@ impl DeviceMonitor {
             new_device_map.insert(name, status);
         }
 
-        // Check for removed devices
+        // Check for removed devices (with debouncing to prevent false positives)
+        const REMOVAL_THRESHOLD: u32 = 3; // Device must be missing for 3 consecutive scans
+
         for (old_name, old_status) in &self.last_devices {
             if !new_device_map.contains_key(old_name) {
-                debug!("Device removed: {}", old_name);
-                let _ = self.event_tx.send(DeviceEvent::DeviceRemoved {
-                    name: old_name.clone(),
-                });
-
-                // If current device was removed, signal disconnection
-                if old_status.is_current {
-                    warn!("Current device disconnected: {}", old_name);
-                    let _ = self.event_tx.send(DeviceEvent::CurrentDeviceDisconnected {
+                // Increment missing count
+                let count = self.missing_count.entry(old_name.clone()).or_insert(0);
+                *count += 1;
+
+                debug!(
+                    "Device '{}' not seen in scan (missing {} times)",
+                    old_name, count
+                );
+
+                // Only emit removal events after threshold
+                if *count >= REMOVAL_THRESHOLD {
+                    warn!(
+                        "Device removed after {} consecutive absences: {}",
+                        REMOVAL_THRESHOLD, old_name
+                    );
+                    let _ = self.event_tx.send(DeviceEvent::DeviceRemoved {
                         name: old_name.clone(),
                     });
+
+                    // If current device was removed, signal disconnection
+                    if old_status.is_current {
+                        warn!("Current device disconnected: {}", old_name);
+                        let _ = self.event_tx.send(DeviceEvent::CurrentDeviceDisconnected {
+                            name: old_name.clone(),
+                        });
+                    }
+
+                    // Clear from missing count after emitting removal
+                    self.missing_count.remove(old_name);
                 }
+            } else {
+                // Device reappeared, reset missing count
+                self.missing_count.remove(old_name);
             }
         }
 
diff --git a/crates/coldvox-audio/src/stderr_suppressor.rs b/crates/coldvox-audio/src/stderr_suppressor.rs
new file mode 100644
index 00000000..54bf8477
--- /dev/null
+++ b/crates/coldvox-audio/src/stderr_suppressor.rs
@@ -0,0 +1,102 @@
+/// Utility to temporarily suppress stderr output from ALSA/CPAL library calls
+/// that produce noisy warnings about missing PCM plugins (pulse, jack, oss, etc.)
+use std::fs::File;
+use std::io;
+use std::os::unix::io::{AsRawFd, FromRawFd};
+
+/// RAII guard that redirects stderr to /dev/null and restores it on drop
+pub struct StderrSuppressor {
+    original_stderr: Option<File>,
+}
+
+impl StderrSuppressor {
+    /// Suppress stderr by redirecting to /dev/null
+    pub fn new() -> io::Result<Self> {
+        // SAFETY: We need unsafe for low-level file descriptor manipulation via libc:
+        // 1. `libc::dup(STDERR_FILENO)` - Duplicates stderr FD so we can restore it later.
+        //    This is safe because STDERR_FILENO is always valid (2) in Unix processes.
+        // 2. `File::from_raw_fd()` - Takes ownership of the duplicated FD. Safe because
+        //    we just created a valid FD via dup, and we ensure it's only used once.
+        // 3. `libc::dup2(devnull_fd, STDERR_FILENO)` - Atomically replaces stderr with /dev/null.
+        //    Safe because both FDs are valid: devnull_fd from File::open, STDERR_FILENO is 2.
+        // The FDs are properly managed: original_stderr owns the dup'd FD and will close it on drop,
+        // and the dup2 call ensures the replacement is atomic.
+        unsafe {
+            // Save original stderr
+            let original_stderr_fd = libc::dup(libc::STDERR_FILENO);
+            if original_stderr_fd < 0 {
+                return Err(io::Error::last_os_error());
+            }
+            let original_stderr = File::from_raw_fd(original_stderr_fd);
+
+            // Redirect stderr to /dev/null
+            let devnull = File::open("/dev/null")?;
+            let devnull_fd = devnull.as_raw_fd();
+            if libc::dup2(devnull_fd, libc::STDERR_FILENO) < 0 {
+                return Err(io::Error::last_os_error());
+            }
+
+            Ok(Self {
+                original_stderr: Some(original_stderr),
+            })
+        }
+    }
+
+    /// Execute a closure with stderr suppressed
+    pub fn with_suppressed<F, R>(f: F) -> R
+    where
+        F: FnOnce() -> R,
+    {
+        match Self::new() {
+            Ok(guard) => {
+                let result = f();
+                drop(guard);
+                result
+            }
+            Err(_) => {
+                // If we can't suppress, just run anyway
+                f()
+            }
+        }
+    }
+}
+
+impl Drop for StderrSuppressor {
+    fn drop(&mut self) {
+        if let Some(original) = self.original_stderr.take() {
+            // SAFETY: We need unsafe to restore the original stderr file descriptor:
+            // `libc::dup2(original_fd, STDERR_FILENO)` - Atomically replaces current stderr
+            // with our saved original. Safe because:
+            // 1. original_fd comes from the File we created in new(), which owns a valid FD
+            // 2. STDERR_FILENO (2) is always a valid target in Unix processes
+            // 3. dup2 is atomic and handles the close of the current stderr internally
+            // We intentionally ignore errors here because Drop must not panic, and there's
+            // nothing meaningful to do if restoration fails (the program is likely shutting down).
+            unsafe {
+                // Restore original stderr
+                let original_fd = original.as_raw_fd();
+                libc::dup2(original_fd, libc::STDERR_FILENO);
+            }
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_suppressor_basic() {
+        // Should not panic
+        let _guard = StderrSuppressor::new().unwrap();
+    }
+
+    #[test]
+    fn test_with_suppressed() {
+        let result = StderrSuppressor::with_suppressed(|| {
+            eprintln!("This should be suppressed");
+            42
+        });
+        assert_eq!(result, 42);
+    }
+}
diff --git a/crates/coldvox-audio/tests/default_mic_detection_it.rs b/crates/coldvox-audio/tests/default_mic_detection_it.rs
index c5f80d56..07262acd 100644
--- a/crates/coldvox-audio/tests/default_mic_detection_it.rs
+++ b/crates/coldvox-audio/tests/default_mic_detection_it.rs
@@ -11,14 +11,15 @@
 //! - Runs only on Linux and requires `pactl` (PulseAudio/PipeWire compatibility layer)
 //! - If audio stack is unavailable, the test will skip gracefully
 
+use coldvox_audio::{AudioCaptureThread, AudioRingBuffer};
+use coldvox_foundation::AudioConfig;
+use parking_lot::Mutex;
 use std::collections::HashMap;
 use std::process::Command;
+use std::sync::Arc;
 use std::thread;
 use std::time::{Duration, Instant};
 
-use coldvox_audio::{AudioCaptureThread, AudioRingBuffer};
-use coldvox_foundation::AudioConfig;
-
 const APP_TAG: &str = "ColdVoxMicTest";
 
 #[cfg(target_os = "linux")]
@@ -56,9 +57,10 @@ fn default_mic_is_detected_and_used_via_pulseaudio() {
 
     let rb = AudioRingBuffer::new(16384);
     let (producer, mut consumer) = rb.split();
+    let producer = Arc::new(Mutex::new(producer));
     let config = AudioConfig::default();
 
-    let capture = match AudioCaptureThread::spawn(config, producer, None) {
+    let capture = match AudioCaptureThread::spawn(config, producer, None, false) {
         Ok((cap, _device_cfg, _cfg_rx, _dev_rx)) => cap,
         Err(e) => {
             eprintln!(
@@ -188,20 +190,16 @@ fn find_our_source_output_source(app_name: &str) -> Option<String> {
                     continue;
                 }
 
-                if line.starts_with("application.name = \"") {
-                    if line.contains(app_name) {
-                        current_block_is_ours = true;
-                        continue;
-                    }
+                if line.starts_with("application.name = \"") && line.contains(app_name) {
+                    current_block_is_ours = true;
+                    continue;
                 }
 
                 // Block end: if we have both flags, resolve name
-                if line.is_empty() {
-                    if current_block_is_ours {
-                        if let Some(idx) = current_block_source_index.take() {
-                            if let Some(name) = source_index_to_name.get(&idx) {
-                                return Some(name.clone());
-                            }
+                if line.is_empty() && current_block_is_ours {
+                    if let Some(idx) = current_block_source_index.take() {
+                        if let Some(name) = source_index_to_name.get(&idx) {
+                            return Some(name.clone());
                         }
                     }
                 }
diff --git a/crates/coldvox-audio/tests/device_hotplug_tests.rs b/crates/coldvox-audio/tests/device_hotplug_tests.rs
index d8452156..df78048a 100644
--- a/crates/coldvox-audio/tests/device_hotplug_tests.rs
+++ b/crates/coldvox-audio/tests/device_hotplug_tests.rs
@@ -1,5 +1,7 @@
 use coldvox_audio::{AudioCaptureThread, AudioRingBuffer, DeviceMonitor};
 use coldvox_foundation::{AudioConfig, DeviceEvent};
+use parking_lot::Mutex;
+use std::sync::Arc;
 use std::time::Duration;
 
 #[cfg(test)]
@@ -46,10 +48,11 @@ mod device_hotplug_tests {
     fn test_audio_capture_thread_with_device_events() {
         let buffer = AudioRingBuffer::new(8192);
         let (producer, _consumer) = buffer.split();
+        let producer = Arc::new(Mutex::new(producer));
         let config = AudioConfig::default();
 
         // Try to create capture thread with device monitoring
-        let result = AudioCaptureThread::spawn(config, producer, None);
+        let result = AudioCaptureThread::spawn(config, producer, None, true);
 
         match result {
             Ok((capture_thread, device_config, _config_rx, device_event_rx)) => {
diff --git a/docs/review/pr-comments-consolidated-2025-10-08.md b/docs/review/pr-comments-consolidated-2025-10-08.md
new file mode 100644
index 00000000..1ff6357a
--- /dev/null
+++ b/docs/review/pr-comments-consolidated-2025-10-08.md
@@ -0,0 +1,280 @@
+# Consolidated PR Comments Review - Stack #123-131
+**Generated:** 2025-10-08
+**Scope:** 9-PR domain refactor stack
+
+---
+
+## Executive Summary
+
+**Total Comments:** 6 user comments, 15 bot reviews across 9 PRs
+**Action Required:** 3 critical fixes, 2 circular dependency resolutions
+**Status:** Most issues are in early PRs or are design discussions
+
+---
+
+## Critical Issues Requiring Action
+
+### 🔴 BLOCKING: PR #129 - Missing `.await` on async calls
+**File:** `crates/app/tests/integration/text_injection_integration_test.rs`
+**Lines:** 54-56, 90, 119
+**Issue:** `StrategyManager::new(...)` is async but not awaited
+**Error:** Type mismatch - `expected struct StrategyManager, found impl Future`
+**Fix:** Add `.await` to all three constructor calls
+**Priority:** P0 - Blocks compilation
+
+```rust
+// Lines 54-56, 90, 119
+let manager = StrategyManager::new(&config).await; // Add .await
+```
+
+---
+
+### 🔴 BLOCKING: PR #128 - Removed config fields still referenced
+**Files:** `examples/inject_demo.rs`, test files
+**Lines:** 43-48 in inject_demo.rs
+**Issue:** `InjectionConfig` fields `allow_ydotool` and `restore_clipboard` removed but still used
+**Error:** `struct InjectionConfig has no field named ...`
+**Fix:** Remove field assignments from all call sites
+**Priority:** P1 - Blocks compilation
+
+```rust
+// Remove these fields:
+InjectionConfig {
+    // allow_ydotool: true,        // DELETE
+    // restore_clipboard: true,    // DELETE
+    // ... other fields
+}
+```
+
+---
+
+### 🟡 COORDINATION: PR #124 & #127 - Circular Dependency
+**Status:** Resolution planned, safe to proceed
+**Issue:** `wav_file_loader` module declaration in #124, implementation in #127
+
+**Solution (Recommended):**
+- **Remove** `pub mod wav_file_loader;` from PR #124 (`crates/app/src/audio/mod.rs`)
+- **Add** `pub mod wav_file_loader;` to PR #127 in same file
+- Keeps file + declaration together (best practice)
+
+**Why it's safe:**
+- wav_file_loader only used in E2E tests within PR #127
+- PRs #125, #126 don't reference it
+- Downstream PRs depend on #127, so they inherit complete module
+- No intermediate PRs affected
+
+**Status:** Analysis completed, awaiting execution
+
+---
+
+## PR-by-PR Analysis
+
+### PR #123: [01/09] Config/Settings
+**Comments:** 2 user + 3 bot reviews
+**Status:** ⚠️ Multiple design concerns, but non-blocking
+
+#### Issues Raised:
+1. ✅ **CI Failures (Vosk)** - Fixed in commit `86dfbb1`
+2. ⚠️ **Compilation standalone** - Expected; depends on later PRs for struct fields
+3. ⚠️ **3 ignored tests** - Env var override tests; can't validate until stack merges
+4. 💡 **Code maintenance** - `build_config()` method very long (50+ set_default calls)
+5. 💡 **Inconsistent validation** - Some fields clamp silently, others error
+6. ❓ **plugins.json** - Included but not integrated into Settings
+7. ❓ **Questionable defaults:**
+   - `cooldown_initial_ms = 10000` (10 sec seems high)
+   - `min_success_rate = 0.3` (30% seems low)
+8. 💡 **Missing features:**
+   - No runtime config reload
+   - No debug/print effective config
+   - No TOML schema validation
+
+#### Resolution:
+- **Blocking items:** ✅ All resolved
+- **Design issues:** Defer to post-merge cleanup
+- **Recommendation:** Merge as-is; address in follow-up
+
+#### Comments:
+```
+Coldaine @ 2025-10-08T08:00:54Z:
+"CI Failures: Setup Vosk Dependencies failing, causing build/test to skip - Need to fix before merge"
+
+Coldaine @ 2025-10-08T09:39:38Z:
+"The CI failure (Vosk) is already fixed in commit 86dfbb1. The ignored tests can be validated after
+the stack merges. Blocking this PR on env var test fixes is premature."
+```
+
+---
+
+### PR #124: [02/09] Audio Capture
+**Comments:** 1 user + 2 bot reviews
+**Status:** ⚠️ Circular dependency with PR #127
+
+#### Issues Raised:
+1. 🔄 **Circular dependency** - See "Critical Issues" section above
+
+#### Comments:
+```
+Coldaine @ 2025-10-08T09:24:12Z:
+"This PR (#124) declares `pub mod wav_file_loader;` in `crates/app/src/audio/mod.rs` but the actual
+file `wav_file_loader.rs` doesn't exist in this PR - it's in PR #127."
+```
+
+---
+
+### PR #125: [03/09] VAD
+**Comments:** 1 user + 2 bot reviews
+**Status:** ✅ Ready, awaiting review
+
+#### Comments:
+```
+Coldaine @ 2025-10-08T12:17:16Z:
+"@claude any ideas here? review and let me know if you have comments"
+```
+
+#### Review:
+- Changes: Frame-based timestamp tracking instead of wall-clock `Instant`
+- Improves debounce timing predictability
+- Maintains existing logic while improving accuracy
+- **No issues identified**
+
+---
+
+### PR #126: [04/09] STT
+**Comments:** 0 user + 3 bot reviews
+**Status:** ✅ Ready
+
+#### Review:
+- Removes unnecessary async from audio frame handling
+- Adds helper utilities (AudioBufferManager, EventEmitter)
+- Improves logging granularity
+- **No issues identified**
+
+---
+
+### PR #127: [05/09] Runtime + WAV Loader
+**Comments:** 2 user + 2 bot reviews
+**Status:** ⚠️ Circular dependency with PR #124
+
+#### Issues Raised:
+1. 🔄 **Circular dependency** - See "Critical Issues" section above
+
+#### Comments:
+```
+Coldaine @ 2025-10-08T09:24:24Z:
+"This PR (#127) adds the file `crates/app/src/audio/wav_file_loader.rs` but the module declaration
+`pub mod wav_file_loader;` is in PR #124's `mod.rs`."
+
+Coldaine (Claude) @ 2025-10-08T12:15:54Z:
+"Analysis: Safe to Include Module Declaration
+Verified that moving `pub mod wav_file_loader;` from PR #124 to this PR will NOT interfere..."
+```
+
+---
+
+### PR #128: [06/09] Text Injection
+**Comments:** 0 user + 2 bot reviews
+**Status:** 🔴 Breaking change - compilation failure
+
+#### Issues Raised:
+1. 🔴 **P1 - Config fields removed but still used** - See "Critical Issues" section above
+
+#### Review:
+- Consolidates clipboard operations with automatic preservation
+- Implements Wayland-first strategy
+- Simplifies strategy ordering
+- **Fix required:** Update all call sites to remove deleted config fields
+
+---
+
+### PR #129: [07/09] Testing
+**Comments:** 0 user + 2 bot reviews
+**Status:** 🔴 Missing `.await` - compilation failure
+
+#### Issues Raised:
+1. 🔴 **P0 - Missing .await** - See "Critical Issues" section above
+
+#### Review:
+- Establishes deterministic E2E testing
+- Removes hardcoded path fallbacks
+- Updates configuration handling
+- **Fix required:** Add `.await` to StrategyManager::new() calls
+
+---
+
+### PR #130: [08/09] Logging/Telemetry
+**Comments:** 0 user + 2 bot reviews
+**Status:** ✅ Ready
+
+#### Review:
+- Reduces logging noise in hot paths
+- Adds request tracking to STT metrics
+- Hardcodes HyperX QuadCast in VAD tests (bypasses detection issues)
+- **No issues identified**
+
+---
+
+### PR #131: [09/09] Documentation
+**Comments:** 0 user + 1 bot review
+**Status:** ✅ Ready
+
+#### Review:
+- Comprehensive documentation refresh
+- Adds execution guides and deployment documentation
+- Updates all architecture diagrams and configuration guides
+- **No issues identified**
+
+---
+
+## Summary by Status
+
+### 🔴 Must Fix (2 PRs)
+- **PR #128:** Remove deleted config field references
+- **PR #129:** Add `.await` to async constructor calls
+
+### 🟡 Coordination Needed (2 PRs)
+- **PR #124 & #127:** Resolve circular dependency (move module declaration)
+
+### ✅ Ready to Merge (5 PRs)
+- PR #125, #126, #130, #131 (after dependencies)
+- PR #123 (with design issues deferred)
+
+---
+
+## Recommended Action Plan
+
+### Phase 1: Fix Compilation Issues
+1. **PR #128:** Remove `allow_ydotool` and `restore_clipboard` field assignments
+2. **PR #129:** Add `.await` to three StrategyManager::new() calls
+
+### Phase 2: Resolve Circular Dependencies
+3. **PR #124:** Remove `pub mod wav_file_loader;` declaration
+4. **PR #127:** Add `pub mod wav_file_loader;` declaration
+
+### Phase 3: Merge Stack
+5. Merge PRs #123 → #124 → #125 → #126 → #127 → #128 → #129 → #130 → #131 in order
+6. Validate env var override tests post-merge
+7. Track design issues from PR #123 for future cleanup
+
+---
+
+## Bot Review Summary
+
+**Copilot:** 11 reviews, identified 2 P0/P1 issues
+**Codex:** 4 reviews, primarily boilerplate
+**Coverage:** All PRs reviewed by at least one bot
+
+**Most Valuable Catches:**
+- PR #129 missing `.await` (P0 - would block compilation)
+- PR #128 config field removal (P1 - would block compilation)
+
+---
+
+## Notes
+
+- Most comments are in first 2 PRs (#123, #124) - expected for foundational changes
+- Later PRs (#130, #131) have minimal comments - indicates stable progression
+- All bot-identified issues are actionable and specific
+- Circular dependency resolution is straightforward and low-risk
+- Design concerns in PR #123 are non-blocking and can be addressed post-merge
+
+**Overall Assessment:** Stack is in good shape. Two compilation fixes + one coordination item required before merge.