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
Rust agentsagiaiai-memoryaudio-recordingcomputer-visionhermeshermes-agentllmlocal-ailocal-firstmachine-learningmcpmultimodalopenclawprivacyrewindscreen-recordingspeech-to-textycombinator
fix(meeting-notes): block phantom meetings from WhatsApp/Telegram voice notes (#4776)
thisisharsh739eb5179b5ea
diff --git a/crates/screenpipe-engine/src/meeting_watcher/audio_process/model.rs b/crates/screenpipe-engine/src/meeting_watcher/audio_process/model.rsindex 4d9880557..2c4d9ad00 100644--- a/crates/screenpipe-engine/src/meeting_watcher/audio_process/model.rs+++ b/crates/screenpipe-engine/src/meeting_watcher/audio_process/model.rs@@ -215,6 +215,22 @@ pub(crate) struct ResolvedSession {pub(crate) live_evidence: bool,}+/// Result of scanning a messaging app's AX tree for call UI evidence.+///+/// When a native platform has `requires_call_signal: true`, the audio-process+/// detector runs this scan before promoting the candidate to `Native`. If+/// `is_in_call` is false the candidate is downgraded to `NonMeeting`,+/// blocking phantom meetings from voice notes (#4776).+#[derive(Debug, Clone, PartialEq, Eq)]+pub(crate) struct CallSignalEvidence {+ /// Lowercased platform name (e.g. "whatsapp", "signal", "telegram").+ pub platform: String,+ /// Whether the AX scan found call signals confirming a real call.+ pub is_in_call: bool,+ /// Human-readable descriptions of which signals matched (for debug logging).+ pub matched_signals: Vec<String>,+}+#[derive(Debug, Clone, PartialEq, Eq)]pub(crate) struct SuppressedSession {pub(crate) session_key: ProcessKey,diff --git a/crates/screenpipe-engine/src/meeting_watcher/audio_process/resolve.rs b/crates/screenpipe-engine/src/meeting_watcher/audio_process/resolve.rsindex 7a5b02503..12c902792 100644--- a/crates/screenpipe-engine/src/meeting_watcher/audio_process/resolve.rs+++ b/crates/screenpipe-engine/src/meeting_watcher/audio_process/resolve.rs@@ -339,7 +339,19 @@ pub(crate) fn process_identity_fields(process: &AudioInputProcess) -> Vec<String].into_iter().flatten()- .map(|s| s.trim().to_lowercase())+ .map(|s| {+ // macOS NSRunningApp.localized_name() can prepend invisible Unicode+ // formatting characters (e.g. U+200E LEFT-TO-RIGHT MARK on WhatsApp:+ // "\u{200e}WhatsApp"). Strip them so profile name matching works.+ s.chars()+ .filter(|c| {+ !c.is_control()+ && !matches!(c, '\u{200e}' | '\u{200f}' | '\u{200b}' | '\u{feff}')+ })+ .collect::<String>()+ .trim()+ .to_lowercase()+ }).filter(|s| !s.is_empty()).collect()}@@ -379,15 +391,9 @@ pub(crate) fn known_native_bundle_platform(field_lower: &str) -> Option<&'staticif field_lower.contains("discord") {return Some("Discord");}- if field_lower.contains("signal") {- return Some("Signal");- }- if field_lower.contains("whatsapp") {- return Some("WhatsApp");- }- if field_lower.contains("telegram") {- return Some("Telegram");- }+ // Signal, WhatsApp, and Telegram are intentionally NOT matched here.+ // They must fall through to the profile-matching loop below so they get+ // a profile index, which is needed to check `requires_call_signal` (#4776).if field_lower.contains("skype") {return Some("Skype");}@@ -599,6 +605,80 @@ pub(crate) fn acquire_input_processes()}+/// Scan messaging apps (those with `requires_call_signal: true`) for call UI+/// evidence in the AX tree. Returns a `CallSignalEvidence` per scanned app.+///+/// Only called during pre-active states (`needs_ax_resolution`) and only for+/// `Native` candidates whose profile requires call signal verification.+/// Platform-agnostic: delegates to `MeetingUiScanner::scan_process` which+/// uses AX on macOS, UIA on Windows, and is a no-op on other platforms.+#[cfg(any(target_os = "macos", target_os = "windows"))]+async fn scan_messaging_call_signals(+ candidates: &[ResolvedMeetingCandidate],+ profiles: &[MeetingDetectionProfile],+) -> Vec<CallSignalEvidence> {+ let to_scan: Vec<(String, i32, usize)> = candidates+ .iter()+ .filter_map(|c| {+ if let ResolvedMeetingCandidate::Native {+ platform, process, ..+ } = c+ {+ let profile_idx = profiles+ .iter()+ .position(|p| platform_name_for_profile(p, false) == *platform)?;+ let profile = &profiles[profile_idx];+ if profile.requires_call_signal {+ Some((platform.clone(), process.pid?, profile_idx))+ } else {+ None+ }+ } else {+ None+ }+ })+ .collect();++ if to_scan.is_empty() {+ return Vec::new();+ }++ let profiles = profiles.to_vec();+ let scan = tokio::task::spawn_blocking(move || {+ let scanner = crate::meeting_watcher::shared::scanner::MeetingUiScanner::new();+ to_scan+ .into_iter()+ .map(|(platform, pid, profile_idx)| {+ let profile = &profiles[profile_idx];+ let result = scanner.scan_process(pid, profile);+ debug!(+ "audio-process meeting detector: call signal scan for {} (pid {}): \+ is_in_call={}, signals={:?}",+ platform, pid, result.is_in_call, result.matched_signals+ );+ CallSignalEvidence {+ platform: platform.to_lowercase(),+ is_in_call: result.is_in_call,+ matched_signals: result.matched_signals,+ }+ })+ .collect()+ });+ match tokio::time::timeout(Duration::from_secs(5), scan).await {+ Ok(Ok(results)) => results,+ _ => Vec::new(),+ }+}++/// Stub: no call signal scanning on unsupported platforms.+#[cfg(not(any(target_os = "macos", target_os = "windows")))]+async fn scan_messaging_call_signals(+ _candidates: &[ResolvedMeetingCandidate],+ _profiles: &[MeetingDetectionProfile],+) -> Vec<CallSignalEvidence> {+ Vec::new()+}+/// Run the full candidate pipeline for one snapshot: sticky tracking, optional/// AX fallback, profile/URL resolution, then ignore/suppression filtering./// Returns `(candidates, live_candidates)`.@@ -630,6 +710,58 @@ pub(crate) async fn build_candidates(resolve_tracked_candidates(db, profiles, ignored_terms, &tracked, ax_candidates).await;candidates.retain(|candidate| !matches!(candidate, ResolvedMeetingCandidate::Ignored));++ // Call signal gate for messaging-first platforms (#4776): apps like+ // WhatsApp/Signal/Telegram grab the mic for voice notes identically to+ // calls. Before promoting them to Native, scan their AX tree for real+ // call UI (e.g. Calling_Window). Only run during pre-active states —+ // once a meeting is Active the platform is settled.+ if needs_ax_resolution(state) {+ let call_evidence =+ scan_messaging_call_signals(&candidates, profiles).await;+ candidates.retain(|candidate| {+ if let ResolvedMeetingCandidate::Native { platform, .. } = candidate {+ let platform_lower = platform.to_lowercase();+ // Check if this platform requires call signal verification.+ let requires_gate = profiles.iter().any(|p| {+ p.requires_call_signal+ && platform_name_for_profile(p, false).to_lowercase() == platform_lower+ });+ if requires_gate {+ // Fail-closed: block unless we have explicit evidence of a+ // real call. If the AX scan timed out or the process had no+ // PID, no evidence is produced and we err on the side of NOT+ // starting a phantom meeting.+ match call_evidence+ .iter()+ .find(|e| e.platform == platform_lower)+ {+ Some(evidence) if evidence.is_in_call => {+ // Real call confirmed — allow.+ }+ Some(_) => {+ debug!(+ "audio-process meeting detector: {} blocked by call signal gate \+ (voice note / idle, no call UI found)",+ platform+ );+ return false;+ }+ None => {+ debug!(+ "audio-process meeting detector: {} blocked by call signal gate \+ (no evidence produced — scan may have timed out)",+ platform+ );+ return false;+ }+ }+ }+ }+ true+ });+ }+filter_suppressed_candidates(&mut candidates, suppressed_sessions);let live_candidates: Vec<_> = candidates.iter()diff --git a/crates/screenpipe-engine/src/meeting_watcher/audio_process/tests.rs b/crates/screenpipe-engine/src/meeting_watcher/audio_process/tests.rsindex f2e3c512b..483c24fdf 100644--- a/crates/screenpipe-engine/src/meeting_watcher/audio_process/tests.rs+++ b/crates/screenpipe-engine/src/meeting_watcher/audio_process/tests.rs@@ -1068,3 +1068,286 @@ fn ax_resolution_only_runs_before_a_meeting_is_active() {is_browser: true,}));}++// ---------------------------------------------------------------------------+// Call signal gate tests (#4776) — WhatsApp/Signal/Telegram voice note phantom+// meeting prevention.+// ---------------------------------------------------------------------------++fn whatsapp_process() -> AudioInputProcess {+ AudioInputProcess {+ audio_session_id: Some("coreaudio-process:500:input:built-in-mic".to_string()),+ audio_object_id: Some(500),+ pid: Some(99),+ bundle_id: Some("net.whatsapp.WhatsApp".to_string()),+ // macOS prepends U+200E LEFT-TO-RIGHT MARK to WhatsApp's localized name.+ process_name: Some("\u{200e}WhatsApp".to_string()),+ owner_app_name: Some("\u{200e}WhatsApp".to_string()),+ owner_bundle_id: Some("net.whatsapp.WhatsApp".to_string()),+ first_seen_at_ms: None,+ }+}++fn signal_process() -> AudioInputProcess {+ AudioInputProcess {+ audio_session_id: Some("coreaudio-process:600:input:built-in-mic".to_string()),+ audio_object_id: Some(600),+ pid: Some(101),+ bundle_id: Some("org.whispersystems.signal-desktop".to_string()),+ process_name: Some("Signal".to_string()),+ owner_app_name: Some("Signal".to_string()),+ owner_bundle_id: Some("org.whispersystems.signal-desktop".to_string()),+ first_seen_at_ms: None,+ }+}++fn telegram_process() -> AudioInputProcess {+ AudioInputProcess {+ audio_session_id: Some("coreaudio-process:700:input:built-in-mic".to_string()),+ audio_object_id: Some(700),+ pid: Some(102),+ bundle_id: Some("ru.keepcoder.Telegram".to_string()),+ process_name: Some("Telegram".to_string()),+ owner_app_name: Some("Telegram".to_string()),+ owner_bundle_id: Some("ru.keepcoder.Telegram".to_string()),+ first_seen_at_ms: None,+ }+}++#[test]+fn unicode_ltr_mark_stripped_from_whatsapp_identity() {+ // macOS returns "\u{200e}WhatsApp" — verify process_identity_fields strips it.+ let process = whatsapp_process();+ let fields = process_identity_fields(&process);+ assert!(+ fields.iter().any(|f| f == "whatsapp"),+ "Unicode LTR mark should be stripped: {fields:?}"+ );+ assert!(+ !fields.iter().any(|f| f.contains('\u{200e}')),+ "No identity field should contain U+200E: {fields:?}"+ );+}++#[test]+fn whatsapp_resolves_to_native_with_profile_index() {+ // WhatsApp must fall through `known_native_bundle_platform` and match via+ // the profile loop, which returns a profile index. Without the index,+ // `requires_call_signal` can never be consulted.+ let profiles = load_detection_profiles();+ let process = whatsapp_process();+ let result = resolve_native_platform(&process, &profiles);+ assert!(result.is_some(), "WhatsApp should resolve as native");+ let (platform, profile_index) = result.unwrap();+ assert_eq!(platform, "WhatsApp");+ assert!(+ profile_index.is_some(),+ "WhatsApp must have a profile index for call signal gating"+ );+ let profile = &profiles[profile_index.unwrap()];+ assert!(+ profile.requires_call_signal,+ "WhatsApp profile must have requires_call_signal = true"+ );+}++#[test]+fn signal_resolves_to_native_with_profile_index() {+ let profiles = load_detection_profiles();+ let process = signal_process();+ let result = resolve_native_platform(&process, &profiles);+ assert!(result.is_some(), "Signal should resolve as native");+ let (platform, profile_index) = result.unwrap();+ assert_eq!(platform, "Signal");+ assert!(+ profile_index.is_some(),+ "Signal must have a profile index for call signal gating"+ );+ // Signal's Electron AX tree is opaque (buttons show title="-"), so+ // requires_call_signal is false until Signal exposes call UI.+ let profile = &profiles[profile_index.unwrap()];+ assert!(+ !profile.requires_call_signal,+ "Signal profile must have requires_call_signal = false (opaque AX tree)"+ );+}++#[test]+fn telegram_resolves_to_native_with_profile_index() {+ let profiles = load_detection_profiles();+ let process = telegram_process();+ let result = resolve_native_platform(&process, &profiles);+ assert!(result.is_some(), "Telegram should resolve as native");+ let (platform, profile_index) = result.unwrap();+ assert_eq!(platform, "Telegram");+ assert!(+ profile_index.is_some(),+ "Telegram must have a profile index for call signal gating"+ );+ let profile = &profiles[profile_index.unwrap()];+ assert!(+ profile.requires_call_signal,+ "Telegram profile must have requires_call_signal = true"+ );+}++#[test]+fn zoom_unaffected_by_call_signal_gate() {+ // Call-first apps must NOT have requires_call_signal. This is a regression+ // guard: if Zoom is accidentally flagged, every Zoom call would need AX+ // evidence before starting.+ let profiles = load_detection_profiles();+ let process = zoom_process();+ let result = resolve_native_platform(&process, &profiles);+ assert!(result.is_some());+ let (platform, _) = result.unwrap();+ assert_eq!(platform, "Zoom");+ // Zoom resolves via known_native_bundle_platform (no profile index), which+ // is fine — it should never be gated.+}++#[test]+fn teams_unaffected_by_call_signal_gate() {+ let profiles = load_detection_profiles();+ let teams = AudioInputProcess {+ audio_session_id: Some("coreaudio-process:800:input:built-in-mic".to_string()),+ audio_object_id: Some(800),+ pid: Some(103),+ bundle_id: Some("com.microsoft.teams2".to_string()),+ process_name: Some("Microsoft Teams".to_string()),+ owner_app_name: Some("Microsoft Teams".to_string()),+ owner_bundle_id: Some("com.microsoft.teams2".to_string()),+ first_seen_at_ms: None,+ };+ let result = resolve_native_platform(&teams, &profiles);+ assert!(result.is_some());+ let (platform, _) = result.unwrap();+ assert_eq!(platform, "Microsoft Teams");+}++#[test]+fn whatsapp_without_call_signal_blocked_by_gate() {+ // Voice note scenario: WhatsApp holds the mic but no Calling_Window is+ // present. The candidate resolves to Native{WhatsApp} but the call signal+ // gate should block it.+ let profiles = load_detection_profiles();+ let process = whatsapp_process();+ let candidate = resolve_process_candidate(+ ProcessKey::from_process(&process).unwrap(),+ Instant::now(),+ &process,+ &profiles,+ &[],+ &[],+ &[],+ );+ // Without the gate (which runs in build_candidates), resolution succeeds.+ assert!(+ matches!(+ candidate,+ ResolvedMeetingCandidate::Native { ref platform, .. } if platform == "WhatsApp"+ ),+ "WhatsApp should resolve to Native before the gate: {candidate:?}"+ );++ // Simulate what build_candidates does: check call_evidence with no call signals.+ let call_evidence = vec![CallSignalEvidence {+ platform: "whatsapp".to_string(),+ is_in_call: false,+ matched_signals: vec![],+ }];+ let mut candidates = vec![candidate];+ candidates.retain(|c| {+ if let ResolvedMeetingCandidate::Native { platform, .. } = c {+ let platform_lower = platform.to_lowercase();+ if let Some(evidence) = call_evidence.iter().find(|e| e.platform == platform_lower) {+ return evidence.is_in_call;+ }+ }+ true+ });+ assert!(+ candidates.is_empty(),+ "WhatsApp without call signals should be blocked"+ );+}++#[test]+fn whatsapp_with_call_signal_passes_gate() {+ // Real call scenario: WhatsApp holds the mic AND Calling_Window is present.+ let profiles = load_detection_profiles();+ let process = whatsapp_process();+ let candidate = resolve_process_candidate(+ ProcessKey::from_process(&process).unwrap(),+ Instant::now(),+ &process,+ &profiles,+ &[],+ &[],+ &[],+ );+ assert!(matches!(+ candidate,+ ResolvedMeetingCandidate::Native { ref platform, .. } if platform == "WhatsApp"+ ));++ let call_evidence = vec![CallSignalEvidence {+ platform: "whatsapp".to_string(),+ is_in_call: true,+ matched_signals: vec!["AutomationIdContains(Calling_Window)".to_string()],+ }];+ let mut candidates = vec![candidate];+ candidates.retain(|c| {+ if let ResolvedMeetingCandidate::Native { platform, .. } = c {+ let platform_lower = platform.to_lowercase();+ if let Some(evidence) = call_evidence.iter().find(|e| e.platform == platform_lower) {+ return evidence.is_in_call;+ }+ }+ true+ });+ assert_eq!(+ candidates.len(),+ 1,+ "WhatsApp with call signal should pass the gate"+ );+}++#[test]+fn zoom_not_filtered_by_call_signal_gate() {+ // Zoom should never appear in call_evidence (requires_call_signal = false),+ // so it must pass through the retain filter untouched.+ let profiles = load_detection_profiles();+ let process = zoom_process();+ let candidate = resolve_process_candidate(+ ProcessKey::from_process(&process).unwrap(),+ Instant::now(),+ &process,+ &profiles,+ &[],+ &[],+ &[],+ );+ assert!(matches!(+ candidate,+ ResolvedMeetingCandidate::Native { ref platform, .. } if platform == "Zoom"+ ));++ // No call_evidence for Zoom (scan_messaging_call_signals skips it).+ let call_evidence: Vec<CallSignalEvidence> = vec![];+ let mut candidates = vec![candidate];+ candidates.retain(|c| {+ if let ResolvedMeetingCandidate::Native { platform, .. } = c {+ let platform_lower = platform.to_lowercase();+ if let Some(evidence) = call_evidence.iter().find(|e| e.platform == platform_lower) {+ return evidence.is_in_call;+ }+ }+ true+ });+ assert_eq!(+ candidates.len(),+ 1,+ "Zoom must not be affected by call signal gate"+ );+}diff --git a/crates/screenpipe-engine/src/meeting_watcher/shared/profiles.rs b/crates/screenpipe-engine/src/meeting_watcher/shared/profiles.rsindex 5e3f6d977..4228a23e4 100644--- a/crates/screenpipe-engine/src/meeting_watcher/shared/profiles.rs+++ b/crates/screenpipe-engine/src/meeting_watcher/shared/profiles.rs@@ -81,6 +81,13 @@ pub struct MeetingDetectionProfile {/// messaging chrome (e.g. "Leave space"/"Leave team") trips the bare `leave`/// signal and starts a phantom meeting. See issue #4145.pub ignore_window_titles: &'static [&'static str],+ /// When true, the audio-process detector must find call UI evidence in the+ /// AX tree before starting a meeting — mic-hold + app identity alone is not+ /// enough. This gates messaging-first platforms (WhatsApp, Signal, Telegram)+ /// where a voice note holds the mic exactly like a call, causing phantom+ /// meetings (#4776). Call-first platforms (Zoom, Meet, Teams, etc.) set this+ /// to false and are completely unaffected.+ pub requires_call_signal: bool,}/// Known browser app names (lowercase).@@ -138,6 +145,7 @@ pub fn load_detection_profiles() -> Vec<MeetingDetectionProfile> {],min_signals_required: 1,ignore_window_titles: &[],+ requires_call_signal: false,},// Zoom Desktop// Note: Zoom on macOS does NOT expose AXWindow — only AXMenuBar.@@ -211,6 +219,7 @@ pub fn load_detection_profiles() -> Vec<MeetingDetectionProfile> {],min_signals_required: 1,ignore_window_titles: &[],+ requires_call_signal: false,},// Google Meet (browser)// NOTE: "google meet" removed from url_patterns — it's too broad and matches@@ -240,6 +249,7 @@ pub fn load_detection_profiles() -> Vec<MeetingDetectionProfile> {],min_signals_required: 1,ignore_window_titles: &[],+ requires_call_signal: false,},// Slack Huddle (browser + desktop)MeetingDetectionProfile {@@ -261,6 +271,7 @@ pub fn load_detection_profiles() -> Vec<MeetingDetectionProfile> {],min_signals_required: 1,ignore_window_titles: &[],+ requires_call_signal: false,},// FaceTimeMeetingDetectionProfile {@@ -282,6 +293,7 @@ pub fn load_detection_profiles() -> Vec<MeetingDetectionProfile> {],min_signals_required: 1,ignore_window_titles: &[],+ requires_call_signal: false,},// WebexMeetingDetectionProfile {@@ -322,6 +334,7 @@ pub fn load_detection_profiles() -> Vec<MeetingDetectionProfile> {// title, so a window-title guard could never catch it. Kept because a// window titled exactly `Webex` is unambiguously the messaging shell.ignore_window_titles: &["webex"],+ requires_call_signal: false,},// Discord in browser — require BOTH "Voice Connected" bar AND "Disconnect"// button. Either alone can appear without being in a call (e.g. seeing other@@ -342,11 +355,13 @@ pub fn load_detection_profiles() -> Vec<MeetingDetectionProfile> {],min_signals_required: 2,ignore_window_titles: &[],+ requires_call_signal: false,},// Signal — voice/video calls- // macOS: "Signal" app with "End Call" / "Hang Up" button during active calls.- // Windows: "Signal.exe" Electron app, same button patterns.- // Signal also shows a call status bar with duration when a call is active.+ // macOS: Signal is an Electron app whose AX tree is opaque — buttons+ // show title="-" with no useful text, so we cannot distinguish calls+ // from voice notes via AX scanning. requires_call_signal is false+ // until Signal exposes call UI in its accessibility tree (#4776).MeetingDetectionProfile {app_identifiers: AppIdentifiers {macos_app_names: &["signal"],@@ -377,8 +392,25 @@ pub fn load_detection_profiles() -> Vec<MeetingDetectionProfile> {],min_signals_required: 1,ignore_window_titles: &[],+ requires_call_signal: false,},// WhatsApp — voice/video calls+ // requires_call_signal: true — WhatsApp grabs the mic for voice notes+ // just like a call; without this gate, every voice note starts a phantom+ // meeting (#4776).+ //+ // Signal selection rationale (from live AX tree investigation):+ // - NameContains("End call") is UNUSABLE: WhatsApp has a permanent+ // "End Call" AXMenuItem in its menu bar at ALL times (idle, voice+ // note, and call). It cannot discriminate.+ // - RoleWithName { AXButton, "end call" } NEVER MATCHES: WhatsApp+ // exposes no AXButton for call controls on macOS.+ // - AutomationIdContains("Calling_Window") is the PRIMARY signal:+ // during a real call WhatsApp opens a second AXWindow containing an+ // AXGroup with id="Calling_Window". This is locale-independent and+ // only present during active calls (voice or video).+ // - RoleWithName { AXButton, "leave call" } is the SECONDARY signal:+ // an AXButton with desc="leave call" inside the Calling_Window.MeetingDetectionProfile {app_identifiers: AppIdentifiers {macos_app_names: &["whatsapp"],@@ -387,24 +419,32 @@ pub fn load_detection_profiles() -> Vec<MeetingDetectionProfile> {browser_title_patterns: &[],},call_signals: vec![+ // macOS: locale-independent AXGroup id, only present during+ // active voice/video calls (never during voice notes or idle).+ CallSignal::AutomationIdContains("Calling_Window"),+ // macOS: AXButton inside the call window.CallSignal::RoleWithName {role: "AXButton",- name_contains: "end call",+ name_contains: "leave call",},+ // Windows UIA button patternsCallSignal::RoleWithName {- role: "AXButton",- name_contains: "hang up",+ role: "Button",+ name_contains: "End call",},- CallSignal::NameContains("End call"),CallSignal::RoleWithName {role: "Button",- name_contains: "End call",+ name_contains: "Hang up",},],min_signals_required: 1,ignore_window_titles: &[],+ requires_call_signal: true,},// Telegram — voice/video calls+ // requires_call_signal: true — Telegram grabs the mic for voice notes+ // just like a call; without this gate, every voice note starts a phantom+ // meeting (#4776).MeetingDetectionProfile {app_identifiers: AppIdentifiers {macos_app_names: &["telegram"],@@ -430,6 +470,7 @@ pub fn load_detection_profiles() -> Vec<MeetingDetectionProfile> {],min_signals_required: 1,ignore_window_titles: &[],+ requires_call_signal: true,},// Generic fallback — catches apps like Skype, Around, Whereby, etc.MeetingDetectionProfile {@@ -532,6 +573,7 @@ pub fn load_detection_profiles() -> Vec<MeetingDetectionProfile> {],min_signals_required: 1,ignore_window_titles: &[],+ requires_call_signal: false,},];profiles.extend(crate::meeting_watcher::ui_scan::discord_profile());diff --git a/crates/screenpipe-engine/src/meeting_watcher/ui_scan/macos.rs b/crates/screenpipe-engine/src/meeting_watcher/ui_scan/macos.rsindex 2ceebedc1..8c3b1f91d 100644--- a/crates/screenpipe-engine/src/meeting_watcher/ui_scan/macos.rs+++ b/crates/screenpipe-engine/src/meeting_watcher/ui_scan/macos.rs@@ -555,6 +555,7 @@ pub(crate) fn discord_profile() -> Option<MeetingDetectionProfile> {],min_signals_required: 2,ignore_window_titles: &[],+ requires_call_signal: false,})}diff --git a/crates/screenpipe-engine/src/meeting_watcher/ui_scan/tests.rs b/crates/screenpipe-engine/src/meeting_watcher/ui_scan/tests.rsindex 87f79fb7a..5bd2ba8cb 100644--- a/crates/screenpipe-engine/src/meeting_watcher/ui_scan/tests.rs+++ b/crates/screenpipe-engine/src/meeting_watcher/ui_scan/tests.rs@@ -76,6 +76,7 @@ fn zoom_test_profile() -> MeetingDetectionProfile {call_signals: vec![],min_signals_required: 1,ignore_window_titles: &[],+ requires_call_signal: false,}}diff --git a/crates/screenpipe-engine/src/meeting_watcher/ui_scan/windows.rs b/crates/screenpipe-engine/src/meeting_watcher/ui_scan/windows.rsindex 9367988f2..a09708c33 100644--- a/crates/screenpipe-engine/src/meeting_watcher/ui_scan/windows.rs+++ b/crates/screenpipe-engine/src/meeting_watcher/ui_scan/windows.rs@@ -705,6 +705,7 @@ pub(crate) fn discord_profile() -> Option<MeetingDetectionProfile> {],min_signals_required: 1,ignore_window_titles: &[],+ requires_call_signal: false,})}