@agent-native/core 0.91.1 → 0.92.0

package/corpus/templates/clips/desktop/src-tauri/src/clips/mod.rs

@@ -15,8 +15,8 @@ use tauri::{
 
 use crate::dlog;
 use crate::state::{
-    DictationActive, LastTranscript, MeetingActive, RecordingActive, TrayAnchor, VoiceTargetBundle,
-    VoiceWakePopover,
+    ActiveMeetingId, DictationActive, LastTranscript, MeetingActive, RecordingActive, TrayAnchor,
+    VoiceTargetBundle, VoiceWakePopover,
 };
 use crate::util::{
     build_overlay_url, configure_overlay_behavior, hide_voice_wake_popover, is_recording_active,
@@ -56,7 +56,7 @@ const ONBOARDING_HEIGHT_LOGICAL: f64 = 640.0;
 /// launch — this matches Loom's out-of-the-box behavior.
 const BUBBLE_SIZE_SMALL: u32 = 360;
 const BUBBLE_SIZE_MEDIUM: u32 = 504;
-const POPOVER_SHADOW_GUTTER_LOGICAL: f64 = 12.0;
+const POPOVER_SHADOW_GUTTER_LOGICAL: f64 = 24.0;
 const POPOVER_DEFAULT_WIDTH_LOGICAL: f64 = 360.0;
 const POPOVER_DEFAULT_HEIGHT_LOGICAL: f64 = 520.0;
 const OVERLAY_SHADOW_GUTTER_LOGICAL: f64 = 18.0;
@@ -969,8 +969,11 @@ pub async fn hide_overlays(app: AppHandle) -> Result<(), String> {
             let _ = w.close();
         }
     }
-    // A recording pill may be owned by meeting or voice flows; tear it down too.
-    let _ = crate::recording_indicator::recording_pill_hide(app).await;
+    // The meeting pill belongs to the live notes session, not the popover's
+    // camera/bubble lifecycle. Keep it visible when the popover closes.
+    if !crate::util::is_meeting_active(&app) {
+        let _ = crate::recording_indicator::recording_pill_hide(app).await;
+    }
     Ok(())
 }
 
@@ -1887,16 +1890,37 @@ pub async fn set_recording_state(app: AppHandle, active: bool) -> Result<(), Str
 /// teardown in `lib.rs`: quit stays instant when no meeting is active, and
 /// only waits for a graceful stop when one is.
 #[tauri::command]
-pub async fn set_meeting_active(app: AppHandle, active: bool) -> Result<(), String> {
-    dlog!("[clips-tray] set_meeting_active active={}", active);
+pub async fn set_meeting_active(
+    app: AppHandle,
+    active: bool,
+    meeting_id: Option<String>,
+) -> Result<(), String> {
+    dlog!(
+        "[clips-tray] set_meeting_active active={} meeting_id={:?}",
+        active,
+        meeting_id
+    );
     if let Some(state) = app.try_state::<MeetingActive>() {
         if let Ok(mut g) = state.0.lock() {
             *g = active;
         }
     }
+    if let Some(state) = app.try_state::<ActiveMeetingId>() {
+        if let Ok(mut g) = state.0.lock() {
+            *g = if active { meeting_id } else { None };
+        }
+    }
+    crate::tray::rebuild_tray_menu(&app);
     Ok(())
 }
 
+#[tauri::command]
+pub async fn get_active_meeting_id(app: AppHandle) -> Result<Option<String>, String> {
+    Ok(app
+        .try_state::<ActiveMeetingId>()
+        .and_then(|s| s.0.lock().ok().and_then(|g| g.clone())))
+}
+
 /// Guards the quit-teardown handshake in `lib.rs`'s `ExitRequested` handler:
 /// 0 = not requested, 1 = requested (waiting on JS), 2 = done (safe to let
 /// the process exit — including the watchdog's own forced exit, which must
@@ -1937,6 +1961,16 @@ pub async fn reset_state(app: AppHandle) -> Result<(), String> {
             *g = false;
         }
     }
+    if let Some(state) = app.try_state::<MeetingActive>() {
+        if let Ok(mut g) = state.0.lock() {
+            *g = false;
+        }
+    }
+    if let Some(state) = app.try_state::<ActiveMeetingId>() {
+        if let Ok(mut g) = state.0.lock() {
+            *g = None;
+        }
+    }
     if let Some(w) = app.get_webview_window(REGION_GUIDES_LABEL) {
         let _ = w.close();
     }

package/corpus/templates/clips/desktop/src-tauri/src/lib.rs

@@ -5,6 +5,7 @@
 //! is served by the Vite-built React UI (see `../dist`).
 
 mod accessibility;
+mod adhoc_meetings_watcher;
 mod clips;
 mod config;
 mod debug;
@@ -32,8 +33,8 @@ use tauri::{Emitter, Manager};
 
 use clips::{position_popover, toggle_popover};
 use state::{
-    DictationActive, DictationEnabled, LastTranscript, MeetingActive, PopoverShownAt,
-    RecordingActive, TrayAnchor, TrayMeetings, VoiceTargetBundle, VoiceWakePopover,
+    ActiveMeetingId, DictationActive, DictationEnabled, LastTranscript, MeetingActive,
+    PopoverShownAt, RecordingActive, TrayAnchor, TrayMeetings, VoiceTargetBundle, VoiceWakePopover,
 };
 use util::{
     configure_overlay_behavior, is_recording_active, present_interactive_window,
@@ -94,6 +95,7 @@ pub fn run() {
             clips::paste_last_dictation,
             clips::set_recording_state,
             clips::set_meeting_active,
+            clips::get_active_meeting_id,
             clips::quit_teardown_done,
             clips::reset_state,
             clips::save_bubble_position,
@@ -203,6 +205,7 @@ pub fn run() {
         .manage(PopoverShownAt::default())
         .manage(RecordingActive::default())
         .manage(MeetingActive::default())
+        .manage(ActiveMeetingId::default())
         .manage(DictationEnabled::default())
         .manage(DictationActive::default())
         .manage(VoiceWakePopover::default())
@@ -211,6 +214,7 @@ pub fn run() {
         .manage(native_screen::NativeFullscreenRecordingState::default())
         .manage(screen_memory::ScreenMemoryState::default())
         .manage(meetings_watcher::MeetingsWatcherState::default())
+        .manage(adhoc_meetings_watcher::AdhocMeetingsWatcherState::default())
         .manage(notifications::MeetingNotificationState::default())
         .manage(silence_detector::DetectorState::default())
         .setup(|app| {
@@ -260,6 +264,9 @@ pub fn run() {
             // server URL via `meetings_watcher_set_server_url` once the
             // popover boots.
             meetings_watcher::spawn_watcher(app.handle().clone());
+            // Granola-style adhoc Zoom/Teams detection — shares session
+            // credentials with the calendar watcher above.
+            adhoc_meetings_watcher::spawn_watcher(app.handle().clone());
 
             // Pre-download the Whisper model in the background so the first
             // meeting doesn't pay the ~142 MB download cost mid-call. Skipped

package/corpus/templates/clips/desktop/src-tauri/src/meetings_watcher.rs

@@ -2,9 +2,9 @@
 //!
 //! Runs as a tokio task spawned from `lib.rs::run` setup. Every 30s it calls
 //! the backend's `list-meetings` action for the next handful of live Google
-//! Calendar meetings. For any meeting starting in the next 5 minutes we
-//! haven't already alerted on, we fire a native notification + the in-app
-//! banner overlay.
+//! Calendar meetings. For any meeting in the Granola-style reminder window
+//! (1 minute before start through 5 minutes after) that we haven't already
+//! alerted on, we fire the in-app banner overlay.
 //!
 //! ## Wire-up (from the popover renderer)
 //!
@@ -39,8 +39,12 @@ use crate::tray_meetings::MeetingItem as TrayMeetingItem;
 
 const MEETING_POLL_LIMIT: u8 = 10;
 
-/// Notify when a meeting starts within this many seconds (the reminder lead).
-const NOTIFY_LEAD_SECS: i64 = 300;
+/// Show the reminder starting this many seconds before meeting start.
+const NOTIFY_LEAD_SECS: i64 = 60;
+
+/// Keep reminding eligible (until dismissed / acted on) this many seconds
+/// after the scheduled start. Overlay auto-hide mirrors this hold window.
+const NOTIFY_HOLD_AFTER_START_SECS: i64 = 5 * 60;
 
 /// Forget de-dupe / snooze entries once a meeting's start is this far past, so
 /// the maps don't grow unbounded across a long-running session.
@@ -80,6 +84,53 @@ struct MeetingsWatcherInner {
     /// meetingId -> unix-seconds deadline. While now < deadline the meeting is
     /// skipped; once it passes we re-fire the reminder exactly once.
     snoozed_until: HashMap<String, i64>,
+    /// platform -> unix-seconds when a calendar reminder last fired. Soft
+    /// guard so adhoc Zoom/Teams detection doesn't double-prompt right after
+    /// a calendar banner for the same app.
+    last_calendar_notify_at: HashMap<String, i64>,
+}
+
+/// Snapshot of auth fields the adhoc watcher needs to POST create-meeting.
+#[derive(Clone, Default)]
+pub struct MeetingsSessionSnapshot {
+    pub server_url: Option<String>,
+    pub session_cookie: Option<String>,
+    pub auth_token: Option<String>,
+}
+
+impl MeetingsWatcherState {
+    pub fn session_snapshot(&self) -> MeetingsSessionSnapshot {
+        let Ok(g) = self.inner.lock() else {
+            return MeetingsSessionSnapshot::default();
+        };
+        MeetingsSessionSnapshot {
+            server_url: g.server_url.clone(),
+            session_cookie: g.session_cookie.clone(),
+            auth_token: g.auth_token.clone(),
+        }
+    }
+
+    pub fn note_calendar_notify(&self, platform: Option<&str>) {
+        let Some(platform) = platform.map(str::trim).filter(|p| !p.is_empty()) else {
+            return;
+        };
+        if let Ok(mut g) = self.inner.lock() {
+            g.last_calendar_notify_at
+                .insert(platform.to_lowercase(), chrono::Utc::now().timestamp());
+        }
+    }
+
+    /// True if a calendar reminder for `platform` fired within `within_secs`.
+    pub fn recent_calendar_notify(&self, platform: &str, within_secs: i64) -> bool {
+        let Ok(g) = self.inner.lock() else {
+            return false;
+        };
+        let key = platform.to_lowercase();
+        let Some(at) = g.last_calendar_notify_at.get(&key).copied() else {
+            return false;
+        };
+        chrono::Utc::now().timestamp() - at <= within_secs
+    }
 }
 
 #[derive(Debug, Clone, Deserialize, Serialize)]
@@ -88,8 +139,12 @@ struct MeetingItem {
     title: Option<String>,
     #[serde(default, alias = "scheduledStart")]
     scheduled_start: Option<String>,
+    #[serde(default, alias = "scheduledEnd")]
+    scheduled_end: Option<String>,
     #[serde(default, alias = "joinUrl")]
     join_url: Option<String>,
+    #[serde(default)]
+    platform: Option<String>,
 }
 
 #[derive(Debug, Deserialize)]
@@ -232,9 +287,17 @@ async fn tick_once(app: &AppHandle, client: &reqwest::Client) -> Result<(), Stri
 
     let url = format!("{}/_agent-native/actions/list-meetings", server_url);
     let limit = MEETING_POLL_LIMIT.to_string();
-    let mut req = client
-        .get(&url)
-        .query(&[("view", "upcoming"), ("limit", limit.as_str())]);
+    // Include meetings that started within the hold window so a late-open
+    // desktop still surfaces the reminder until 5 minutes after start.
+    let within_min = ((NOTIFY_LEAD_SECS + NOTIFY_HOLD_AFTER_START_SECS) / 60 + 1).to_string();
+    let mut req = client.get(&url).query(&[
+        ("view", "upcoming"),
+        ("limit", limit.as_str()),
+        ("upcomingWithinMin", within_min.as_str()),
+        // list-meetings also uses this for the lower bound when we widen the
+        // upcoming window to include recently-started events (see action).
+        ("includeStartedWithinMin", "5"),
+    ]);
     req = req.header("X-Request-Source", "clips-desktop");
     if let Some(c) = cookie.as_deref() {
         req = req.header("Cookie", c);
@@ -301,14 +364,19 @@ async fn tick_once(app: &AppHandle, client: &reqwest::Client) -> Result<(), Stri
             g.snoozed_until
                 .retain(|_, until| *until > now_ts - STALE_AFTER_SECS);
 
+            // Eligible from 1 min before start through 5 min after start.
+            // secs_until > 0 => still upcoming; negative => already started.
+            let in_window =
+                secs_until <= NOTIFY_LEAD_SECS && secs_until >= -NOTIFY_HOLD_AFTER_START_SECS;
+
             let eligible = match g.snoozed_until.get(&m.id).copied() {
                 Some(until) if now_ts < until => false, // still snoozed
                 Some(_) => {
-                    // Snooze elapsed — re-fire now regardless of the lead window.
+                    // Snooze elapsed — re-fire if still inside the hold window.
                     g.snoozed_until.remove(&m.id);
-                    true
+                    in_window
                 }
-                None => (0..=NOTIFY_LEAD_SECS).contains(&secs_until),
+                None => in_window,
             };
 
             if !eligible {
@@ -333,10 +401,16 @@ async fn tick_once(app: &AppHandle, client: &reqwest::Client) -> Result<(), Stri
         if config.show_meeting_widget_enabled
             || config.meeting_transcription_mode == MeetingTranscriptionMode::Auto
         {
+            if let Some(state) = app.try_state::<MeetingsWatcherState>() {
+                state.note_calendar_notify(m.platform.as_deref());
+            }
             let app_clone = app.clone();
             let id_clone = m.id.clone();
             let title_clone = title.clone();
             let join_clone = join_url.clone();
+            let start_clone = m.scheduled_start.clone();
+            let end_clone = m.scheduled_end.clone();
+            let platform_clone = m.platform.clone();
             let auto_start = config.meeting_transcription_mode == MeetingTranscriptionMode::Auto;
             tauri::async_runtime::spawn(async move {
                 let _ = crate::notifications::notify_meeting_starting(
@@ -345,7 +419,11 @@ async fn tick_once(app: &AppHandle, client: &reqwest::Client) -> Result<(), Stri
                     title_clone,
                     secs_until,
                     join_clone,
+                    start_clone,
+                    end_clone,
+                    platform_clone,
                     Some(auto_start),
+                    None,
                 )
                 .await;
             });

package/corpus/templates/clips/desktop/src-tauri/src/native_screen.rs

@@ -65,18 +65,36 @@ const AUDIO_DENOISE_FILTER: &str = "afftdn=nr=10:nf=-50:tn=1";
 // explicit output rate the AAC track ends up at 192 kHz and plays back slow.
 const AUDIO_OUTPUT_SAMPLE_RATE: u32 = 48000;
 
+// Pre-gain for mic-only native captures. ScreenCaptureKit records without
+// WebRTC AGC (unlike Loom / the browser path), so speech often lands well
+// below -16 LUFS. 12 dB before loudnorm matches Loom-ish perceptual loudness
+// for MacBook mics; loudnorm still clamps true peaks at TP=-1.5.
+const AUDIO_MIC_PREGAIN_FILTER: &str = "volume=12dB";
+// After the mic+system centered downmix (0.5*L+0.5*R) each source is ~
+// 6 dB quieter. Restore energy before loudnorm so dual-capture clips are not
+// systematically quieter than mic-only. Dual still mixes two sources so peaks
+// may compress more under loudnorm than mic-only — by design when both sides
+// compete for the same LUFS budget.
+const AUDIO_DOWNMIX_MAKEUP_FILTER: &str = "volume=6dB";
+
 // Loudness normalization, optionally preceded by the centered-stereo downmix
 // that repairs the mic+system L/R split and denoise for native mic captures.
 // Pair with `-ar AUDIO_OUTPUT_SAMPLE_RATE` so loudnorm's 192 kHz output is
 // resampled back.
-fn audio_filter_chain(downmix: bool, denoise: bool) -> String {
+fn audio_filter_chain(downmix: bool, denoise: bool, mic_pregain: bool) -> String {
     let mut filters = Vec::new();
     if downmix {
         filters.push(AUDIO_DOWNMIX_FILTER);
+        // Undo pan attenuation; do not also apply mic-only pregain here —
+        // system audio would get a double boost.
+        filters.push(AUDIO_DOWNMIX_MAKEUP_FILTER);
     }
     if denoise {
         filters.push(AUDIO_DENOISE_FILTER);
     }
+    if mic_pregain {
+        filters.push(AUDIO_MIC_PREGAIN_FILTER);
+    }
     filters.push(AUDIO_LOUDNESS_FILTER);
     filters.join(",")
 }
@@ -522,11 +540,17 @@ struct SavedNativeRecording {
     height: Option<u32>,
     bytes: u64,
     has_audio: bool,
-    // Whether the mic was captured. Drives the centered-stereo downmix repair
-    // for the mic+system L/R split. Defaults to false for recordings queued
-    // before this field existed so their audio is left untouched.
+    // Whether the mic was captured. Drives denoise + (with system audio) the
+    // centered-stereo downmix repair for the mic+system L/R split. Defaults to
+    // false for recordings queued before this field existed so their audio is
+    // left untouched.
     #[serde(default)]
     mic_captured: bool,
+    // Whether system audio was captured alongside the mic. Needed to decide
+    // downmix vs mic-only pregain on retry uploads. Defaults to false for
+    // older pending files (safe: skips downmix that would attenuate mic-only).
+    #[serde(default)]
+    system_audio_captured: bool,
     has_camera: bool,
     saved_at: String,
     last_attempt_at: Option<String>,
@@ -2577,6 +2601,7 @@ fn saved_recording_from_path(
         bytes,
         has_audio,
         mic_captured: session.restart.mic_captured_in_file,
+        system_audio_captured: session.restart.capture_system_audio,
         has_camera,
         saved_at: now_iso(),
         last_attempt_at: None,
@@ -3071,6 +3096,7 @@ async fn upload_recording_file(
         Some(duration_ms),
         has_audio,
         session.restart.mic_captured_in_file,
+        session.restart.capture_system_audio,
     )?;
     let upload_result = upload_prepared_recording_file(
         app,
@@ -3152,6 +3178,7 @@ fn prepare_saved_recording_file(
         Some(saved.duration_ms),
         saved.has_audio,
         saved.mic_captured,
+        saved.system_audio_captured,
     )?;
     Ok((prepared, retry_combined_path))
 }
@@ -3878,7 +3905,14 @@ fn prepare_recording_file(
     duration_ms: Option<u128>,
     has_audio: bool,
     mic_captured_audio: bool,
+    system_audio_captured: bool,
 ) -> Result<PreparedRecordingFile, String> {
+    // Downmix only repairs mic+system L/R split. Applying it to mic-only
+    // capture halves speech energy (~6 dB) when SCK puts the mic on one channel.
+    let downmix_audio = mic_captured_audio && system_audio_captured;
+    let denoise_audio = mic_captured_audio;
+    // Pregain only for mic-only (no system audio compete) — SCK has no AGC.
+    let mic_pregain = mic_captured_audio && !system_audio_captured;
     let metadata = std::fs::metadata(path).map_err(|e| {
         let diag = describe_recording_path(path);
         eprintln!("[clips-tray] native recording file missing at prepare: {e}; {diag}");
@@ -3935,8 +3969,9 @@ fn prepare_recording_file(
                     ffmpeg_path,
                     path,
                     &normalized_path,
-                    mic_captured_audio,
-                    mic_captured_audio,
+                    downmix_audio,
+                    denoise_audio,
+                    mic_pregain,
                 ) {
                     Ok(()) => {
                         let normalized_bytes = std::fs::metadata(&normalized_path)
@@ -4022,8 +4057,9 @@ fn prepare_recording_file(
                 height,
                 duration_ms,
                 has_audio,
-                mic_captured_audio,
-                mic_captured_audio,
+                downmix_audio,
+                denoise_audio,
+                mic_pregain,
             ) {
                 Ok(()) => {
                     let compressed_bytes = std::fs::metadata(&compressed_path)
@@ -4421,6 +4457,7 @@ fn normalize_audio_with_ffmpeg(
     output: &Path,
     downmix_audio: bool,
     denoise_audio: bool,
+    mic_pregain: bool,
 ) -> Result<(), String> {
     let audio_bitrate = format!("{NORMALIZED_AUDIO_BITRATE_KBPS}k");
     let mut command = Command::new(ffmpeg_path);
@@ -4442,7 +4479,11 @@ fn normalize_audio_with_ffmpeg(
         .arg("-b:a")
         .arg(audio_bitrate)
         .arg("-af")
-        .arg(audio_filter_chain(downmix_audio, denoise_audio))
+        .arg(audio_filter_chain(
+            downmix_audio,
+            denoise_audio,
+            mic_pregain,
+        ))
         .arg("-ac")
         .arg("2")
         .arg("-ar")
@@ -4507,6 +4548,7 @@ fn transcode_with_ffmpeg(
     normalize_audio: bool,
     downmix_audio: bool,
     denoise_audio: bool,
+    mic_pregain: bool,
 ) -> Result<(), String> {
     let mut command = Command::new(ffmpeg_path);
     command
@@ -4530,9 +4572,11 @@ fn transcode_with_ffmpeg(
     }
 
     if normalize_audio {
-        command
-            .arg("-af")
-            .arg(audio_filter_chain(downmix_audio, denoise_audio));
+        command.arg("-af").arg(audio_filter_chain(
+            downmix_audio,
+            denoise_audio,
+            mic_pregain,
+        ));
     }
 
     let duration_rate_limit =
@@ -4965,7 +5009,8 @@ fn concat_mp4_segments(segments: &[PathBuf], output: &Path) -> Result<(), String
 mod audio_track_probe_tests {
     use super::{
         audio_filter_chain, mp4_has_audio_track, parse_ffmpeg_volume_db, AudioSignalProbe,
-        AUDIO_DENOISE_FILTER, AUDIO_DOWNMIX_FILTER, AUDIO_LOUDNESS_FILTER,
+        AUDIO_DENOISE_FILTER, AUDIO_DOWNMIX_FILTER, AUDIO_DOWNMIX_MAKEUP_FILTER,
+        AUDIO_LOUDNESS_FILTER, AUDIO_MIC_PREGAIN_FILTER,
     };
     use std::io::Write;
 
@@ -5006,14 +5051,23 @@ mod audio_track_probe_tests {
 
     #[test]
     fn builds_native_audio_filter_chain_for_mic_noise_reduction() {
-        assert_eq!(audio_filter_chain(false, false), AUDIO_LOUDNESS_FILTER);
         assert_eq!(
-            audio_filter_chain(false, true),
+            audio_filter_chain(false, false, false),
+            AUDIO_LOUDNESS_FILTER
+        );
+        assert_eq!(
+            audio_filter_chain(false, true, false),
             format!("{AUDIO_DENOISE_FILTER},{AUDIO_LOUDNESS_FILTER}")
         );
         assert_eq!(
-            audio_filter_chain(true, true),
-            format!("{AUDIO_DOWNMIX_FILTER},{AUDIO_DENOISE_FILTER},{AUDIO_LOUDNESS_FILTER}")
+            audio_filter_chain(false, true, true),
+            format!("{AUDIO_DENOISE_FILTER},{AUDIO_MIC_PREGAIN_FILTER},{AUDIO_LOUDNESS_FILTER}")
+        );
+        assert_eq!(
+            audio_filter_chain(true, true, false),
+            format!(
+                "{AUDIO_DOWNMIX_FILTER},{AUDIO_DOWNMIX_MAKEUP_FILTER},{AUDIO_DENOISE_FILTER},{AUDIO_LOUDNESS_FILTER}"
+            )
         );
     }
 

package/corpus/templates/clips/desktop/src-tauri/src/native_speech.rs

@@ -134,7 +134,8 @@ pub(crate) mod macos {
         kAudioOutputUnitProperty_CurrentDevice, kAudioUnitScope_Global, AudioUnitSetProperty,
     };
     use objc2_avf_audio::{
-        AVAudioEngine, AVAudioInputNode, AVAudioPCMBuffer, AVAudioTime,
+        AVAudioEngine, AVAudioInputNode, AVAudioPCMBuffer, AVAudioSession,
+        AVAudioSessionCategoryOptions, AVAudioSessionCategoryPlayAndRecord, AVAudioTime,
         AVAudioVoiceProcessingOtherAudioDuckingConfiguration,
         AVAudioVoiceProcessingOtherAudioDuckingLevel,
     };
@@ -652,6 +653,36 @@ pub(crate) mod macos {
         }
     }
 
+    /// Keep Zoom/Meet/Teams' own mic uplink alive while Clips opens a parallel
+    /// AVAudioEngine tap. Without MixWithOthers, PlayAndRecord takes exclusive
+    /// session ownership and other apps' live calls get ducked or starved even
+    /// when VoiceProcessingIO is off.
+    fn configure_shared_mic_audio_session() {
+        unsafe {
+            let session = AVAudioSession::sharedInstance();
+            let Some(category) = AVAudioSessionCategoryPlayAndRecord else {
+                eprintln!("[whisper-mic] PlayAndRecord category missing — skipping MixWithOthers");
+                return;
+            };
+            let options = AVAudioSessionCategoryOptions::MixWithOthers;
+            if let Err(err) = session.setCategory_withOptions_error(category, options) {
+                eprintln!(
+                    "[whisper-mic] setCategory MixWithOthers failed: {} — continuing",
+                    ns_error_message(&err)
+                );
+                return;
+            }
+            if let Err(err) = session.setActive_error(true) {
+                eprintln!(
+                    "[whisper-mic] AVAudioSession setActive failed: {} — continuing",
+                    ns_error_message(&err)
+                );
+                return;
+            }
+            eprintln!("[whisper-mic] AVAudioSession PlayAndRecord + MixWithOthers active");
+        }
+    }
+
     fn take_warmed_raw_mic_engine(device_key: &RawMicDeviceKey) -> Option<WarmedRawMicEngine> {
         let mut slot = warmed_raw_mic_engine_slot().lock().ok()?;
         let should_reuse = slot
@@ -758,6 +789,7 @@ pub(crate) mod macos {
         mic_device_label: Option<&str>,
         device_key: RawMicDeviceKey,
     ) -> Result<WarmedRawMicEngine, String> {
+        configure_shared_mic_audio_session();
         let engine: Retained<AVAudioEngine> = unsafe { AVAudioEngine::new() };
         configure_engine_input_device(&engine, mic_device_id, mic_device_label)?;
         let input_node: Retained<AVAudioInputNode> = unsafe { engine.inputNode() };
@@ -955,6 +987,7 @@ pub(crate) mod macos {
         // Spin up the engine and grab its input node + native format.
         // SAFETY: `AVAudioEngine::new()` returns a retained engine.
         // `inputNode` is the engine's singleton input — also retained.
+        configure_shared_mic_audio_session();
         let engine: Retained<AVAudioEngine> = unsafe { AVAudioEngine::new() };
         configure_engine_input_device(
             &engine,
@@ -1321,6 +1354,8 @@ pub(crate) mod macos {
         }
         clear_warmed_raw_mic_engine();
 
+        configure_shared_mic_audio_session();
+
         let engine: Retained<AVAudioEngine> = unsafe { AVAudioEngine::new() };
         configure_engine_input_device(
             &engine,