feat(tray): color-coded level meter + clearer right-click menu

Tray icon now reflects the current output level into VB-Cable with 5
color buckets (grey / dim green / green / amber / red). Tooltip shows
live dBFS. Set show_level_meter: false in config.json to disable.

Menu layout clarifies what each entry does:
  - "🎙 Input microphone:" disabled header above the mic list
  - "🔊 System sound: <device> (Windows default)" as a read-only hint
    so users know which speakers loopback is capturing and that the
    selector is elsewhere (Windows volume mixer)

Internals:
  - mixer::peak_i16 reports the peak amplitude of a mixed buffer
  - Pipeline exposes it via an Arc<AtomicU32> (lock-free tray reads)
  - TrayApp event loop switched from Poll to WaitUntil(166ms) so the
    thread actually sleeps between ticks (~6 Hz update, low CPU)
  - Icon repaints only on bucket transitions, not every tick, to avoid
    Shell_NotifyIconW rate-limit / flicker
  - Config::show_level_meter is optional at serde level — legacy
    config.json files from 0.1.0 still load and default to true

README: explains menu semantics (what the mic list is vs. the system
sound row) and documents the meter legend.

Author: Yakov Tchenak

README.md

@@ -53,6 +53,36 @@ cargo build --release
 4. In your recording app (Otter, OBS, etc.), set the input device to **`CABLE Output (VB-Audio Virtual Cable)`**.
 5. **Left-click** again to stop.
 
+### What the tray menu is for
+
+The right-click menu only picks **your microphone**. The **system-audio source** (whichever speakers / headphones Windows is currently playing through) is captured automatically via WASAPI loopback — to change it, swap the Windows default playback device from the volume-mixer tray popup, not from wasamix. The menu shows the current default as a read-only hint:
+
+```
+🎙  Input microphone:
+  ● Microphone (HD Pro Webcam C920)
+  ○ Headset (Jabra Evolve2 65)
+  ──────────────
+  🔊 System sound: Speakers (Realtek) (Windows default)
+  ──────────────
+  Quit
+```
+
+So picking "Headset (Jabra Evolve2 65)" captures the Jabra's *mic* and mixes it with whatever Windows is currently playing out — it does **not** route anything else.
+
+### Reading the tray icon
+
+While mixing, the icon changes color to reflect the current output level into VB-Cable. Hover for an exact dBFS reading.
+
+| Icon          | Meaning                      | Peak range                |
+|---------------|------------------------------|---------------------------|
+| ⚪ Grey       | Idle                         | —                         |
+| 🟢 Dim green  | Running, effectively silent  | below −40 dBFS            |
+| 🟢 Green      | Running, quiet               | −40 to −20 dBFS           |
+| 🟡 Amber      | Running, healthy levels      | −20 to −3 dBFS            |
+| 🔴 Red        | Clipping — output too hot    | −3 dBFS and above         |
+
+Don't want the color meter? Set `"show_level_meter": false` in `config.json` and you get the classic green-on-running behavior.
+
 ### Behavior notes
 
 - Selecting a different mic while mixing is disabled by design — stop first, switch, then start.

src/audio/devices.rs

@@ -130,6 +130,16 @@ pub fn get_default_render_device_id() -> Result<String> {
     Ok(id)
 }
 
+/// Friendly name of the default render device — shown in the tray menu so
+/// users can tell which speakers/headphones wasamix is capturing system
+/// audio from. Returns `None` if the device has no friendly name or we
+/// can't reach the enumerator.
+pub fn get_default_render_device_name() -> Option<String> {
+    initialize_mta().ok().ok()?;
+    let device = wasapi::get_default_device(&Direction::Render).ok()?;
+    device.get_friendlyname().ok()
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;

src/audio/mixer.rs

@@ -138,6 +138,25 @@ pub fn new_shared_buffer(capacity: usize) -> Arc<Mutex<RingBuffer>> {
 /// Audio arrives as `&[u8]` (raw bytes) but we need to treat it as i16
 /// samples. We use `i16::from_le_bytes()` to convert pairs of bytes into
 /// signed 16-bit integers (little-endian, which is what Windows uses).
+/// Return the peak absolute amplitude of mono i16 audio bytes, in the
+/// range 0..=32768. `0` means silence; `32768` means clipped.
+///
+/// We keep the unsigned range (u16) so the tray thread can read it as an
+/// AtomicU32 without sign handling.
+pub fn peak_i16(data: &[u8]) -> u16 {
+    let mut peak: u16 = 0;
+    for chunk in data.chunks_exact(BYTES_PER_SAMPLE) {
+        let s = i16::from_le_bytes([chunk[0], chunk[1]]);
+        // i16::MIN (-32768) has |.| = 32768 which doesn't fit in i16 — use
+        // unsigned_abs which widens to u16 and handles the edge cleanly.
+        let abs = s.unsigned_abs();
+        if abs > peak {
+            peak = abs;
+        }
+    }
+    peak
+}
+
 pub fn mix_samples(mic: &[u8], loopback: &[u8]) -> Vec<u8> {
     if mic.is_empty() && loopback.is_empty() {
         return Vec::new();
@@ -291,6 +310,29 @@ mod tests {
         assert!(mix_samples(&[], &[]).is_empty());
     }
 
+    #[test]
+    fn test_peak_silence() {
+        assert_eq!(peak_i16(&[]), 0);
+        assert_eq!(peak_i16(&[0, 0, 0, 0]), 0);
+    }
+
+    #[test]
+    fn test_peak_positive_and_negative() {
+        let mut data = Vec::new();
+        data.extend_from_slice(&1000i16.to_le_bytes());
+        data.extend_from_slice(&(-5000i16).to_le_bytes());
+        data.extend_from_slice(&100i16.to_le_bytes());
+        assert_eq!(peak_i16(&data), 5000);
+    }
+
+    #[test]
+    fn test_peak_extreme_min_value() {
+        // i16::MIN (-32768) — its absolute value doesn't fit in i16; must
+        // return 32768 (u16::from(i16::MIN.unsigned_abs())).
+        let data = i16::MIN.to_le_bytes();
+        assert_eq!(peak_i16(&data), 32768);
+    }
+
     #[test]
     fn test_convert_f32_stereo_to_mono() {
         // Two frames of stereo: (0.5, -0.5), (1.0, 0.0)

src/audio/pipeline.rs

@@ -10,15 +10,15 @@
 //! `Pipeline::stop()` is called (or Pipeline is dropped), it signals all
 //! threads to stop and waits for them to finish. No resource leaks!
 
-use std::sync::atomic::{AtomicBool, Ordering};
+use std::sync::atomic::{AtomicBool, AtomicU32, Ordering};
 use std::sync::{Arc, Mutex};
 use std::thread;
 
 use anyhow::Result;
 use tracing::info;
 
 use super::capture::{start_capture_thread, start_render_thread};
-use super::mixer::{BYTES_PER_SAMPLE, SAMPLE_RATE, mix_samples, new_shared_buffer};
+use super::mixer::{BYTES_PER_SAMPLE, SAMPLE_RATE, mix_samples, new_shared_buffer, peak_i16};
 
 /// Buffer 2 seconds of audio
 const BUFFER_CAPACITY: usize = SAMPLE_RATE as usize * BYTES_PER_SAMPLE * 2;
@@ -31,6 +31,11 @@ const BUFFER_CAPACITY: usize = SAMPLE_RATE as usize * BYTES_PER_SAMPLE * 2;
 /// We start with `None` and fill them in `start()`.
 pub struct Pipeline {
     stop_flag: Arc<AtomicBool>,
+    /// Peak absolute amplitude of the most recent mixed buffer, in 0..=32768.
+    /// Written by the mixer closure on the render thread, read by the tray
+    /// thread for the level meter. `AtomicU32` (not `AtomicU16`) because
+    /// u16 atomics aren't guaranteed on all Rust targets.
+    peak_level: Arc<AtomicU32>,
     mic_thread: Option<thread::JoinHandle<()>>,
     loopback_thread: Option<thread::JoinHandle<()>>,
     render_thread: Option<thread::JoinHandle<()>>,
@@ -45,6 +50,7 @@ impl Pipeline {
     /// It's from the `anyhow` crate — a convenient way to return errors.
     pub fn start(mic_device_id: &str, vbcable_device_id: &str) -> Result<Self> {
         let stop_flag = Arc::new(AtomicBool::new(false));
+        let peak_level = Arc::new(AtomicU32::new(0));
 
         // Create shared ring buffers for mic and loopback audio
         let mic_buffer = new_shared_buffer(BUFFER_CAPACITY);
@@ -74,11 +80,14 @@ impl Pipeline {
         // ring buffer and mix them.
         let mic_buf_for_mixer = Arc::clone(&mic_buffer);
         let loop_buf_for_mixer = Arc::clone(&loopback_buffer);
+        let peak_for_mixer = Arc::clone(&peak_level);
         let mixer_fn: Arc<Mutex<dyn FnMut(usize) -> Vec<u8> + Send>> =
             Arc::new(Mutex::new(move |bytes_needed: usize| {
                 let mic_data = mic_buf_for_mixer.lock().unwrap().read(bytes_needed);
                 let loop_data = loop_buf_for_mixer.lock().unwrap().read(bytes_needed);
-                mix_samples(&mic_data, &loop_data)
+                let mixed = mix_samples(&mic_data, &loop_data);
+                peak_for_mixer.store(peak_i16(&mixed) as u32, Ordering::Relaxed);
+                mixed
             }));
 
         // Start render thread — writes mixed audio to VB-Cable
@@ -95,12 +104,22 @@ impl Pipeline {
 
         Ok(Pipeline {
             stop_flag,
+            peak_level,
             mic_thread: Some(mic_thread),
             loopback_thread: Some(loopback_thread),
             render_thread: Some(render_thread),
         })
     }
 
+    /// Current peak output level, in 0..=32768.
+    ///
+    /// Read by the tray thread on its UI timer. Cheap (single atomic load).
+    pub fn peak_level(&self) -> u16 {
+        // Clamp back to u16: the mixer closure only writes 0..=32768, so this
+        // is a pure type narrowing.
+        self.peak_level.load(Ordering::Relaxed).min(u16::MAX as u32) as u16
+    }
+
     /// Stop the pipeline — signals all threads and waits for them.
     ///
     /// RUST CONCEPT: `.take()` on Option

src/config.rs

@@ -24,6 +24,16 @@ pub struct Config {
     /// `Option<String>` means this field can be `Some("device-id")` or `None`.
     /// We store the device ID as a string because WASAPI device IDs are strings.
     pub mic_device_id: Option<String>,
+
+    /// Whether the tray icon color-codes the current output level.
+    /// `#[serde(default = "...")]` lets older config.json files (missing this
+    /// field) still deserialize — they get `default_show_level_meter()`.
+    #[serde(default = "default_show_level_meter")]
+    pub show_level_meter: bool,
+}
+
+fn default_show_level_meter() -> bool {
+    true
 }
 
 /// `impl` blocks attach methods to a struct — similar to defining methods
@@ -76,6 +86,7 @@ impl Default for Config {
     fn default() -> Self {
         Config {
             mic_device_id: None,
+            show_level_meter: default_show_level_meter(),
         }
     }
 }
@@ -101,10 +112,24 @@ mod tests {
         let path = dir.path().join("config.json");
         let config = Config {
             mic_device_id: Some("test-device-123".to_string()),
+            show_level_meter: false,
         };
         config.save_to(&path).unwrap();
         let loaded = Config::load_from(&path).unwrap();
         assert_eq!(loaded.mic_device_id, Some("test-device-123".to_string()));
+        assert!(!loaded.show_level_meter);
+    }
+
+    #[test]
+    fn test_load_legacy_without_level_meter_field() {
+        // A config.json written by wasamix 0.1.0 won't have show_level_meter.
+        // It should still load, defaulting show_level_meter to true.
+        let dir = tempdir().unwrap();
+        let path = dir.path().join("config.json");
+        fs::write(&path, r#"{"mic_device_id":"abc"}"#).unwrap();
+        let loaded = Config::load_from(&path).unwrap();
+        assert_eq!(loaded.mic_device_id, Some("abc".to_string()));
+        assert!(loaded.show_level_meter);
     }
 
     #[test]