fix(detection): address code-review P1s + P2s (001, 002, 004, 005)

- set_recording moved to Arc<AtomicBool> on DetectionService; poll loop
  syncs it into state before each advance. Removes the try_lock/spawn
  fallback that could reorder rapid start/stop calls and wrongly gate
  the MeetingEnded banner.
- DetectorPhaseSnapshot.bundle_id exposed for non-idle phases so agents
  can act on get_detection_state alone (dismiss_detected_meeting
  requires the raw bundle_id).
- meeting-detected / meeting-ended Tauri events gated on the matching
  notification preference and emit DetectedMeetingEvent { display_name }
  only. bundle_id stays Rust-side; agents read it via the command
  surface, not the event bus.
- NSMicrophoneUsageDescription updated to cover the new process-
  enumeration capability introduced by CoreAudio mic-holder detection.

The NotificationManager OnceCell migration (003) was dropped after
review: the race it addressed is narrow (racing first-callers during
startup eager-init) and the fallout benign (duplicate settings-file
write, idempotent delegate re-registration). Not worth ~100 LOC of
churn across every notification command handler.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: AzimovS

frontend/src-tauri/Info.plist

@@ -3,7 +3,7 @@
 <plist version="1.0">
 <dict>
     <key>NSMicrophoneUsageDescription</key>
-    <string>This application needs access to your microphone to record meeting audio.</string>
+    <string>Meetily uses your microphone to record meetings you ask it to capture, and observes which apps are currently using the microphone so it can offer to auto-record when a meeting starts.</string>
     <key>NSScreenCaptureUsageDescription</key>
     <string>This application needs screen recording permission to capture system audio during meetings.</string>
     <key>NSAudioCaptureUsageDescription</key>

frontend/src-tauri/src/detection/service.rs

@@ -18,7 +18,7 @@ use tokio::sync::Mutex;
 
 use crate::detection::signals::mic_activity;
 use crate::detection::state::{DetectorConfig, DetectorState};
-use crate::detection::types::DetectionEvent;
+use crate::detection::types::{DetectedMeetingEvent, DetectionEvent};
 use crate::notifications::commands::{
     show_meeting_detected_notification, show_meeting_ended_notification,
     NotificationManagerState,
@@ -31,13 +31,19 @@ const POLL_INTERVAL: Duration = Duration::from_secs(1);
 pub struct DetectionService {
     state: Arc<Mutex<DetectorState>>,
     running: Arc<AtomicBool>,
+    /// External recording flag, pushed in from the audio layer.
+    /// Lock-free so `set_recording` stays sync and strictly ordered
+    /// even if the poll loop is mid-`advance()`. The poll loop
+    /// snapshots this into `DetectorState` before each tick.
+    is_recording: Arc<AtomicBool>,
 }
 
 impl DetectionService {
     fn new(config: DetectorConfig, running: Arc<AtomicBool>) -> Self {
         Self {
             state: Arc::new(Mutex::new(DetectorState::new(config))),
             running,
+            is_recording: Arc::new(AtomicBool::new(false)),
         }
     }
 
@@ -49,24 +55,12 @@ impl DetectionService {
         debug!("DetectionService::shutdown signalled");
     }
 
-    /// Record that Meetily started/stopped recording. Gates the
-    /// MeetingEnded banner inside the state machine.
+    /// Record that Meetily started/stopped recording. Lock-free atomic
+    /// write — safe to call from any thread, sync or async, in any
+    /// order, without contending on the state-machine mutex.
     pub fn set_recording(&self, recording: bool) {
-        // Runs from audio commands which are async; we need a blocking
-        // lock here. This is called at most once per start/stop.
-        if let Ok(mut guard) = self.state.try_lock() {
-            guard.set_recording(recording);
-            debug!("DetectionService: set_recording({})", recording);
-        } else {
-            // Fall back: spawn to unblock once the poll loop lock
-            // releases. Still quick — advance() holds the lock briefly.
-            let state = self.state.clone();
-            tauri::async_runtime::spawn(async move {
-                let mut guard = state.lock().await;
-                guard.set_recording(recording);
-                debug!("DetectionService: set_recording({}) (async fallback)", recording);
-            });
-        }
+        self.is_recording.store(recording, Ordering::Release);
+        debug!("DetectionService: set_recording({})", recording);
     }
 
     /// Dismiss a detected bundle so further MeetingDetected banners
@@ -96,6 +90,7 @@ where
     let service = DetectionService::new(DetectorConfig::DEFAULT, running.clone());
     let state = service.state.clone();
     let running_for_task = running.clone();
+    let is_recording_for_task = service.is_recording.clone();
 
     let sampler = match mic_activity::create() {
         Ok(s) => s,
@@ -126,8 +121,12 @@ where
                 }
             };
 
+            // Sync the externally-pushed recording flag into the state
+            // machine right before advancing. Done under the state lock
+            // so `advance()` sees a coherent value.
             let event = {
                 let mut guard = state.lock().await;
+                guard.set_recording(is_recording_for_task.load(Ordering::Acquire));
                 guard.advance(Instant::now(), &snapshot)
             };
 
@@ -138,10 +137,16 @@ where
                 DetectionEvent::MeetingDetected(m) => {
                     info!("Meeting detection: DETECTED {}", m.display_name);
                     debug!("Meeting detection: DETECTED bundle={}", m.bundle_id);
-                    // Emit Tauri event so frontend / agents can observe
-                    // alongside the notification banner.
-                    if let Err(e) = app.emit("meeting-detected", &m) {
-                        debug!("failed to emit meeting-detected event: {}", e);
+                    // Only emit the event when the corresponding banner
+                    // preference is enabled. Keeps the event and the
+                    // user-facing banner under the same user control,
+                    // and strips `bundle_id` from the payload — agents
+                    // can still read it via `get_detection_state`.
+                    if pref_show_meeting_detected(mgr_state.inner()).await {
+                        let payload = DetectedMeetingEvent { display_name: m.display_name.clone() };
+                        if let Err(e) = app.emit("meeting-detected", &payload) {
+                            debug!("failed to emit meeting-detected event: {}", e);
+                        }
                     }
                     if let Err(e) = show_meeting_detected_notification(
                         &app, mgr_state.inner(), m.display_name,
@@ -152,8 +157,11 @@ where
                 DetectionEvent::MeetingEnded(m) => {
                     info!("Meeting detection: ENDED {}", m.display_name);
                     debug!("Meeting detection: ENDED bundle={}", m.bundle_id);
-                    if let Err(e) = app.emit("meeting-ended", &m) {
-                        debug!("failed to emit meeting-ended event: {}", e);
+                    if pref_show_meeting_ended(mgr_state.inner()).await {
+                        let payload = DetectedMeetingEvent { display_name: m.display_name.clone() };
+                        if let Err(e) = app.emit("meeting-ended", &payload) {
+                            debug!("failed to emit meeting-ended event: {}", e);
+                        }
                     }
                     if let Err(e) = show_meeting_ended_notification(
                         &app, mgr_state.inner(), m.display_name,
@@ -169,3 +177,38 @@ where
 
     service
 }
+
+/// Read the `show_meeting_detected` preference from the live notification
+/// manager. Defaults to `true` if the manager isn't initialized yet so
+/// the first detection after startup isn't silently dropped.
+async fn pref_show_meeting_detected<R: Runtime>(
+    manager_state: &NotificationManagerState<R>,
+) -> bool {
+    let guard = manager_state.read().await;
+    match guard.as_ref() {
+        Some(manager) => {
+            manager
+                .get_settings()
+                .await
+                .notification_preferences
+                .show_meeting_detected
+        }
+        None => true,
+    }
+}
+
+async fn pref_show_meeting_ended<R: Runtime>(
+    manager_state: &NotificationManagerState<R>,
+) -> bool {
+    let guard = manager_state.read().await;
+    match guard.as_ref() {
+        Some(manager) => {
+            manager
+                .get_settings()
+                .await
+                .notification_preferences
+                .show_meeting_ended
+        }
+        None => true,
+    }
+}

frontend/src-tauri/src/detection/state.rs

@@ -75,6 +75,9 @@ pub struct DetectorPhaseSnapshot {
     /// One of `"idle" | "sustaining" | "detected" | "ending"`.
     pub phase: &'static str,
     pub display_name: Option<String>,
+    /// Raw bundle ID for the current candidate — the identity
+    /// `dismiss_detected_meeting` expects. `None` in `Idle`.
+    pub bundle_id: Option<String>,
     pub elapsed_ms: Option<u64>,
     pub remaining_ms: Option<u64>,
     pub is_recording: bool,
@@ -308,6 +311,7 @@ impl DetectorState {
             Phase::Idle => DetectorPhaseSnapshot {
                 phase: "idle",
                 display_name: None,
+                bundle_id: None,
                 elapsed_ms: None,
                 remaining_ms: None,
                 is_recording: self.is_recording,
@@ -322,6 +326,7 @@ impl DetectorState {
                 DetectorPhaseSnapshot {
                     phase: "sustaining",
                     display_name: Some(matcher::display_name(bundle).to_string()),
+                    bundle_id: Some(bundle.clone()),
                     elapsed_ms: Some(elapsed.as_millis() as u64),
                     remaining_ms: Some(threshold.saturating_sub(elapsed).as_millis() as u64),
                     is_recording: self.is_recording,
@@ -330,6 +335,7 @@ impl DetectorState {
             Phase::Detected { bundle } => DetectorPhaseSnapshot {
                 phase: "detected",
                 display_name: Some(matcher::display_name(bundle).to_string()),
+                bundle_id: Some(bundle.clone()),
                 elapsed_ms: None,
                 remaining_ms: None,
                 is_recording: self.is_recording,
@@ -343,6 +349,7 @@ impl DetectorState {
                 DetectorPhaseSnapshot {
                     phase: "ending",
                     display_name: Some(matcher::display_name(bundle).to_string()),
+                    bundle_id: Some(bundle.clone()),
                     elapsed_ms: Some(elapsed.as_millis() as u64),
                     remaining_ms: Some(
                         self.config.end_silence.saturating_sub(elapsed).as_millis() as u64,
@@ -673,6 +680,38 @@ mod tests {
         assert!(snap.remaining_ms.unwrap() <= 7_000 && snap.remaining_ms.unwrap() > 6_500);
     }
 
+    #[test]
+    fn phase_snapshot_exposes_bundle_id_for_non_idle_phases() {
+        let mut s = DetectorState::new(test_config());
+        let t0 = Instant::now();
+
+        // Idle → no bundle_id
+        assert_eq!(s.phase_snapshot(t0).bundle_id, None);
+
+        // Sustaining → bundle_id present
+        s.advance(t0, &snapshot(&["us.zoom.xos"]));
+        assert_eq!(
+            s.phase_snapshot(t0).bundle_id.as_deref(),
+            Some("us.zoom.xos")
+        );
+
+        // Detected → bundle_id present
+        let t_detect = t0 + Duration::from_secs(10);
+        s.advance(t_detect, &snapshot(&["us.zoom.xos"]));
+        assert_eq!(
+            s.phase_snapshot(t_detect).bundle_id.as_deref(),
+            Some("us.zoom.xos")
+        );
+
+        // Ending → bundle_id still present (the app we were tracking)
+        let t_release = t_detect + Duration::from_secs(5);
+        s.advance(t_release, &snapshot(&[]));
+        assert_eq!(
+            s.phase_snapshot(t_release).bundle_id.as_deref(),
+            Some("us.zoom.xos")
+        );
+    }
+
     #[test]
     fn dismissed_reaper_removes_expired_entries() {
         let mut s = DetectorState::new(test_config());

frontend/src-tauri/src/detection/types.rs

@@ -1,12 +1,23 @@
 use serde::{Deserialize, Serialize};
 
-/// A meeting detected by the mic-activity signal.
+/// A meeting detected by the mic-activity signal. Used internally by
+/// the detector; not emitted on the Tauri event bus — see
+/// [`DetectedMeetingEvent`] for the public wire shape.
 #[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
 pub struct DetectedMeeting {
     pub bundle_id: String,
     pub display_name: String,
 }
 
+/// Public payload for `meeting-detected` / `meeting-ended` Tauri events.
+/// Omits `bundle_id` so Tauri events don't stream app-identity
+/// telemetry to every webview. Agents needing `bundle_id` can read it
+/// via the `get_detection_state` command.
+#[derive(Debug, Clone, Serialize)]
+pub struct DetectedMeetingEvent {
+    pub display_name: String,
+}
+
 /// Events the detector emits as its internal state advances.
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub enum DetectionEvent {