feat(notifications): add MeetingDetected / MeetingEnded variants

Scaffolds the notification plumbing for mic-activity meeting
detection (landing in the next commit). Adds `MeetingDetected(String)`
and `MeetingEnded(String)` enum variants alongside their settings
toggles (`show_meeting_detected` / `show_meeting_ended`, default on),
manager helpers, and the "Meeting detected — tap to start recording"
/ "Meeting ended — tap to stop recording" body text. Surfaces both
in the About debug dropdown so they can be fired manually.

Author: AzimovS

frontend/src-tauri/src/notifications/commands.rs

@@ -28,6 +28,8 @@ pub enum DebugNotificationKind {
     MeetingReminder,
     SystemError,
     Test,
+    MeetingDetected,
+    MeetingEnded,
 }
 
 /// Initialize the notification manager (called during app setup)
@@ -338,6 +340,13 @@ pub async fn debug_show_notification(
                 None => Err(anyhow::anyhow!("Notification manager not initialized")),
             }
         }
+        DebugNotificationKind::MeetingDetected => {
+            show_meeting_detected_notification(&app, manager_state.inner(), "Zoom".to_string())
+                .await
+        }
+        DebugNotificationKind::MeetingEnded => {
+            show_meeting_ended_notification(&app, manager_state.inner(), "Zoom".to_string()).await
+        }
     };
 
     result.map_err(|e| format!("Failed to show debug notification: {}", e))
@@ -563,4 +572,69 @@ pub async fn show_meeting_reminder_notification(
         log_error!("Cannot show meeting reminder notification: manager not initialized");
         Ok(())
     }
+}
+
+/// Show "Meeting detected" notification. Lazy-initializes the manager on
+/// first call, matching `show_recording_started_notification`.
+pub async fn show_meeting_detected_notification<R: Runtime>(
+    app_handle: &tauri::AppHandle<R>,
+    manager_state: &NotificationManagerState<R>,
+    app_name: String,
+) -> Result<()> {
+    log_info!("Attempting to show meeting-detected notification for: {}", app_name);
+
+    let manager_lock = manager_state.read().await;
+    if let Some(manager) = manager_lock.as_ref() {
+        return manager.show_meeting_detected(app_name).await;
+    }
+    drop(manager_lock);
+
+    match initialize_notification_manager(app_handle.clone()).await {
+        Ok(manager) => {
+            let mut state_lock = manager_state.write().await;
+            *state_lock = Some(manager);
+            drop(state_lock);
+            let manager_lock = manager_state.read().await;
+            match manager_lock.as_ref() {
+                Some(manager) => manager.show_meeting_detected(app_name).await,
+                None => Ok(()),
+            }
+        }
+        Err(e) => {
+            log_error!("Failed to init notification manager for meeting-detected: {}", e);
+            Ok(())
+        }
+    }
+}
+
+/// Show "Meeting ended" notification. Same pattern as meeting-detected.
+pub async fn show_meeting_ended_notification<R: Runtime>(
+    app_handle: &tauri::AppHandle<R>,
+    manager_state: &NotificationManagerState<R>,
+    app_name: String,
+) -> Result<()> {
+    log_info!("Attempting to show meeting-ended notification for: {}", app_name);
+
+    let manager_lock = manager_state.read().await;
+    if let Some(manager) = manager_lock.as_ref() {
+        return manager.show_meeting_ended(app_name).await;
+    }
+    drop(manager_lock);
+
+    match initialize_notification_manager(app_handle.clone()).await {
+        Ok(manager) => {
+            let mut state_lock = manager_state.write().await;
+            *state_lock = Some(manager);
+            drop(state_lock);
+            let manager_lock = manager_state.read().await;
+            match manager_lock.as_ref() {
+                Some(manager) => manager.show_meeting_ended(app_name).await,
+                None => Ok(()),
+            }
+        }
+        Err(e) => {
+            log_error!("Failed to init notification manager for meeting-ended: {}", e);
+            Ok(())
+        }
+    }
 }

frontend/src-tauri/src/notifications/manager.rs

@@ -189,6 +189,28 @@ impl<R: Runtime> NotificationManager<R> {
         self.system_handler.show_notification(notification).await
     }
 
+    /// Show a "Meeting detected" notification (mic-activity detection).
+    pub async fn show_meeting_detected(&self, app_name: String) -> Result<()> {
+        let settings = self.settings.read().await;
+        if !settings.notification_preferences.show_meeting_detected {
+            return Ok(());
+        }
+        drop(settings);
+        let notification = Notification::meeting_detected(app_name);
+        self.show_notification(notification).await
+    }
+
+    /// Show a "Meeting ended" notification (mic-activity detection).
+    pub async fn show_meeting_ended(&self, app_name: String) -> Result<()> {
+        let settings = self.settings.read().await;
+        if !settings.notification_preferences.show_meeting_ended {
+            return Ok(());
+        }
+        drop(settings);
+        let notification = Notification::meeting_ended(app_name);
+        self.show_notification(notification).await
+    }
+
     /// Get current notification settings
     pub async fn get_settings(&self) -> NotificationSettings {
         self.settings.read().await.clone()
@@ -301,6 +323,8 @@ impl<R: Runtime> NotificationManager<R> {
             NotificationType::MeetingReminder(_) => settings.notification_preferences.show_meeting_reminders,
             NotificationType::SystemError(_) => settings.notification_preferences.show_system_errors,
             NotificationType::Test => true, // Always show test notifications
+            NotificationType::MeetingDetected(_) => settings.notification_preferences.show_meeting_detected,
+            NotificationType::MeetingEnded(_) => settings.notification_preferences.show_meeting_ended,
         }
     }
 

frontend/src-tauri/src/notifications/settings.rs

@@ -60,6 +60,19 @@ pub struct NotificationPreferences {
 
     /// Minutes before meeting to show reminder (0 = disabled)
     pub meeting_reminder_minutes: Vec<u64>,
+
+    /// Show "Meeting detected" banner when mic-activity detection fires.
+    #[serde(default = "default_true")]
+    pub show_meeting_detected: bool,
+
+    /// Show "Meeting ended" banner when mic-activity detection fires
+    /// during an active recording.
+    #[serde(default = "default_true")]
+    pub show_meeting_ended: bool,
+}
+
+fn default_true() -> bool {
+    true
 }
 
 impl Default for NotificationSettings {
@@ -89,6 +102,8 @@ impl Default for NotificationPreferences {
             show_meeting_reminders: true,
             show_system_errors: true,
             meeting_reminder_minutes: vec![15, 5], // 15 minutes and 5 minutes before
+            show_meeting_detected: true,
+            show_meeting_ended: true,
         }
     }
 }

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

@@ -23,6 +23,14 @@ pub enum NotificationType {
     MeetingReminder(u64), // Duration in minutes
     SystemError(String),
     Test, // For testing notifications
+    /// Auto-detected meeting start — a non-Meetily app has held the mic
+    /// past the sustain threshold. Payload is the detected app's display
+    /// name (e.g. "Zoom", "a browser meeting", "a meeting").
+    MeetingDetected(String),
+    /// Auto-detected meeting end — the previously-detected app released
+    /// the mic for the full end-silence window while Meetily was
+    /// recording. Payload is the detected app's display name.
+    MeetingEnded(String),
 }
 
 #[derive(Debug, Clone, Serialize, Deserialize)]
@@ -196,4 +204,28 @@ impl Notification {
         .with_priority(NotificationPriority::Normal)
         .with_timeout(NotificationTimeout::Seconds(5))
     }
+
+    pub fn meeting_detected(app_name: impl Into<String>) -> Self {
+        let app = app_name.into();
+        let body = if app == "a meeting" || app == "a browser meeting" {
+            format!("Meeting detected — tap to start recording")
+        } else {
+            format!("Meeting detected — {}", app)
+        };
+
+        Notification::new("Meetily", body, NotificationType::MeetingDetected(app))
+            .with_priority(NotificationPriority::High)
+            .with_timeout(NotificationTimeout::Seconds(10))
+    }
+
+    pub fn meeting_ended(app_name: impl Into<String>) -> Self {
+        let app = app_name.into();
+        Notification::new(
+            "Meetily",
+            "Meeting ended — tap to stop recording",
+            NotificationType::MeetingEnded(app),
+        )
+        .with_priority(NotificationPriority::High)
+        .with_timeout(NotificationTimeout::Seconds(10))
+    }
 }

frontend/src/components/About.tsx

@@ -22,7 +22,9 @@ type DebugNotificationKind =
     | 'transcription_complete'
     | 'meeting_reminder'
     | 'system_error'
-    | 'test';
+    | 'test'
+    | 'meeting_detected'
+    | 'meeting_ended';
 
 // `prefKey` matches a Rust NotificationPreferences field; omitted when a type isn't gated by preference.
 const DEBUG_NOTIFICATION_ITEMS: Array<{
@@ -38,6 +40,8 @@ const DEBUG_NOTIFICATION_ITEMS: Array<{
     { kind: 'meeting_reminder',       label: 'Meeting reminder (5 min)', prefKey: 'show_meeting_reminders' },
     { kind: 'system_error',           label: 'System error',             prefKey: 'show_system_errors' },
     { kind: 'test',                   label: 'Generic test notification' },
+    { kind: 'meeting_detected',       label: 'Meeting detected (auto)',  prefKey: 'show_meeting_detected' },
+    { kind: 'meeting_ended',          label: 'Meeting ended (auto)',     prefKey: 'show_meeting_ended' },
 ];