Skip to content

YC (S26) | Open Computer History | Continuously record your company computer work, map your workflows, help you find work worth automating, and power your agents' context

fix(meetings): probe browsers for active-tab URL, start on live evidence (#4803)

Ezra Ellette3fd38b295b68
diff --git a/crates/screenpipe-engine/src/meeting_watcher/audio_process/macos.rs b/crates/screenpipe-engine/src/meeting_watcher/audio_process/macos.rs
index 5cf05b478..d0a4369b9 100644
--- a/crates/screenpipe-engine/src/meeting_watcher/audio_process/macos.rs
+++ b/crates/screenpipe-engine/src/meeting_watcher/audio_process/macos.rs
@@ -8,6 +8,68 @@ use super::*;
use crate::meeting_watcher::shared::ignore::{is_browser_app, meeting_app_is_ignored_with_terms};
use crate::meeting_watcher::shared::profiles::MeetingDetectionProfile;
+/// Ask each mic-holding browser directly for its active-tab URL and match it
+/// against the meeting profiles.
+///
+/// Uses the same per-browser detector as the vision pipeline
+/// (`browser_utils::create_url_detector`): AppleScript for Arc, AXDocument /
+/// AX address-bar walk for the rest. AppleScript reads the URL even when the
+/// browser shows no URL bar at all, so this resolves e.g. Arc + Google Meet
+/// within one poll of the mic being taken instead of waiting for the vision
+/// pipeline to happen to capture a frame.
+///
+/// Only called while a browser candidate is still unresolved (same gating as
+/// `ax_resolved_candidates`), so the ~100ms osascript round-trip runs at most
+/// once per poll during that window. The whole probe is capped by a timeout so
+/// a hung browser can't stall the detection loop.
+pub(crate) async fn active_tab_url_candidates(
+ browser_apps: &[String],
+ profiles: &[MeetingDetectionProfile],
+ ignored_terms: &[String],
+) -> Vec<AxResolvedCandidate> {
+ let browser_apps = browser_apps.to_vec();
+ let profiles = profiles.to_vec();
+ let ignored_terms = ignored_terms.to_vec();
+ let probe = tokio::task::spawn_blocking(move || {
+ let detector = screenpipe_screen::browser_utils::create_url_detector();
+ browser_apps
+ .iter()
+ .filter_map(|app| {
+ let pid = crate::meeting_watcher::ui_scan::resolve_browser_pid(app);
+ if pid <= 0 {
+ return None;
+ }
+ let url = match detector.get_active_url(app, pid, "") {
+ Ok(Some(url)) => url,
+ Ok(None) => return None,
+ Err(e) => {
+ debug!(
+ "audio-process meeting detector: active-tab URL probe failed for {}: {}",
+ app, e
+ );
+ return None;
+ }
+ };
+ let candidate = resolve_active_tab_url_candidate(app, &url, &profiles)?;
+ let profile = profiles.get(candidate.profile_index)?;
+ let platform = platform_name_for_profile(profile, true);
+ if meeting_app_is_ignored_with_terms(&platform, profile, &ignored_terms) {
+ return None;
+ }
+ debug!(
+ "audio-process meeting detector: active-tab URL probe resolved {} to {}",
+ app, platform
+ );
+ Some(candidate)
+ })
+ .collect()
+ });
+ match tokio::time::timeout(Duration::from_secs(3), probe).await {
+ Ok(Ok(candidates)) => candidates,
+ _ => Vec::new(),
+ }
+}
+
pub(crate) async fn ax_resolved_candidates(
profiles: &[MeetingDetectionProfile],
ignored_terms: &[String],
diff --git a/crates/screenpipe-engine/src/meeting_watcher/audio_process/mod.rs b/crates/screenpipe-engine/src/meeting_watcher/audio_process/mod.rs
index a066e0ee5..0ef5782e5 100644
--- a/crates/screenpipe-engine/src/meeting_watcher/audio_process/mod.rs
+++ b/crates/screenpipe-engine/src/meeting_watcher/audio_process/mod.rs
@@ -39,18 +39,32 @@ mod null;
mod windows;
#[cfg(target_os = "macos")]
-use macos::ax_resolved_candidates;
+use macos::{active_tab_url_candidates, ax_resolved_candidates};
#[cfg(not(any(target_os = "macos", target_os = "windows")))]
-use null::ax_resolved_candidates;
+use null::{active_tab_url_candidates, ax_resolved_candidates};
#[cfg(target_os = "windows")]
-use windows::ax_resolved_candidates;
+use windows::{active_tab_url_candidates, ax_resolved_candidates};
const STICKY_PROCESS_WINDOW: Duration = Duration::from_secs(4);
-const CANDIDATE_CONFIRM_WINDOW: Duration = Duration::from_secs(3);
+/// How long a session resolved from STORED evidence (DB frames, up to 10s
+/// stale) must persist before a meeting starts — two consecutive sightings at
+/// the 1s active poll, so one stale frame alone can't mint a meeting. Live
+/// evidence (active-tab probe, AX window sweep, native app identity) bypasses
+/// this entirely and starts on the first sighting. This window does NOT
+/// filter voice notes on messaging platforms (real voice notes run 5–60s and
+/// outlast any sane value) — that is #4776's call-signal gate, not this
+/// constant.
+const CANDIDATE_CONFIRM_WINDOW: Duration = Duration::from_secs(1);
const ENDING_GRACE: Duration = Duration::from_secs(20);
const ACTIVE_POLL_INTERVAL: Duration = Duration::from_secs(1);
const IDLE_POLL_INTERVAL: Duration = Duration::from_secs(5);
const UNKNOWN_BROWSER_PLATFORM: &str = "Unknown";
+/// Log (at INFO, so it lands in the shipped log file) once a mic-holding
+/// browser has stayed unattributed this long — the "my call was never
+/// detected" failure mode is otherwise completely silent.
+const UNRESOLVED_BROWSER_LOG_AFTER: Duration = Duration::from_secs(15);
+/// Rate limit for the unresolved-browser log line.
+const UNRESOLVED_BROWSER_LOG_EVERY: Duration = Duration::from_secs(60);
mod model;
pub(crate) use model::*;
@@ -89,6 +103,7 @@ pub async fn run_audio_process_meeting_detection_loop(
let mut last_explicit_stop_id: Option<i64> = None;
let mut suppressed_sessions: Vec<SuppressedSession> = Vec::new();
let mut flap_count = 0u32;
+ let mut last_unresolved_browser_log: Option<Instant> = None;
if close_orphaned_meetings_on_start {
match db.close_orphaned_meetings().await {
@@ -230,6 +245,34 @@ pub async fn run_audio_process_meeting_detection_loop(
}
state = new_state;
+ // A browser holding the mic that we can't attribute to a platform is
+ // the silent failure mode behind "my call was never detected": every
+ // resolution attempt happens at debug level. Surface it at INFO once
+ // it has been pending a while, rate-limited.
+ if let AudioProcessMeetingState::CandidateUnresolvedBrowser {
+ browser_app,
+ first_seen_at,
+ ..
+ } = &state
+ {
+ let pending_for = now.duration_since(*first_seen_at);
+ if pending_for >= UNRESOLVED_BROWSER_LOG_AFTER
+ && last_unresolved_browser_log
+ .is_none_or(|at| now.duration_since(at) >= UNRESOLVED_BROWSER_LOG_EVERY)
+ {
+ info!(
+ "audio-process meeting detector: {} has held the mic for {}s without \
+ resolving to a meeting platform (no fresh URL/title evidence and the \
+ active-tab probe found no meeting URL; still retrying every poll)",
+ browser_app,
+ pending_for.as_secs()
+ );
+ last_unresolved_browser_log = Some(now);
+ }
+ } else {
+ last_unresolved_browser_log = None;
+ }
+
if let Some(action) = action {
apply_state_action(
action,
diff --git a/crates/screenpipe-engine/src/meeting_watcher/audio_process/model.rs b/crates/screenpipe-engine/src/meeting_watcher/audio_process/model.rs
index bdca3d827..4d9880557 100644
--- a/crates/screenpipe-engine/src/meeting_watcher/audio_process/model.rs
+++ b/crates/screenpipe-engine/src/meeting_watcher/audio_process/model.rs
@@ -129,6 +129,12 @@ pub(crate) enum ResolvedMeetingCandidate {
session_key: ProcessKey,
first_seen_at: Instant,
process: AudioInputProcess,
+ /// True when the platform was observed live on this poll (active-tab
+ /// URL probe or AX window sweep) rather than replayed from stored
+ /// frame evidence, which can be up to 10s stale. Live evidence starts
+ /// a meeting on a single sighting; stored evidence waits out the
+ /// confirm window.
+ live_evidence: bool,
},
UnresolvedBrowser {
browser_app: String,
@@ -154,12 +160,16 @@ impl ResolvedMeetingCandidate {
meeting_url: None,
first_seen_at: *first_seen_at,
is_browser: false,
+ // A native app holding the mic is by definition a live
+ // observation of the current snapshot.
+ live_evidence: true,
}),
Self::Browser {
platform,
meeting_url,
session_key,
first_seen_at,
+ live_evidence,
..
} => Some(ResolvedSession {
platform: platform.clone(),
@@ -167,6 +177,7 @@ impl ResolvedMeetingCandidate {
meeting_url: Some(meeting_url.clone()),
first_seen_at: *first_seen_at,
is_browser: true,
+ live_evidence: *live_evidence,
}),
_ => None,
}
@@ -199,6 +210,9 @@ pub(crate) struct ResolvedSession {
pub(crate) meeting_url: Option<String>,
pub(crate) first_seen_at: Instant,
pub(crate) is_browser: bool,
+ /// See [`ResolvedMeetingCandidate::Browser::live_evidence`]. Always true
+ /// for native candidates.
+ pub(crate) live_evidence: bool,
}
#[derive(Debug, Clone, PartialEq, Eq)]
diff --git a/crates/screenpipe-engine/src/meeting_watcher/audio_process/null.rs b/crates/screenpipe-engine/src/meeting_watcher/audio_process/null.rs
index 0e641bab7..97f37b23d 100644
--- a/crates/screenpipe-engine/src/meeting_watcher/audio_process/null.rs
+++ b/crates/screenpipe-engine/src/meeting_watcher/audio_process/null.rs
@@ -13,3 +13,11 @@ pub(crate) async fn ax_resolved_candidates(
) -> Vec<AxResolvedCandidate> {
Vec::new()
}
+
+pub(crate) async fn active_tab_url_candidates(
+ _browser_apps: &[String],
+ _profiles: &[MeetingDetectionProfile],
+ _ignored_terms: &[String],
+) -> Vec<AxResolvedCandidate> {
+ Vec::new()
+}
diff --git a/crates/screenpipe-engine/src/meeting_watcher/audio_process/resolve.rs b/crates/screenpipe-engine/src/meeting_watcher/audio_process/resolve.rs
index 38a1c09be..7a5b02503 100644
--- a/crates/screenpipe-engine/src/meeting_watcher/audio_process/resolve.rs
+++ b/crates/screenpipe-engine/src/meeting_watcher/audio_process/resolve.rs
@@ -56,14 +56,70 @@ pub(crate) async fn should_use_ax_fallback(
profiles: &[MeetingDetectionProfile],
ignored_terms: &[String],
) -> Vec<AxResolvedCandidate> {
- let has_browser = tracked
+ let mut browser_apps: Vec<String> = tracked
.iter()
- .any(|(_, tracked)| browser_app_name(&tracked.raw).is_some());
- if !has_browser {
+ .filter_map(|(_, tracked)| browser_app_name(&tracked.raw))
+ .collect();
+ browser_apps.sort();
+ browser_apps.dedup();
+ if browser_apps.is_empty() {
return Vec::new();
}
- ax_resolved_candidates(profiles, ignored_terms).await
+ let mut candidates = ax_resolved_candidates(profiles, ignored_terms).await;
+
+ // The AX window sweep is blind on browsers that expose neither AXDocument
+ // nor a URL in the window title (Arc titles its in-call window with just
+ // the meeting code). For mic-holding browsers it could not attribute, ask
+ // the browser directly for its active-tab URL — this works with the URL
+ // bar hidden and does not depend on the vision pipeline having recently
+ // captured a frame (event-driven capture produces none on a static call
+ // screen, which starved `db_find_browser_evidence` exactly when a call
+ // just started).
+ let unattributed: Vec<String> = browser_apps
+ .into_iter()
+ .filter(|app| {
+ !candidates
+ .iter()
+ .any(|candidate| browser_names_match(app, &candidate.browser_app))
+ })
+ .collect();
+ if !unattributed.is_empty() {
+ candidates.extend(active_tab_url_candidates(&unattributed, profiles, ignored_terms).await);
+ }
+ candidates
+}
+
+/// Match a browser's live active-tab URL against the meeting profiles.
+///
+/// URL-only matching (titles are never consulted here), with query/fragment
+/// ignored by `browser_window_matches_meeting` so a meeting link carried as a
+/// parameter on an unrelated page can't resolve (#4246). The stored
+/// `meeting_url` keeps the browser-reported form for parity with the DB
+/// evidence path.
+pub(crate) fn resolve_active_tab_url_candidate(
+ browser_app: &str,
+ active_tab_url: &str,
+ profiles: &[MeetingDetectionProfile],
+) -> Option<AxResolvedCandidate> {
+ let url = active_tab_url.trim();
+ if url.is_empty() {
+ return None;
+ }
+ profiles.iter().enumerate().find_map(|(idx, profile)| {
+ if profile.app_identifiers.browser_url_patterns.is_empty() {
+ return None;
+ }
+ if browser_window_matches_meeting(Some(url), None, profile) {
+ Some(AxResolvedCandidate {
+ browser_app: browser_app.to_string(),
+ profile_index: idx,
+ meeting_url: Some(url.to_string()),
+ })
+ } else {
+ None
+ }
+ })
}
pub(crate) async fn db_find_browser_evidence(
@@ -101,11 +157,26 @@ pub(crate) fn resolve_process_candidate(
ignored_terms: &[String],
) -> ResolvedMeetingCandidate {
if let Some(browser_app) = browser_app_name(process) {
- if let Some((profile_index, meeting_url)) =
- resolve_browser_evidence(&browser_app, profiles, evidence)
- {
- let profile = &profiles[profile_index];
+ // Live observation first (active-tab URL probe / AX window sweep):
+ // it reflects the browser RIGHT NOW, while DB frame evidence can be
+ // up to 10s stale — a stale frame must never outrank a live answer.
+ // Live evidence is also what entitles the state machine to start a
+ // meeting on a single sighting.
+ if let Some(ax) = resolve_ax_browser_candidate(&browser_app, profiles, ax_candidates) {
+ let profile = &profiles[ax.profile_index];
let platform = platform_name_for_profile(profile, true);
+ // The AX window sweep resolves without a URL; borrow the URL from
+ // frame evidence when it agrees on the profile so meeting_url
+ // quality doesn't regress (e.g. Safari: AXDocument match while a
+ // fresh frame carries the real URL).
+ let meeting_url = ax
+ .meeting_url
+ .or_else(|| {
+ resolve_browser_evidence(&browser_app, profiles, evidence)
+ .filter(|(idx, _)| *idx == ax.profile_index)
+ .map(|(_, url)| url)
+ })
+ .unwrap_or_else(|| platform.clone());
if candidate_is_ignored(
&platform,
Some(profile),
@@ -124,13 +195,15 @@ pub(crate) fn resolve_process_candidate(
session_key,
first_seen_at,
process: process.clone(),
+ live_evidence: true,
};
}
- if let Some(ax) = resolve_ax_browser_candidate(&browser_app, profiles, ax_candidates) {
- let profile = &profiles[ax.profile_index];
+ if let Some((profile_index, meeting_url)) =
+ resolve_browser_evidence(&browser_app, profiles, evidence)
+ {
+ let profile = &profiles[profile_index];
let platform = platform_name_for_profile(profile, true);
- let meeting_url = ax.meeting_url.unwrap_or_else(|| platform.clone());
if candidate_is_ignored(
&platform,
Some(profile),
@@ -149,6 +222,7 @@ pub(crate) fn resolve_process_candidate(
session_key,
first_seen_at,
process: process.clone(),
+ live_evidence: false,
};
}
diff --git a/crates/screenpipe-engine/src/meeting_watcher/audio_process/state.rs b/crates/screenpipe-engine/src/meeting_watcher/audio_process/state.rs
index 7bf1f8c09..9f533906f 100644
--- a/crates/screenpipe-engine/src/meeting_watcher/audio_process/state.rs
+++ b/crates/screenpipe-engine/src/meeting_watcher/audio_process/state.rs
@@ -72,6 +72,41 @@ pub(crate) fn advance_audio_process_state(
.iter()
.find_map(ResolvedMeetingCandidate::unresolved_browser_session);
+ // Live evidence — a native app identity, the active-tab URL probe, or the
+ // AX window sweep, all observed on THIS poll — starts a meeting from any
+ // pre-start state on a single sighting. The confirm window exists so that
+ // stored frame evidence (up to 10s stale) has to prove itself across two
+ // polls; a live observation has nothing to prove by waiting, and every
+ // poll spent waiting is time a competing notes app owns the user's
+ // attention.
+ let pre_start = matches!(
+ state,
+ AudioProcessMeetingState::Idle
+ | AudioProcessMeetingState::Candidate { .. }
+ | AudioProcessMeetingState::CandidateUnresolvedBrowser { .. }
+ );
+ if pre_start && resolved.as_ref().is_some_and(|s| s.live_evidence) {
+ let session = resolved.expect("checked is_some above");
+ return (
+ AudioProcessMeetingState::Active {
+ meeting_id: -1,
+ platform: session.platform.clone(),
+ session_key: session.session_key.clone(),
+ meeting_url: session.meeting_url.clone(),
+ first_seen_at: session.first_seen_at,
+ last_seen_at: now,
+ is_browser: session.is_browser,
+ },
+ Some(AudioProcessStateAction::StartMeeting {
+ platform: session.platform,
+ session_key: session.session_key,
+ meeting_url: session.meeting_url,
+ first_seen_at: session.first_seen_at,
+ is_browser: session.is_browser,
+ }),
+ );
+ }
+
match state {
AudioProcessMeetingState::Idle => advance_from_idle(resolved, unresolved, now),
AudioProcessMeetingState::Candidate {
diff --git a/crates/screenpipe-engine/src/meeting_watcher/audio_process/tests.rs b/crates/screenpipe-engine/src/meeting_watcher/audio_process/tests.rs
index 1820609ef..f2e3c512b 100644
--- a/crates/screenpipe-engine/src/meeting_watcher/audio_process/tests.rs
+++ b/crates/screenpipe-engine/src/meeting_watcher/audio_process/tests.rs
@@ -316,6 +316,66 @@ fn ax_fallback_can_resolve_browser_platform() {
));
}
+#[test]
+fn active_tab_meet_url_resolves_candidate() {
+ // Arc exposes no AXDocument and titles its in-call window with just the
+ // meeting code ("phv-jdrc-vxw"), so the AX sweep can never attribute it.
+ // The live active-tab URL probe must resolve it directly.
+ let profiles = load_detection_profiles();
+ let candidate =
+ resolve_active_tab_url_candidate("Arc", "https://meet.google.com/abc-defg-hij", &profiles)
+ .expect("meet url should resolve to a candidate");
+ assert_eq!(candidate.browser_app, "Arc");
+ assert_eq!(
+ platform_name_for_profile(&profiles[candidate.profile_index], true),
+ "Google Meet"
+ );
+ assert_eq!(
+ candidate.meeting_url.as_deref(),
+ Some("https://meet.google.com/abc-defg-hij")
+ );
+}
+
+#[test]
+fn active_tab_join_url_with_query_params_resolves_candidate() {
+ // Green-room join URLs carry query params (?ijlm=…&adhoc=1). Matching
+ // strips them, but the stored meeting_url keeps the browser-reported form.
+ let profiles = load_detection_profiles();
+ let url = "https://meet.google.com/abc-defg-hij?ijlm=1783008102488&hs=187&adhoc=1";
+ let candidate = resolve_active_tab_url_candidate("Arc", url, &profiles)
+ .expect("join url should resolve to a candidate");
+ assert_eq!(
+ platform_name_for_profile(&profiles[candidate.profile_index], true),
+ "Google Meet"
+ );
+ assert_eq!(candidate.meeting_url.as_deref(), Some(url));
+}
+
+#[test]
+fn active_tab_unrelated_url_does_not_resolve() {
+ let profiles = load_detection_profiles();
+ assert!(resolve_active_tab_url_candidate(
+ "Arc",
+ "https://github.com/screenpipe/screenpipe/pull/4772",
+ &profiles
+ )
+ .is_none());
+ assert!(resolve_active_tab_url_candidate("Arc", "", &profiles).is_none());
+}
+
+#[test]
+fn active_tab_meeting_link_in_query_does_not_resolve() {
+ // A meeting URL carried as a query param on an unrelated page is not the
+ // page you're on (#4246): the query/fragment must be ignored for matching.
+ let profiles = load_detection_profiles();
+ assert!(resolve_active_tab_url_candidate(
+ "Arc",
+ "https://example.com/redirect?to=https://meet.google.com/abc-defg-hij",
+ &profiles
+ )
+ .is_none());
+}
+
#[test]
fn unresolved_browser_does_not_start_after_confirmation() {
let process = chrome_process();
@@ -443,6 +503,8 @@ fn sticky_process_absent_from_live_snapshot_cannot_start() {
let process = chrome_process();
let key = ProcessKey::from_process(&process).unwrap();
let start = Instant::now();
+ // live_evidence: true on purpose — even live evidence must not start a
+ // meeting for a process that is absent from the live snapshot.
let sticky_only = vec![ResolvedMeetingCandidate::Browser {
platform: "Google Meet".to_string(),
meeting_url: "https://meet.google.com/abc-defg-hij".to_string(),
@@ -450,6 +512,7 @@ fn sticky_process_absent_from_live_snapshot_cannot_start() {
session_key: key,
first_seen_at: start,
process,
+ live_evidence: true,
}];
let (state, action) = advance_audio_process_state(
@@ -466,7 +529,9 @@ fn sticky_process_absent_from_live_snapshot_cannot_start() {
}
#[test]
-fn unresolved_browser_resolution_gets_fresh_confirm_window() {
+fn stored_evidence_resolution_gets_fresh_confirm_window() {
+ // Resolution via stored frame evidence (live_evidence: false) still has to
+ // survive the confirm window, measured from the moment it resolved.
let process = chrome_process();
let key = ProcessKey::from_process(&process).unwrap();
let start = Instant::now();
@@ -492,6 +557,7 @@ fn unresolved_browser_resolution_gets_fresh_confirm_window() {
session_key: key,
first_seen_at: start,
process,
+ live_evidence: false,
};
let resolved_at = start + Duration::from_secs(10);
let (state, action) = advance_audio_process_state(
@@ -522,6 +588,124 @@ fn unresolved_browser_resolution_gets_fresh_confirm_window() {
));
}
+#[test]
+fn live_resolution_starts_meeting_on_first_sighting() {
+ // Evidence observed live on this poll (active-tab probe / AX sweep /
+ // native identity) starts the meeting immediately — no confirm window,
+ // even a generous one.
+ let process = arc_process();
+ let key = ProcessKey::from_process(&process).unwrap();
+ let start = Instant::now();
+ let resolved = ResolvedMeetingCandidate::Browser {
+ platform: "Google Meet".to_string(),
+ meeting_url: "https://meet.google.com/abc-defg-hij".to_string(),
+ browser_app: "Arc".to_string(),
+ session_key: key,
+ first_seen_at: start,
+ process,
+ live_evidence: true,
+ };
+ let (state, action) = advance_audio_process_state(
+ AudioProcessMeetingState::Idle,
+ std::slice::from_ref(&resolved),
+ std::slice::from_ref(&resolved),
+ start,
+ Duration::from_secs(30),
+ Duration::from_secs(20),
+ );
+ assert!(matches!(state, AudioProcessMeetingState::Active { .. }));
+ assert!(matches!(
+ action,
+ Some(AudioProcessStateAction::StartMeeting { platform, .. }) if platform == "Google Meet"
+ ));
+}
+
+#[test]
+fn live_resolution_starts_immediately_from_unresolved_browser() {
+ // An unresolved browser that resolves via live evidence does not wait out
+ // a fresh confirm window — that wait exists for stored evidence only.
+ let process = arc_process();
+ let key = ProcessKey::from_process(&process).unwrap();
+ let start = Instant::now();
+ let state = AudioProcessMeetingState::CandidateUnresolvedBrowser {
+ browser_app: "Arc".to_string(),
+ session_key: key.clone(),
+ first_seen_at: start,
+ last_resolution_attempt: start,
+ };
+ let resolved = ResolvedMeetingCandidate::Browser {
+ platform: "Google Meet".to_string(),
+ meeting_url: "https://meet.google.com/abc-defg-hij".to_string(),
+ browser_app: "Arc".to_string(),
+ session_key: key,
+ first_seen_at: start,
+ process,
+ live_evidence: true,
+ };
+ let (state, action) = advance_audio_process_state(
+ state,
+ std::slice::from_ref(&resolved),
+ std::slice::from_ref(&resolved),
+ start + Duration::from_secs(5),
+ Duration::from_secs(3),
+ Duration::from_secs(20),
+ );
+ assert!(matches!(state, AudioProcessMeetingState::Active { .. }));
+ assert!(action.is_some());
+}
+
+#[test]
+fn live_ax_candidate_outranks_stored_frame_evidence() {
+ // A live observation wins over stored frame evidence (which can be up to
+ // 10s stale), and an urlless AX-sweep candidate borrows the stored URL
+ // when both agree on the profile.
+ let profiles = load_detection_profiles();
+ let process = arc_process();
+ let meet_profile = profiles
+ .iter()
+ .position(|p| {
+ p.app_identifiers
+ .browser_url_patterns
+ .contains(&"meet.google.com")
+ })
+ .unwrap();
+ let evidence = vec![BrowserPageEvidence {
+ browser_app: Some("Arc".to_string()),
+ url: Some("https://meet.google.com/abc-defg-hij".to_string()),
+ title: Some("abc-defg-hij".to_string()),
+ }];
+ let ax = vec![AxResolvedCandidate {
+ browser_app: "Arc".to_string(),
+ profile_index: meet_profile,
+ meeting_url: None,
+ }];
+ let candidate = resolve_process_candidate(
+ ProcessKey::from_process(&process).unwrap(),
+ Instant::now(),
+ &process,
+ &profiles,
+ &evidence,
+ &ax,
+ &[],
+ );
+ match candidate {
+ ResolvedMeetingCandidate::Browser {
+ platform,
+ meeting_url,
+ live_evidence,
+ ..
+ } => {
+ assert_eq!(platform, "Google Meet");
+ assert!(live_evidence, "ax-resolved candidate must be live");
+ assert_eq!(
+ meeting_url, "https://meet.google.com/abc-defg-hij",
+ "urlless AX candidate should borrow the stored URL for the same profile"
+ );
+ }
+ other => panic!("expected Browser candidate, got {other:?}"),
+ }
+}
+
#[test]
fn browser_meeting_ends_only_after_audio_session_disappears() {
// Corrected behavior (previously `unresolved_browser_does_not_keep_active_meeting_alive`,
@@ -640,6 +824,7 @@ fn auto_end_suppresses_same_session_restart_until_audio_session_disappears() {
session_key: key.clone(),
first_seen_at: start + Duration::from_secs(22),
process: process.clone(),
+ live_evidence: true,
}];
filter_suppressed_candidates(&mut candidates, &suppressed);
assert!(
@@ -672,6 +857,7 @@ fn explicit_stop_suppresses_current_session_until_process_disappears() {
session_key: key.clone(),
first_seen_at: start,
process: process.clone(),
+ live_evidence: true,
}];
filter_suppressed_candidates(&mut candidates, &suppressed);
@@ -708,6 +894,7 @@ fn explicit_stop_does_not_suppress_new_browser_meeting_url() {
session_key: key,
first_seen_at: start,
process,
+ live_evidence: true,
}];
filter_suppressed_candidates(&mut candidates, &suppressed);
@@ -739,6 +926,7 @@ fn explicit_stop_does_not_suppress_new_audio_session_same_browser_pid() {
session_key: new_key,
first_seen_at: start,
process: new_process,
+ live_evidence: true,
}];
filter_suppressed_candidates(&mut candidates, &suppressed);
diff --git a/crates/screenpipe-engine/src/meeting_watcher/audio_process/windows.rs b/crates/screenpipe-engine/src/meeting_watcher/audio_process/windows.rs
index f6c07c6ae..d2b770062 100644
--- a/crates/screenpipe-engine/src/meeting_watcher/audio_process/windows.rs
+++ b/crates/screenpipe-engine/src/meeting_watcher/audio_process/windows.rs
@@ -8,6 +8,18 @@ use super::*;
use crate::meeting_watcher::shared::ignore::{is_browser_app, meeting_app_is_ignored_with_terms};
use crate::meeting_watcher::shared::profiles::MeetingDetectionProfile;
+/// Windows: no live active-tab URL probe yet. The UIA sweep in
+/// `ax_resolved_candidates` reads browser window titles/URLs already; wiring
+/// `browser_utils`' UIA URL detector here is possible but unverified, so keep
+/// this a no-op until it's tested on a real Windows browser matrix.
+pub(crate) async fn active_tab_url_candidates(
+ _browser_apps: &[String],
+ _profiles: &[MeetingDetectionProfile],
+ _ignored_terms: &[String],
+) -> Vec<AxResolvedCandidate> {
+ Vec::new()
+}
+
pub(crate) async fn ax_resolved_candidates(
profiles: &[MeetingDetectionProfile],
ignored_terms: &[String],