fix(sound): suppress ALSA stderr errors on headless systems

On Linux systems without audio hardware (Docker containers, headless servers),
ALSA prints error messages like 'ALSA lib confmisc.c: cannot find card 0'
directly to stderr before Rust error handling can catch them.

This fix temporarily redirects stderr to /dev/null during audio initialization
on Linux to suppress these noisy messages while preserving the graceful
fallback to terminal bell notifications.

The fix:
- Only applies on Linux (where ALSA is used)
- Falls back to normal behavior if stderr redirection fails
- Properly restores stderr after initialization
- Has no effect on non-Linux platforms (macOS, Windows)

Author: echobt

src/cortex-tui/src/sound.rs

@@ -9,6 +9,9 @@
 //!
 //! On platforms without audio support (e.g., musl builds), falls back to
 //! terminal bell notifications.
+//!
+//! On Linux, ALSA error messages (e.g., "cannot find card 0") are suppressed
+//! during audio initialization to avoid noisy output on headless systems.
 
 #[cfg(feature = "audio")]
 use std::io::Cursor;
@@ -44,6 +47,96 @@ const COMPLETE_WAV: &[u8] = include_bytes!("sounds/complete.wav");
 #[cfg(feature = "audio")]
 const APPROVAL_WAV: &[u8] = include_bytes!("sounds/approval.wav");
 
+/// Try to create audio output stream, suppressing ALSA errors on Linux.
+///
+/// On Linux, ALSA prints error messages directly to stderr when no audio
+/// hardware is available (e.g., "ALSA lib confmisc.c: cannot find card 0").
+/// This function suppresses those messages by temporarily redirecting stderr
+/// to /dev/null during initialization.
+#[cfg(all(feature = "audio", target_os = "linux"))]
+fn try_create_output_stream() -> Option<(rodio::OutputStream, rodio::OutputStreamHandle)> {
+    use std::os::unix::io::AsRawFd;
+
+    // Open /dev/null for redirecting stderr
+    let dev_null = match std::fs::File::open("/dev/null") {
+        Ok(f) => f,
+        Err(_) => {
+            // Can't open /dev/null, try without suppression
+            return match rodio::OutputStream::try_default() {
+                Ok((stream, handle)) => Some((stream, handle)),
+                Err(e) => {
+                    tracing::debug!("Failed to initialize audio output: {}", e);
+                    None
+                }
+            };
+        }
+    };
+
+    // Save the original stderr file descriptor
+    // SAFETY: dup is safe to call with a valid file descriptor (2 = stderr)
+    let original_stderr = unsafe { libc::dup(2) };
+    if original_stderr == -1 {
+        // dup failed, try without suppression
+        return match rodio::OutputStream::try_default() {
+            Ok((stream, handle)) => Some((stream, handle)),
+            Err(e) => {
+                tracing::debug!("Failed to initialize audio output: {}", e);
+                None
+            }
+        };
+    }
+
+    // Redirect stderr to /dev/null
+    // SAFETY: dup2 is safe with valid file descriptors
+    let redirect_result = unsafe { libc::dup2(dev_null.as_raw_fd(), 2) };
+    drop(dev_null); // Close our handle to /dev/null
+
+    if redirect_result == -1 {
+        // dup2 failed, restore and try without suppression
+        // SAFETY: close is safe with a valid file descriptor
+        unsafe { libc::close(original_stderr) };
+        return match rodio::OutputStream::try_default() {
+            Ok((stream, handle)) => Some((stream, handle)),
+            Err(e) => {
+                tracing::debug!("Failed to initialize audio output: {}", e);
+                None
+            }
+        };
+    }
+
+    // Try to create the audio output stream (ALSA errors will go to /dev/null)
+    let result = rodio::OutputStream::try_default();
+
+    // Restore the original stderr
+    // SAFETY: dup2 and close are safe with valid file descriptors
+    unsafe {
+        libc::dup2(original_stderr, 2);
+        libc::close(original_stderr);
+    }
+
+    match result {
+        Ok((stream, handle)) => Some((stream, handle)),
+        Err(e) => {
+            tracing::debug!("Failed to initialize audio output: {}", e);
+            None
+        }
+    }
+}
+
+/// Try to create audio output stream (non-Linux platforms).
+///
+/// On non-Linux platforms, ALSA is not used, so no stderr suppression is needed.
+#[cfg(all(feature = "audio", not(target_os = "linux")))]
+fn try_create_output_stream() -> Option<(rodio::OutputStream, rodio::OutputStreamHandle)> {
+    match rodio::OutputStream::try_default() {
+        Ok((stream, handle)) => Some((stream, handle)),
+        Err(e) => {
+            tracing::debug!("Failed to initialize audio output: {}", e);
+            None
+        }
+    }
+}
+
 /// Initialize the global sound system.
 /// Spawns a dedicated audio thread that owns the OutputStream.
 /// Should be called once at application startup.
@@ -67,14 +160,8 @@ pub fn init() {
     thread::Builder::new()
         .name("cortex-audio".to_string())
         .spawn(move || {
-            // Try to create audio output
-            let output = match rodio::OutputStream::try_default() {
-                Ok((stream, handle)) => Some((stream, handle)),
-                Err(e) => {
-                    tracing::debug!("Failed to initialize audio output: {}", e);
-                    None
-                }
-            };
+            // Try to create audio output (with ALSA error suppression on Linux)
+            let output = try_create_output_stream();
 
             // Process sound requests
             while let Ok(sound_type) = rx.recv() {