ProactiveAssistantsPlugin.swift

import Cocoa
import UserNotifications

/// Service that manages proactive assistants - screen monitoring, frame capture, and assistant coordination
@MainActor
public class ProactiveAssistantsPlugin: NSObject {

    // MARK: - Singleton

    /// Shared instance
    public static let shared = ProactiveAssistantsPlugin()

    // MARK: - Properties

    private var screenCaptureService: ScreenCaptureService?
    private var windowMonitor: WindowMonitor?
    private var focusAssistant: FocusAssistant?

    /// Public read-only accessor for memory diagnostics
    var currentFocusAssistant: FocusAssistant? { focusAssistant }
    private var taskAssistant: TaskAssistant?
    private var insightAssistant: InsightAssistant?
    private var memoryAssistant: MemoryAssistant?
    private var captureTimer: Timer?
    private var analysisDelayTimer: Timer?
    private var isInDelayPeriod = false

    private(set) var isMonitoring = false
    private var isStartingMonitoring = false  // Prevents race condition with async startMonitoring
    private var _hasScreenRecordingPermission: Bool?  // Cached permission state
    private var currentApp: String?
    private var currentWindowID: CGWindowID?
    private var currentWindowTitle: String?
    private var lastStatus: FocusStatus?
    private var frameCount = 0

    // Backpressure: prevents unbounded CGImage accumulation (~24MB each) when video
    // encoding is slower than the capture rate — the primary cause of multi-GB memory growth.
    private(set) var isProcessingRewindFrame = false
    private(set) var droppedFrameCount = 0

    /// Periodic screen recording permission recheck interval (60 seconds).
    /// Detects permission revocation while monitoring is active (issue #5792).
    private var lastPermissionCheckTime: Date = .distantPast
    private let permissionCheckInterval: TimeInterval = 60

    // Failure tracking for screen capture recovery
    private var consecutiveFailures = 0
    private let maxConsecutiveFailures = 5
    private var lastCaptureSucceeded = true
    private var wasMonitoringBeforeSleep = false
    private var wasMonitoringBeforeLock = false
    private var systemEventObservers: [NSObjectProtocol] = []

    // Video call throttling: reduce capture frequency when a call app is frontmost
    // to avoid competing with the call app for CPU/GPU (ScreenCaptureKit, encoding, OCR).
    private var videoCallFrameCounter = 0
    private let videoCallThrottleFactor = 5  // Capture 1 out of every 5 frames (effective ~5s interval)

    // Screenshot-app yielding: pause capture entirely while another screenshot/recording
    // app is frontmost, and hold a short backoff after it resigns so its editor UI isn't
    // disturbed. Prevents Omi's 3s capture loop from locking WindowServer at the moment
    // the user is trying to take a screenshot (CleanShot, Shottr, macOS screenshot, etc.).
    private var wasScreenshotAppFrontmost = false
    private var screenshotAppBackoffUntil: Date = .distantPast

    // Change-gated distribution: only distribute frames to assistants when context changes.
    // Eliminates continuous polling when the user stays on the same app/window.
    private var lastDistributedApp: String?
    private var lastDistributedWindowTitle: String?
    private var distributionDebounceTimer: Timer?
    private var latestCapturedFrame: CapturedFrame?
    private var lastDistributionTime: Date = .distantPast
    /// Fallback interval: re-distribute even without context change to catch visual-only updates.
    private let distributionFallbackInterval: TimeInterval = 60

    /// Apps whose primary purpose is video/audio calls.
    private static let videoCallApps: Set<String> = [
        "Microsoft Teams",
        "zoom.us",
        "FaceTime",
        "Webex",
        "Cisco Webex Meetings",
        "GoTo Meeting",
        "GoToMeeting",
    ]

    /// Bundle IDs of third-party and system screenshot/screen-recording apps.
    /// When one of these is frontmost, Omi's 3s capture loop contends with the
    /// user's active capture (WindowServer locks + SCK arbitration), which can
    /// freeze the other app's capture UI for 20-60 seconds. We pause Omi's
    /// capture entirely while any of these is frontmost.
    private static let screenshotAppBundleIDs: Set<String> = [
        "pl.maketheweb.cleanshotx",          // CleanShot X
        "cc.ffitch.shottr",                  // Shottr
        "com.apple.screencaptureui",         // macOS screenshot.app overlay
        "com.apple.screenshot.launcher",     // macOS screenshot hotkey launcher
        "com.loom.desktop-app",              // Loom
        "com.loom.desktop",                  // Loom (alt)
        "com.techsmith.snagit2025",          // Snagit (current)
        "com.techsmith.snagit2024",          // Snagit (prior)
        "com.techsmith.snagit2023",          // Snagit (older)
        "com.obsproject.obs-studio",         // OBS Studio
        "com.screenium.Screenium3",          // Screenium
        "com.kapeli.screenium",              // Screenium (alt)
        "com.skitch.skitch",                 // Skitch
        "com.evernote.skitch",               // Skitch (alt)
        "com.monosnap.monosnap",             // Monosnap
        "com.lightshot.app",                 // Lightshot
        "com.capto.Capto",                   // Capto
        "com.pixelmatorteam.screenshot",     // Pixelmator screenshot
        "com.tencent.xin.lemon",             // WeCom screenshot
    ]

    /// Keywords in browser window titles that indicate a video call.
    private static let videoCallBrowserKeywords: [String] = [
        "Google Meet",
        "meet.google.com",
        "Teams - Microsoft",  // Teams web app
    ]

    /// Browser app names (for window-title-based call detection).
    private static let browserApps: Set<String> = [
        "Google Chrome",
        "Arc",
        "Safari",
        "Firefox",
        "Microsoft Edge",
        "Brave Browser",
        "Opera",
    ]

    // Auto-retry state for transient failures (Exposé, Mission Control, etc.)
    private var isInRecoveryMode = false
    private var recoveryRetryCount = 0
    private let maxRecoveryRetries = 30  // Try up to 30 attempts before giving up
    private let recoveryInterval: TimeInterval = 5.0  // Seconds between recovery attempts

    // Background polling state for extended recovery after initial retry fails
    private var isInBackgroundPolling = false
    private var backgroundPollTimer: Timer?
    private var backgroundPollCount = 0
    private let maxBackgroundPollAttempts = 5  // 5 attempts × 60s = 5 minutes
    private static var hasAutoResetThisSession = false
    private static var hasSoftRecoveryThisSession = false

    // Retain distributed notification observer tokens
    private var testNotificationObservers: [NSObjectProtocol] = []

    // MARK: - Initialization

    private override init() {
        super.init()

        // Load environment variables
        loadEnvironment()

        // Set up the coordinator event callback
        AssistantCoordinator.shared.setEventCallback { [weak self] type, data in
            self?.sendEvent(type: type, data: data)
        }

        // Set up system event observers for sleep/wake/lock recovery
        setupSystemEventObservers()

        // Listen for CLI-triggered test notifications
        setupTestNotificationListeners()

        log("ProactiveAssistantsPlugin initialized")
    }

    // MARK: - Environment Loading

    private func loadEnvironment() {
        let envPaths = [
            Bundle.main.path(forResource: ".env", ofType: nil),
            FileManager.default.currentDirectoryPath + "/.env",
            NSHomeDirectory() + "/.omi.env",
            NSHomeDirectory() + "/.hartford.env"
        ].compactMap { $0 }

        for path in envPaths {
            if let contents = try? String(contentsOfFile: path, encoding: .utf8) {
                for line in contents.components(separatedBy: .newlines) {
                    let parts = line.split(separator: "=", maxSplits: 1)
                    if parts.count == 2 {
                        let key = String(parts[0]).trimmingCharacters(in: .whitespaces)
                        let value = String(parts[1]).trimmingCharacters(in: .whitespaces)
                            .trimmingCharacters(in: CharacterSet(charactersIn: "\"'"))
                        setenv(key, value, 1)
                    }
                }
                log("Loaded environment from: \(path)")
                break
            }
        }

        DesktopBackendEnvironment.applyReleaseChannelDefaults()
    }


    // MARK: - Assistant Management

    private func enableAssistant(identifier: String, enabled: Bool) {
        switch identifier {
        case "focus":
            FocusAssistantSettings.shared.isEnabled = enabled
        case "task-extraction":
            TaskAssistantSettings.shared.isEnabled = enabled
        case "insight":
            InsightAssistantSettings.shared.isEnabled = enabled
        case "memory-extraction":
            MemoryAssistantSettings.shared.isEnabled = enabled
        default:
            log("Unknown assistant: \(identifier)")
        }
    }

    // MARK: - Public Monitoring Control

    /// Start monitoring with optional retry for transient permission failures
    public func startMonitoring(retryCount: Int = 0, completion: @escaping (Bool, String?) -> Void) {
        let maxRetries = 3
        let retryDelays: [Double] = [2.0, 4.0, 8.0]  // exponential backoff

        // Guard against both active monitoring and pending startup (race condition fix)
        guard !isMonitoring && !isStartingMonitoring else {
            completion(isMonitoring, nil)
            return
        }

        // Set flag synchronously before async call to prevent race condition
        isStartingMonitoring = true

        // Check screen recording permission (and update cache)
        refreshScreenRecordingPermission()
        guard hasScreenRecordingPermission else {
            if retryCount == 0 {
                // First attempt: request permissions and schedule retry
                ScreenCaptureService.requestAllScreenCapturePermissions()
            }

            if retryCount < maxRetries {
                let delay = retryDelays[retryCount]
                log("Screen recording permission not yet granted, retrying in \(delay)s (attempt \(retryCount + 1)/\(maxRetries))")
                isStartingMonitoring = false
                DispatchQueue.main.asyncAfter(deadline: .now() + delay) { [weak self] in
                    self?.startMonitoring(retryCount: retryCount + 1, completion: completion)
                }
                return
            }

            log("Screen recording permission not granted after \(maxRetries) retries, giving up")
            isStartingMonitoring = false
            completion(false, "Screen recording permission not granted")
            return
        }

        // Request notification permission in parallel — don't block monitoring on it.
        // Screen analysis can work without notifications - users just won't get alerts.
        UNUserNotificationCenter.current().requestAuthorization(options: [.alert, .sound, .badge]) { granted, error in
            DispatchQueue.main.async {
                if let error = error {
                    let nsError = error as NSError
                    log("Notification permission request error: \(error.localizedDescription) (domain=\(nsError.domain) code=\(nsError.code))")

                    // UNErrorDomain code 1 = notificationsNotAllowed
                    // This happens when LaunchServices has the app marked as launch-disabled,
                    // preventing notification center registration. Repair and retry once.
                    if nsError.domain == "UNErrorDomain" && nsError.code == 1 {
                        AnalyticsManager.shared.notificationRepairTriggered(
                            reason: "launch_disabled_error_startup",
                            previousStatus: "notDetermined",
                            currentStatus: "error_code_1"
                        )
                        Self.repairNotificationRegistration()
                    }
                }

                if !granted {
                    log("Notification permission not granted - screen analysis will work but notifications will be disabled")
                }
            }
        }

        // Start monitoring immediately — don't wait for notification permission callback
        continueStartMonitoring(completion: completion)
    }

    /// Repair LaunchServices registration when notification authorization fails with "not allowed".
    /// The launch-disabled flag in LaunchServices prevents notification center registration.
    /// Unregistering and re-registering clears the flag, then retries authorization.
    static func repairNotificationRegistration() {
        let appPath = Bundle.main.bundlePath
        let bundleURL = Bundle.main.bundleURL
        log("Repairing LaunchServices registration for notifications: \(appPath)")

        let lsregister = "/System/Library/Frameworks/CoreServices.framework/Frameworks/LaunchServices.framework/Support/lsregister"

        // Run blocking Process calls on a background thread
        DispatchQueue.global(qos: .utility).async {
            // Unregister to clear stale/launch-disabled entries
            let unregister = Process()
            unregister.executableURL = URL(fileURLWithPath: lsregister)
            unregister.arguments = ["-u", appPath]
            try? unregister.run()
            unregister.waitUntilExit()

            // Force re-register
            let register = Process()
            register.executableURL = URL(fileURLWithPath: lsregister)
            register.arguments = ["-f", appPath]
            try? register.run()
            register.waitUntilExit()

            // Restart usernoted (notification center daemon) to pick up fresh registration
            // Runs as current user (no sudo needed), auto-restarts within ~1 second
            let killUsernoted = Process()
            killUsernoted.executableURL = URL(fileURLWithPath: "/usr/bin/killall")
            killUsernoted.arguments = ["usernoted"]
            killUsernoted.standardOutput = FileHandle.nullDevice
            killUsernoted.standardError = FileHandle.nullDevice
            try? killUsernoted.run()
            killUsernoted.waitUntilExit()
            log("Restarted usernoted to force notification re-discovery")

            // Wait for usernoted to restart before retrying
            Thread.sleep(forTimeInterval: 1.5)

            DispatchQueue.main.async {
                // Also re-register via LSRegisterURL (must be on main thread)
                if let cfURL = bundleURL as CFURL? {
                    LSRegisterURL(cfURL, true)
                }

                log("LaunchServices re-registration complete, retrying notification authorization...")

                // Retry authorization after a short delay
                DispatchQueue.main.asyncAfter(deadline: .now() + 1.0) {
                    NSApp.activate()
                    UNUserNotificationCenter.current().requestAuthorization(options: [.alert, .sound, .badge]) { granted, error in
                        if let error = error {
                            log("Notification retry after repair failed: \(error.localizedDescription)")
                        } else if granted {
                            log("Notification permission granted after LaunchServices repair")
                        }
                    }
                }
            }
        }
    }

    private func continueStartMonitoring(completion: @escaping (Bool, String?) -> Void) {
        // Report resources before starting heavy monitoring
        ResourceMonitor.shared.reportResourcesNow(context: "before_monitoring_start")

        // Initialize services
        screenCaptureService = ScreenCaptureService()

        do {
            focusAssistant = try FocusAssistant(
                onAlert: { [weak self] message in
                    self?.sendEvent(type: "alert", data: ["message": message])
                },
                onStatusChange: { [weak self] status in
                    Task { @MainActor in
                        self?.lastStatus = status
                        self?.sendEvent(type: "statusChange", data: ["status": status.rawValue])
                    }
                },
                onRefocus: {
                    Task { @MainActor in
                        OverlayService.shared.showGlowAroundActiveWindow(colorMode: .focused)
                    }
                },
                onDistraction: {
                    Task { @MainActor in
                        OverlayService.shared.showGlowAroundActiveWindow(colorMode: .distracted)
                    }
                }
            )

            if let focus = focusAssistant {
                AssistantCoordinator.shared.register(focus)
            }

            taskAssistant = try TaskAssistant()

            if let task = taskAssistant {
                AssistantCoordinator.shared.register(task)
            }

            Task { await TaskDeduplicationService.shared.start() }
            Task { await TaskPrioritizationService.shared.start() }
            Task { await TaskPromotionService.shared.start() }

            insightAssistant = try InsightAssistant()

            if let insight = insightAssistant {
                AssistantCoordinator.shared.register(insight)
            }

            memoryAssistant = try MemoryAssistant()

            if let memory = memoryAssistant {
                AssistantCoordinator.shared.register(memory)
            }

        } catch {
            log("ProactiveAssistantsPlugin: Failed to initialize assistants: \(error.localizedDescription)")
            logError("ProactiveAssistantsPlugin: Assistant initialization failed", error: error)
            isStartingMonitoring = false
            completion(false, error.localizedDescription)
            return
        }

        // Get initial app state
        let (appName, _, _) = WindowMonitor.getActiveWindowInfoStatic()
        if let appName = appName {
            currentApp = appName
            // Update FocusStorage with initial detected app
            FocusStorage.shared.updateDetectedApp(appName)
            AssistantCoordinator.shared.notifyAppSwitch(newApp: appName)
        }

        // Start window monitor
        windowMonitor = WindowMonitor { [weak self] appName in
            Task { @MainActor in
                self?.onAppActivated(appName: appName)
            }
        }
        windowMonitor?.start()

        // Start capture timer (invalidate any orphaned timer first as safety measure)
        captureTimer?.invalidate()
        captureTimer = Timer.scheduledTimer(withTimeInterval: RewindSettings.shared.captureInterval, repeats: true) { [weak self] _ in
            Task { @MainActor in
                await self?.captureFrame()
            }
        }

        isMonitoring = true

        // Capture the first frame immediately so screenshots appear right away
        // (don't wait for the first timer interval to elapse)
        Task { @MainActor in
            await self.captureFrame()
        }
        isStartingMonitoring = false

        // Report resources after initialization
        ResourceMonitor.shared.reportResourcesNow(context: "after_monitoring_start")

        sendEvent(type: "monitoringStarted", data: [:])
        AnalyticsManager.shared.monitoringStarted()
        NotificationCenter.default.post(
            name: .assistantMonitoringStateDidChange,
            object: nil,
            userInfo: ["isMonitoring": true]
        )
        log("Proactive assistants started")

        completion(true, nil)
    }

    /// Stop monitoring
    public func stopMonitoring() {
        guard isMonitoring else { return }

        captureTimer?.invalidate()
        captureTimer = nil
        analysisDelayTimer?.invalidate()
        analysisDelayTimer = nil
        distributionDebounceTimer?.invalidate()
        distributionDebounceTimer = nil
        isInDelayPeriod = false
        lastDistributedApp = nil
        lastDistributedWindowTitle = nil
        latestCapturedFrame = nil
        lastDistributionTime = .distantPast

        windowMonitor?.stop()
        windowMonitor = nil

        if let focus = focusAssistant {
            Task {
                await focus.stop()
            }
        }
        if let task = taskAssistant {
            Task {
                await task.stop()
            }
        }
        Task { await TaskDeduplicationService.shared.stop() }
        Task { await TaskPromotionService.shared.stop() }
        if let insight = insightAssistant {
            Task {
                await insight.stop()
            }
        }
        if let memory = memoryAssistant {
            Task {
                await memory.stop()
            }
        }

        focusAssistant = nil
        taskAssistant = nil
        insightAssistant = nil
        memoryAssistant = nil
        screenCaptureService = nil

        isMonitoring = false
        isStartingMonitoring = false  // Reset in case stop was called during startup
        isProcessingRewindFrame = false
        if droppedFrameCount > 0 {
            log("RewindBackpressure: Session total dropped frames: \(droppedFrameCount)")
        }
        droppedFrameCount = 0
        currentApp = nil
        currentWindowID = nil
        currentWindowTitle = nil
        lastStatus = nil
        frameCount = 0

        // Clear FocusStorage real-time state
        FocusStorage.shared.clearRealtimeStatus()

        // Report resources after stopping
        ResourceMonitor.shared.reportResourcesNow(context: "after_monitoring_stop")

        sendEvent(type: "monitoringStopped", data: [:])
        AnalyticsManager.shared.monitoringStopped()
        NotificationCenter.default.post(
            name: .assistantMonitoringStateDidChange,
            object: nil,
            userInfo: ["isMonitoring": false]
        )
        log("Proactive assistants stopped")
    }

    /// Toggle monitoring state
    public func toggleMonitoring() {
        if isMonitoring {
            stopMonitoring()
        } else {
            startMonitoring { success, error in
                if !success, let error = error {
                    logError("Failed to start monitoring: \(error)")
                }
            }
        }
    }

    /// Check if screen recording permission is granted
    /// Uses cached value to avoid excessive permission check logging
    public var hasScreenRecordingPermission: Bool {
        if let cached = _hasScreenRecordingPermission {
            return cached
        }
        // First access - check and cache
        let result = ScreenCaptureService.checkPermission()
        _hasScreenRecordingPermission = result
        return result
    }

    /// Refresh the cached screen recording permission state
    public func refreshScreenRecordingPermission() {
        _hasScreenRecordingPermission = ScreenCaptureService.checkPermission()
    }

    /// Get current monitoring status
    var currentStatus: (isMonitoring: Bool, currentApp: String?, lastStatus: FocusStatus?) {
        return (isMonitoring, currentApp, lastStatus)
    }

    // MARK: - Frame Capture

    private func onAppActivated(appName: String) {
        guard appName != currentApp else { return }
        currentApp = appName
        currentWindowID = nil
        currentWindowTitle = nil  // Reset window title on app switch

        // Update FocusStorage immediately with detected app (before analysis)
        FocusStorage.shared.updateDetectedApp(appName)

        // Notify all assistants
        AssistantCoordinator.shared.notifyAppSwitch(newApp: appName)

        sendEvent(type: "appSwitch", data: ["app": appName])

        // Start/restart the analysis delay timer
        let delaySeconds = AssistantSettings.shared.analysisDelay

        analysisDelayTimer?.invalidate()
        analysisDelayTimer = nil

        if delaySeconds > 0 {
            isInDelayPeriod = true
            AssistantCoordinator.shared.clearAllPendingWork()
            log("App switch detected, starting \(delaySeconds)s analysis delay")

            // Update FocusStorage with delay end time
            let delayEndTime = Date().addingTimeInterval(TimeInterval(delaySeconds))
            FocusStorage.shared.updateDelayEndTime(delayEndTime)

            analysisDelayTimer = Timer.scheduledTimer(withTimeInterval: TimeInterval(delaySeconds), repeats: false) { [weak self] _ in
                Task { @MainActor in
                    self?.isInDelayPeriod = false
                    self?.analysisDelayTimer = nil
                    FocusStorage.shared.updateDelayEndTime(nil)
                    log("Analysis delay ended, resuming frame processing")
                }
            }
        } else {
            isInDelayPeriod = false
            FocusStorage.shared.updateDelayEndTime(nil)
            Task { @MainActor in
                await captureFrame()
            }
        }
    }

    private func captureFrame() async {
        guard isMonitoring, let screenCaptureService = screenCaptureService else { return }

        // Periodic screen recording permission recheck (issue #5792).
        // Detects when the user revokes permission via System Settings while monitoring is active,
        // and stops gracefully instead of silently failing on every capture.
        let now = Date()
        if now.timeIntervalSince(lastPermissionCheckTime) >= permissionCheckInterval {
            lastPermissionCheckTime = now
            let permissionGranted = ScreenCaptureService.checkPermission()
            _hasScreenRecordingPermission = permissionGranted
            if !permissionGranted {
                log("ProactiveAssistantsPlugin: Screen recording permission revoked — stopping monitoring")
                // Send user-visible notification about lost permission
                sendEvent(type: "permissionLost", data: ["permission": "screenRecording"])
                stopMonitoring()
                return
            }
        }

        // Skip capture during system modes that block ScreenCaptureKit (Mission Control, Expose, etc.)
        // This avoids burning through consecutive failures and generating unnecessary error events
        if isInSpecialSystemMode() {
            return
        }

        // Skip capture while a screenshot / screen-recording app is frontmost.
        // Both apps using ScreenCaptureKit at the same time contend for WindowServer
        // locks, which can stall the user's capture UI for 20-60s. Yield to the user.
        if isScreenshotAppFrontmost() {
            if !wasScreenshotAppFrontmost {
                log("ProactiveAssistantsPlugin: Screenshot app frontmost — pausing capture to avoid WindowServer contention")
                wasScreenshotAppFrontmost = true
            }
            screenshotAppBackoffUntil = Date().addingTimeInterval(10)
            return
        } else if wasScreenshotAppFrontmost {
            log("ProactiveAssistantsPlugin: Screenshot app no longer frontmost, holding backoff for \(Int(max(0, screenshotAppBackoffUntil.timeIntervalSinceNow)))s")
            wasScreenshotAppFrontmost = false
        }

        // Continue honoring the backoff window after the screenshot app resigns so its
        // post-capture editor UI (e.g. CleanShot's annotation window) isn't disturbed.
        if Date() < screenshotAppBackoffUntil {
            return
        }

        // Get current window info (use real app name, not cached)
        let (realAppName, windowTitle, windowID) = await WindowMonitor.getActiveWindowInfoAsync()

        // Check if the current app is excluded from Rewind capture
        let isRewindExcluded = realAppName.map { RewindSettings.shared.isAppExcluded($0) } ?? false

        // Throttle capture when a video call app is frontmost to reduce CPU contention.
        // Captures 1 out of every N frames (e.g., effective ~5s interval at default 1s capture rate).
        if isVideoCallApp(appName: realAppName, windowTitle: windowTitle) {
            videoCallFrameCounter += 1
            if videoCallFrameCounter < videoCallThrottleFactor {
                if videoCallFrameCounter == 1 {
                    log("VideoCallThrottle: Detected call app '\(realAppName ?? "unknown")', throttling capture to 1/\(videoCallThrottleFactor) frames")
                }
                return  // Skip this frame
            }
            // This frame will be captured — reset counter for next cycle
            videoCallFrameCounter = 0
        } else if videoCallFrameCounter > 0 {
            log("VideoCallThrottle: Left call app, resuming normal capture")
            videoCallFrameCounter = 0
        }

        // Unified context switch detection (covers app changes, window ID changes, and title changes)
        // Called BEFORE trackFrame so the coordinator's departing frame is from the previous context
        if let appForCheck = realAppName ?? currentApp {
            let switched = AssistantCoordinator.shared.checkContextSwitch(
                newApp: appForCheck,
                newWindowTitle: windowTitle
            )
            if switched && !isInDelayPeriod {
                let delaySeconds = AssistantSettings.shared.analysisDelay
                if delaySeconds > 0 {
                    isInDelayPeriod = true
                    AssistantCoordinator.shared.clearAllPendingWork()
                    log("Context switch detected, starting \(delaySeconds)s analysis delay")

                    analysisDelayTimer?.invalidate()
                    let delayEndTime = Date().addingTimeInterval(TimeInterval(delaySeconds))
                    FocusStorage.shared.updateDelayEndTime(delayEndTime)

                    analysisDelayTimer = Timer.scheduledTimer(withTimeInterval: TimeInterval(delaySeconds), repeats: false) { [weak self] _ in
                        Task { @MainActor in
                            self?.isInDelayPeriod = false
                            self?.analysisDelayTimer = nil
                            FocusStorage.shared.updateDelayEndTime(nil)
                            log("Analysis delay ended, resuming frame processing")
                        }
                    }
                }
            }
        }

        // Update local window tracking
        if let windowID = windowID {
            currentWindowID = windowID
        }
        currentWindowTitle = windowTitle

        // Use real app name from window info, fall back to cached if unavailable
        let appName = realAppName ?? currentApp

        // Always capture frames (other features may need them)
        // macOS 14+: capture CGImage directly, encode JPEG once for assistants,
        // pass CGImage to RewindIndexer (avoids redundant encode/decode round-trips)
        if #available(macOS 14.0, *) {
            // Use the window ID already resolved above (line 624) to avoid stale cache hits
            // from a second getActiveWindowInfoAsync() call inside captureActiveWindowCGImage()
            var cgImage: CGImage? = nil
            if let wid = windowID {
                switch await screenCaptureService.captureWindowCGImage(windowID: wid) {
                case .success(let image):
                    cgImage = image
                case .windowGone:
                    // The window disappeared between resolution and capture (user closed
                    // a tab, dismissed a modal, app destroyed the window). Re-resolve the
                    // active window fresh and retry once — do NOT count this as a capture
                    // failure. This used to trip the consecutive-failure counter and falsely
                    // declare "screen recording permission lost" after normal user actions.
                    cgImage = await screenCaptureService.captureActiveWindowCGImage()
                case .failed:
                    cgImage = nil
                }
            } else {
                cgImage = await screenCaptureService.captureActiveWindowCGImage()
            }
            if let cgImage = cgImage,
               let appName = appName {
                if !lastCaptureSucceeded {
                    log("Screen capture recovered after \(consecutiveFailures) failures")
                }
                consecutiveFailures = 0
                lastCaptureSucceeded = true

                frameCount += 1
                let captureTime = Date()

                // Encode JPEG off main actor — CGImageDestinationFinalize is CPU-heavy
                let captureService = screenCaptureService
                let jpegData = await Task.detached(priority: .userInitiated) {
                    captureService.encodeJPEG(from: cgImage)
                }.value
                if let jpegData = jpegData {
                    let frame = CapturedFrame(
                        jpegData: jpegData,
                        appName: appName,
                        windowTitle: currentWindowTitle,
                        frameNumber: frameCount,
                        captureTime: captureTime
                    )

                    // Always track the frame for context switch detection (even during delay)
                    AssistantCoordinator.shared.trackFrame(frame)

                    if !isInDelayPeriod {
                        distributeFrameIfChanged(frame)
                    } else {
                        // During delay, still distribute to assistants that need it (e.g. refocus detection)
                        AssistantCoordinator.shared.distributeFrameDuringDelay(frame)
                    }
                }

                // Pass CGImage directly to RewindIndexer (only if not excluded from Rewind)
                // Backpressure: skip this frame if the previous one is still being processed.
                // Without this, fire-and-forget Tasks queue up holding CGImages (~24MB each),
                // causing multi-GB memory growth when encoding can't keep up with capture rate.
                if !isRewindExcluded {
                    if isProcessingRewindFrame {
                        droppedFrameCount += 1
                        if droppedFrameCount == 1 || droppedFrameCount % 30 == 0 {
                            log("RewindBackpressure: Dropped frame (encoder busy), total dropped: \(droppedFrameCount)")
                        }
                    } else {
                        isProcessingRewindFrame = true
                        let windowTitle = self.currentWindowTitle
                        Task { [weak self] in
                            await RewindIndexer.shared.processFrame(
                                cgImage: cgImage,
                                appName: appName,
                                windowTitle: windowTitle,
                                captureTime: captureTime
                            )
                            await MainActor.run {
                                self?.isProcessingRewindFrame = false
                            }
                        }
                    }
                }
            } else {
                consecutiveFailures += 1
                lastCaptureSucceeded = false

                if consecutiveFailures == 1 || consecutiveFailures % 5 == 0 {
                    log("ProactiveAssistantsPlugin: Capture failed (\(consecutiveFailures) consecutive), frontmost: \(getFrontmostAppInfo())")
                }

                if consecutiveFailures >= maxConsecutiveFailures {
                    handleRepeatedCaptureFailures()
                }
                return
            }
        } else if let jpegData = await screenCaptureService.captureActiveWindowAsync(),
           let appName = appName {
            // macOS 13.x fallback: existing JPEG-based path
            if !lastCaptureSucceeded {
                log("Screen capture recovered after \(consecutiveFailures) failures")
            }
            consecutiveFailures = 0
            lastCaptureSucceeded = true

            frameCount += 1

            let frame = CapturedFrame(
                jpegData: jpegData,
                appName: appName,
                windowTitle: currentWindowTitle,
                frameNumber: frameCount
            )

            // Always track the frame for context switch detection (even during delay)
            AssistantCoordinator.shared.trackFrame(frame)

            if !isInDelayPeriod {
                distributeFrameIfChanged(frame)
            } else {
                // During delay, still distribute to assistants that need it (e.g. refocus detection)
                AssistantCoordinator.shared.distributeFrameDuringDelay(frame)
            }

            if !isRewindExcluded {
                if isProcessingRewindFrame {
                    droppedFrameCount += 1
                    if droppedFrameCount == 1 || droppedFrameCount % 30 == 0 {
                        log("RewindBackpressure: Dropped frame (encoder busy), total dropped: \(droppedFrameCount)")
                    }
                } else {
                    isProcessingRewindFrame = true
                    Task { [weak self] in
                        await RewindIndexer.shared.processFrame(frame)
                        await MainActor.run {
                            self?.isProcessingRewindFrame = false
                        }
                    }
                }
            }
        } else {
            // Track capture failures
            consecutiveFailures += 1
            lastCaptureSucceeded = false

            // Log first failure and every 5th failure to avoid spam
            if consecutiveFailures == 1 || consecutiveFailures % 5 == 0 {
                log("ProactiveAssistantsPlugin: Capture failed (\(consecutiveFailures) consecutive), frontmost: \(getFrontmostAppInfo())")
            }

            if consecutiveFailures >= maxConsecutiveFailures {
                handleRepeatedCaptureFailures()
            }
        }
    }


    // MARK: - Change-Gated Distribution

    /// Distribute a frame to assistants only when context changed (app or window title),
    /// with a 3-second debounce to let rapid switches settle, and a 60-second fallback
    /// for periodic re-analysis within the same context.
    private func distributeFrameIfChanged(_ frame: CapturedFrame) {
        latestCapturedFrame = frame

        // First frame after monitoring starts — distribute immediately, no debounce
        if lastDistributedApp == nil {
            flushDebouncedFrame()
            return
        }

        let contextChanged = ContextDetection.didContextChange(
            fromApp: lastDistributedApp,
            fromWindowTitle: lastDistributedWindowTitle,
            toApp: frame.appName,
            toWindowTitle: frame.windowTitle
        )

        let timeSinceLastDistribution = Date().timeIntervalSince(lastDistributionTime)
        let fallbackDue = timeSinceLastDistribution >= distributionFallbackInterval

        if contextChanged {
            // Update tracking immediately so subsequent captures in the same new context
            // don't keep resetting the debounce timer (fixes starvation bug).
            lastDistributedApp = frame.appName
            lastDistributedWindowTitle = frame.windowTitle

            // Restart the 3s debounce timer — fires 3s after the last context change
            distributionDebounceTimer?.invalidate()
            distributionDebounceTimer = Timer.scheduledTimer(withTimeInterval: 3.0, repeats: false) { [weak self] _ in
                Task { @MainActor in
                    self?.flushDebouncedFrame()
                }
            }
        } else if fallbackDue {
            // Same context but fallback interval elapsed — distribute for periodic re-analysis
            distributionDebounceTimer?.invalidate()
            flushDebouncedFrame()
        }
        // Otherwise: same context, within fallback interval — skip distribution
    }

    /// Flush the latest captured frame to all assistants (called when debounce timer fires or fallback is due).
    private func flushDebouncedFrame() {
        guard let frame = latestCapturedFrame else { return }

        lastDistributedApp = frame.appName
        lastDistributedWindowTitle = frame.windowTitle
        lastDistributionTime = Date()
        distributionDebounceTimer = nil

        AssistantCoordinator.shared.distributeFrame(frame)
    }

    // MARK: - Event Broadcasting

    private func sendEvent(type: String, data: [String: Any]) {
        var event = data
        event["type"] = type
        event["timestamp"] = ISO8601DateFormatter().string(from: Date())

        // Post notification for any listeners
        NotificationCenter.default.post(
            name: .assistantEvent,
            object: nil,
            userInfo: event
        )
    }

    // MARK: - Utility Methods

    /// Open screen recording preferences
    public func openScreenRecordingPreferences() {
        ScreenCaptureService.openScreenRecordingPreferences()
    }

    /// Trigger glow effect manually (for testing)
    func triggerGlow(colorMode: GlowColorMode = .focused) {
        OverlayService.shared.showGlowAroundActiveWindow(colorMode: colorMode)
    }

    // MARK: - CLI Test Triggers

    /// Listen for distributed notifications from CLI to trigger test runs
    private func setupTestNotificationListeners() {
        // Use selector-based observer (more reliable with DistributedNotificationCenter)
        DistributedNotificationCenter.default().addObserver(
            self,
            selector: #selector(handleInsightTestNotification(_:)),
            name: NSNotification.Name("com.omi.test.insight"),
            object: nil
        )
        DistributedNotificationCenter.default().addObserver(
            self,
            selector: #selector(handleFocusTestNotification(_:)),
            name: NSNotification.Name("com.omi.test.focus"),
            object: nil
        )
        DistributedNotificationCenter.default().addObserver(
            self,
            selector: #selector(handleNotificationTestNotification(_:)),
            name: NSNotification.Name("com.omi.test.notification"),
            object: nil
        )
        log("InsightTestCLI: Notification observer registered")
        log("FocusTestCLI: Notification observer registered")
        log("NotificationTestCLI: Notification observer registered")
    }

    @objc private func handleInsightTestNotification(_ notification: Notification) {
        Task { @MainActor in
            let hours = (notification.userInfo?["hours"] as? String).flatMap { Double($0) } ?? 1.0
            let count = (notification.userInfo?["count"] as? String).flatMap { Int($0) } ?? 10
            log("InsightTestCLI: Received test trigger (hours=\(hours), count=\(count))")
            await InsightTestRunner.runCLITest(lookbackHours: hours, maxScreenshots: count)
        }
    }

    @objc private func handleFocusTestNotification(_ notification: Notification) {
        Task { @MainActor in
            let hours = (notification.userInfo?["hours"] as? String).flatMap { Double($0) } ?? 1.0
            let count = (notification.userInfo?["count"] as? String).flatMap { Int($0) } ?? 20
            log("FocusTestCLI: Received test trigger (hours=\(hours), count=\(count))")
            await FocusTestRunner.runCLITest(lookbackHours: hours, maxScreenshots: count)
        }
    }

    @objc private func handleNotificationTestNotification(_ notification: Notification) {
        Task { @MainActor in
            let title = (notification.userInfo?["title"] as? String)?.trimmingCharacters(in: .whitespacesAndNewlines)
            let message = (notification.userInfo?["message"] as? String)?.trimmingCharacters(in: .whitespacesAndNewlines)
            let assistantId = (notification.userInfo?["assistantId"] as? String)?.trimmingCharacters(in: .whitespacesAndNewlines)

            let resolvedTitle = title?.isEmpty == false ? title! : "Insight"
            let resolvedMessage = message?.isEmpty == false ? message! : "Test notification from Omi"
            let resolvedAssistantId = assistantId?.isEmpty == false ? assistantId! : "insight"

            let context = FloatingBarNotificationContext(
                sourceTitle: resolvedTitle,
                assistantId: resolvedAssistantId,
                sourceApp: notification.userInfo?["sourceApp"] as? String,
                windowTitle: notification.userInfo?["windowTitle"] as? String,
                contextSummary: notification.userInfo?["contextSummary"] as? String,
                currentActivity: notification.userInfo?["currentActivity"] as? String,
                reasoning: notification.userInfo?["reasoning"] as? String,
                detail: notification.userInfo?["detail"] as? String
            )

            log("NotificationTestCLI: Received test trigger (title=\(resolvedTitle), assistantId=\(resolvedAssistantId))")
            NotificationService.shared.sendNotification(
                title: resolvedTitle,
                message: resolvedMessage,
                assistantId: resolvedAssistantId,
                context: context
            )
        }
    }

    // MARK: - System Event Handling

    /// Set up observers for system sleep/wake and screen lock/unlock events
    private func setupSystemEventObservers() {
        // System about to sleep - track state before sleep
        let sleepObserver = NSWorkspace.shared.notificationCenter.addObserver(
            forName: NSWorkspace.willSleepNotification,
            object: nil,
            queue: .main
        ) { [weak self] _ in
            Task { @MainActor in
                self?.wasMonitoringBeforeSleep = self?.isMonitoring ?? false
                log("ProactiveAssistantsPlugin: System going to sleep, wasMonitoring=\(self?.wasMonitoringBeforeSleep ?? false)")

                // Pause the capture timer while sleeping (same as screen lock)
                self?.captureTimer?.invalidate()
                self?.captureTimer = nil
            }
        }
        systemEventObservers.append(sleepObserver)

        // System wake from sleep
        let wakeObserver = NotificationCenter.default.addObserver(
            forName: .systemDidWake,
            object: nil,
            queue: .main
        ) { [weak self] _ in
            Task { @MainActor in
                self?.handleSystemWake()
            }
        }
        systemEventObservers.append(wakeObserver)

        // Screen locked
        let lockObserver = NotificationCenter.default.addObserver(
            forName: .screenDidLock,
            object: nil,
            queue: .main
        ) { [weak self] _ in
            Task { @MainActor in
                self?.handleScreenLock()
            }
        }
        systemEventObservers.append(lockObserver)

        // Screen unlocked
        let unlockObserver = NotificationCenter.default.addObserver(
            forName: .screenDidUnlock,
            object: nil,
            queue: .main
        ) { [weak self] _ in
            Task { @MainActor in
                self?.handleScreenUnlock()
            }
        }
        systemEventObservers.append(unlockObserver)
    }

    /// Handle system wake from sleep
    private func handleSystemWake() {
        log("ProactiveAssistantsPlugin: System woke from sleep")

        // Reset failure counter
        consecutiveFailures = 0
        lastCaptureSucceeded = true

        // If we were monitoring before sleep, reinitialize capture service and restart timer
        if wasMonitoringBeforeSleep && isMonitoring {
            log("ProactiveAssistantsPlugin: Restarting screen capture after wake")

            // Reinitialize the screen capture service
            screenCaptureService = ScreenCaptureService()

            // Refresh permission state
            refreshScreenRecordingPermission()

            // Restart capture timer after a brief delay to let the system settle
            captureTimer?.invalidate()
            captureTimer = nil
            DispatchQueue.main.asyncAfter(deadline: .now() + 1.5) { [weak self] in
                guard let self = self, self.isMonitoring else { return }
                self.captureTimer?.invalidate()
                self.captureTimer = Timer.scheduledTimer(withTimeInterval: RewindSettings.shared.captureInterval, repeats: true) { [weak self] _ in
                    Task { @MainActor in
                        await self?.captureFrame()
                    }
                }
                log("ProactiveAssistantsPlugin: Capture timer restarted after wake")
            }
        }

        wasMonitoringBeforeSleep = false
    }

    /// Handle screen lock - pause capture
    private func handleScreenLock() {
        log("ProactiveAssistantsPlugin: Screen locked - pausing capture")

        wasMonitoringBeforeLock = isMonitoring

        // Pause the capture timer while locked
        captureTimer?.invalidate()
        captureTimer = nil
    }

    /// Handle screen unlock - resume capture
    private func handleScreenUnlock() {
        log("ProactiveAssistantsPlugin: Screen unlocked - resuming capture")

        // Reset failure counter
        consecutiveFailures = 0
        lastCaptureSucceeded = true

        if wasMonitoringBeforeLock && isMonitoring {
            log("ProactiveAssistantsPlugin: Restarting capture timer after unlock")

            // Reinitialize screen capture service to ensure fresh state
            screenCaptureService = ScreenCaptureService()

            // Restart capture timer
            captureTimer?.invalidate()
            captureTimer = Timer.scheduledTimer(withTimeInterval: RewindSettings.shared.captureInterval, repeats: true) { [weak self] _ in
                Task { @MainActor in
                    await self?.captureFrame()
                }
            }
        } else if wasMonitoringBeforeLock && !isMonitoring {
            // We stopped monitoring while locked, restart it
            log("ProactiveAssistantsPlugin: Restarting monitoring after unlock")
            startMonitoring { success, error in
                if !success, let error = error {
                    log("Failed to restart monitoring after unlock: \(error)")
                }
            }
        }

        wasMonitoringBeforeLock = false
    }

    /// Handle repeated capture failures (likely permission issue)
    private func handleRepeatedCaptureFailures() {
        let frontApp = getFrontmostAppInfo()
        log("ProactiveAssistantsPlugin: Detected \(consecutiveFailures) consecutive capture failures (frontmost: \(frontApp))")

        // Check if we're in a special system mode (Exposé, Mission Control, etc.)
        // These modes temporarily block screen capture but aren't permission issues
        if isInSpecialSystemMode() {
            log("ProactiveAssistantsPlugin: System is in special mode, entering recovery mode instead of stopping")
            enterRecoveryMode()
            return
        }

        // First pass: run a single permission test.
        refreshScreenRecordingPermission()

        if hasScreenRecordingPermission {
            // Permission appears granted but capture is failing
            // This could be a transient issue - enter recovery mode instead of stopping
            log("ProactiveAssistantsPlugin: Capture failing with permission granted, entering recovery mode")
            enterRecoveryMode()
            return
        }

        // First permission test failed. Do NOT declare permission lost yet —
        // `/usr/sbin/screencapture` can transiently fail during app-switches,
        // mid-animation, or while macOS is mid-context-switch. A single failed
        // probe previously stopped monitoring + fired a scary "permission lost"
        // notification even though real recording was still working.
        // Re-test after a short delay; only stop if both tests fail.
        log("ProactiveAssistantsPlugin: First permission test failed, re-testing to avoid false positive")
        Task { @MainActor [weak self] in
            try? await Task.sleep(nanoseconds: 1_500_000_000)  // 1.5s
            guard let self = self, self.isMonitoring else { return }

            self.refreshScreenRecordingPermission()
            if self.hasScreenRecordingPermission {
                log("ProactiveAssistantsPlugin: Permission test recovered on second check — treating initial failure as transient, entering recovery mode")
                self.enterRecoveryMode()
                return
            }

            log("ProactiveAssistantsPlugin: Screen recording permission lost (confirmed by second test)")

            // Post notification for AppState to update UI
            NotificationCenter.default.post(name: .screenCapturePermissionLost, object: nil)

            // Stop monitoring since we can't capture
            self.stopMonitoring()

            // Send user notification
            NotificationService.shared.sendNotification(
                title: "Screen Recording Permission Required",
                message: "omi needs screen recording permission to continue monitoring. Please re-enable it in System Settings.",
                deliverSystemBanner: true
            )
        }
    }

    // MARK: - Video Call Detection

    /// Check if the frontmost app (and optionally window title) indicates an active video call.
    private func isVideoCallApp(appName: String?, windowTitle: String?) -> Bool {
        guard let appName = appName else { return false }

        // Direct match: dedicated video call apps
        if Self.videoCallApps.contains(appName) {
            return true
        }

        // Browser-based calls: check window title for call keywords
        if Self.browserApps.contains(appName), let title = windowTitle {
            let lowercaseTitle = title.lowercased()
            for keyword in Self.videoCallBrowserKeywords {
                if lowercaseTitle.contains(keyword.lowercased()) {
                    return true
                }
            }
        }

        return false
    }

    // MARK: - Screenshot App Detection

    /// True when a known third-party / system screenshot or screen-recording app is
    /// frontmost. While one is, Omi pauses its 3s capture loop so the user's capture
    /// doesn't stall on WindowServer lock contention with Omi. See PR attached to
    /// the "CleanShot lags 20-60s" investigation.
    private func isScreenshotAppFrontmost() -> Bool {
        guard let frontApp = NSWorkspace.shared.frontmostApplication,
              let bundleID = frontApp.bundleIdentifier else {
            return false
        }
        return Self.screenshotAppBundleIDs.contains(bundleID)
    }

    // MARK: - Special System Mode Detection

    /// Check if the system is in a special mode that blocks screen capture.
    ///
    /// Known modes that block ScreenCaptureKit:
    /// - **Exposé / Mission Control** (F3 or swipe up): Dock owns all windows
    /// - **App Exposé** (swipe down on app): Shows all windows of one app
    /// - **Notification Center**: Slide-in panel
    /// - **Lock Screen**: Captured separately via screenDidLock notification
    /// - **Screen Saver**: Similar to lock screen
    ///
    /// When in these modes, ScreenCaptureKit returns "user declined TCCs" error
    /// even though permission is actually granted. This is a transient state.
    private func isInSpecialSystemMode() -> Bool {
        // Check if Dock is the frontmost app (indicates Exposé/Mission Control)
        if let frontApp = NSWorkspace.shared.frontmostApplication {
            if frontApp.bundleIdentifier == "com.apple.dock" {
                log("SpecialModeDetection: Dock is frontmost app (Exposé/Mission Control active)")
                return true
            }
        }

        // Check for Mission Control windows using CGWindowList
        // When Mission Control is active, Dock creates a window with no name
        guard let windowList = CGWindowListCopyWindowInfo([.optionOnScreenOnly], kCGNullWindowID) as? [[String: Any]] else {
            return false
        }

        for window in windowList {
            guard let ownerName = window[kCGWindowOwnerName as String] as? String else {
                continue
            }

            // Dock window with no name indicates Mission Control/Exposé
            if ownerName == "Dock" {
                let windowName = window[kCGWindowName as String] as? String
                if windowName == nil || windowName?.isEmpty == true {
                    // Check if it's a large window (Mission Control overlay)
                    if let bounds = window[kCGWindowBounds as String] as? [String: CGFloat],
                       let width = bounds["Width"],
                       let height = bounds["Height"],
                       width > 500 && height > 300 {
                        log("SpecialModeDetection: Dock overlay window detected (\(Int(width))x\(Int(height))) - Mission Control/Exposé")
                        return true
                    }
                }
            }

            // Notification Center active
            if ownerName == "NotificationCenter" {
                log("SpecialModeDetection: Notification Center is active")
                return true
            }
        }

        return false
    }

    /// Get the current frontmost app for logging
    private func getFrontmostAppInfo() -> String {
        if let frontApp = NSWorkspace.shared.frontmostApplication {
            return "\(frontApp.localizedName ?? "unknown") (\(frontApp.bundleIdentifier ?? "no-bundle-id"))"
        }
        return "none"
    }

    // MARK: - Recovery Mode

    /// Enter recovery mode - pause capture temporarily and retry
    private func enterRecoveryMode() {
        guard !isInRecoveryMode else { return }

        isInRecoveryMode = true
        recoveryRetryCount = 0

        log("ProactiveAssistantsPlugin: Entering recovery mode, will retry capture periodically")

        // Pause the normal capture timer
        captureTimer?.invalidate()
        captureTimer = nil

        // Start recovery timer - check every 5 seconds if we can capture again
        // Using a slower interval than normal capture to reduce CPU overhead from repeated failed ScreenCaptureKit calls
        captureTimer = Timer.scheduledTimer(withTimeInterval: recoveryInterval, repeats: true) { [weak self] _ in
            Task { @MainActor in
                await self?.attemptRecovery()
            }
        }
    }

    /// Attempt to recover from transient capture failure
    private func attemptRecovery() async {
        recoveryRetryCount += 1

        // Check if system is still in special mode
        if isInSpecialSystemMode() {
            // Still in Exposé/Mission Control, keep waiting
            if recoveryRetryCount % 5 == 0 {
                log("ProactiveAssistantsPlugin: Still in special system mode, waiting... (attempt \(recoveryRetryCount))")
            }

            // Give up after max retries (likely a real issue)
            if recoveryRetryCount >= maxRecoveryRetries {
                log("ProactiveAssistantsPlugin: Recovery timeout in special mode, continuing to wait")
                // Reset counter but keep trying - user might be in Exposé for a while
                recoveryRetryCount = 0
            }
            return
        }

        // Try to capture a frame
        guard let screenCaptureService = screenCaptureService else {
            exitRecoveryMode(success: false)
            return
        }

        if let _ = await screenCaptureService.captureActiveWindowAsync() {
            // Success! Exit recovery mode
            log("ProactiveAssistantsPlugin: Recovery successful after \(recoveryRetryCount) attempts (~\(recoveryRetryCount * Int(recoveryInterval))s), resuming normal capture (frontmost: \(getFrontmostAppInfo()))")
            exitRecoveryMode(success: true)
        } else {
            // Still failing
            if recoveryRetryCount >= maxRecoveryRetries {
                // Give up and show the reset notification
                log("ProactiveAssistantsPlugin: Recovery failed after \(maxRecoveryRetries) attempts")
                exitRecoveryMode(success: false)
            }
        }
    }

    /// Exit recovery mode
    private func exitRecoveryMode(success: Bool) {
        isInRecoveryMode = false
        recoveryRetryCount = 0

        if success {
            // Reset failure counter and resume normal operation
            consecutiveFailures = 0
            lastCaptureSucceeded = true

            // Restart normal capture timer
            captureTimer?.invalidate()
            captureTimer = Timer.scheduledTimer(withTimeInterval: RewindSettings.shared.captureInterval, repeats: true) { [weak self] _ in
                Task { @MainActor in
                    await self?.captureFrame()
                }
            }
        } else {
            // Recovery failed - enter background polling before giving up
            log("ProactiveAssistantsPlugin: Initial recovery failed, entering background polling mode")
            enterBackgroundPollingMode()
        }
    }

    // MARK: - Background Polling (Extended Recovery)

    /// Enter background polling mode - check every 60s for up to 5 minutes
    /// This handles cases where the permission state resolves itself over time
    private func enterBackgroundPollingMode() {
        guard !isInBackgroundPolling else { return }

        isInBackgroundPolling = true
        backgroundPollCount = 0

        log("ProactiveAssistantsPlugin: Starting background polling (every 60s, up to \(maxBackgroundPollAttempts) attempts)")

        // Pause capture timer if still running
        captureTimer?.invalidate()
        captureTimer = nil

        backgroundPollTimer = Timer.scheduledTimer(withTimeInterval: 60, repeats: true) { [weak self] _ in
            Task { @MainActor in
                await self?.backgroundPollAttempt()
            }
        }
    }

    /// Single background poll attempt
    private func backgroundPollAttempt() async {
        backgroundPollCount += 1

        guard let screenCaptureService = screenCaptureService else {
            exitBackgroundPolling(success: false)
            return
        }

        log("ProactiveAssistantsPlugin: Background poll attempt \(backgroundPollCount)/\(maxBackgroundPollAttempts)")

        if let _ = await screenCaptureService.captureActiveWindowAsync() {
            log("ProactiveAssistantsPlugin: Background polling recovered after \(backgroundPollCount) attempts")
            exitBackgroundPolling(success: true)
        } else if backgroundPollCount >= maxBackgroundPollAttempts {
            log("ProactiveAssistantsPlugin: Background polling exhausted, attempting auto-reset")
            exitBackgroundPolling(success: false)
        }
    }

    /// Exit background polling mode
    private func exitBackgroundPolling(success: Bool) {
        isInBackgroundPolling = false
        backgroundPollCount = 0
        backgroundPollTimer?.invalidate()
        backgroundPollTimer = nil

        if success {
            consecutiveFailures = 0
            lastCaptureSucceeded = true

            // Resume normal capture
            captureTimer = Timer.scheduledTimer(withTimeInterval: RewindSettings.shared.captureInterval, repeats: true) { [weak self] _ in
                Task { @MainActor in
                    await self?.captureFrame()
                }
            }
        } else {
            attemptAutoReset()
        }
    }

    /// Attempt automatic recovery (soft first, then hard reset as last resort)
    private func attemptAutoReset() {
        // Step 1: Try soft recovery first (lsregister + SCK re-request, no TCC wipe)
        if !Self.hasSoftRecoveryThisSession {
            Self.hasSoftRecoveryThisSession = true
            log("ProactiveAssistantsPlugin: Attempting soft recovery (no TCC reset)")

            Task {
                let recovered = await ScreenCaptureService.attemptSoftRecovery()
                await MainActor.run {
                    if recovered {
                        log("ProactiveAssistantsPlugin: Soft recovery succeeded, resuming capture")
                        self.consecutiveFailures = 0
                        self.lastCaptureSucceeded = true

                        // Restart normal capture timer
                        self.captureTimer?.invalidate()
                        self.captureTimer = Timer.scheduledTimer(withTimeInterval: RewindSettings.shared.captureInterval, repeats: true) { [weak self] _ in
                            Task { @MainActor in
                                await self?.captureFrame()
                            }
                        }
                    } else {
                        // Soft recovery failed in-process, restart app to refresh permission state
                        // This still avoids wiping TCC — the restart itself often fixes stale caches
                        log("ProactiveAssistantsPlugin: Soft recovery failed in-process, restarting to refresh state")
                        AnalyticsManager.shared.screenCaptureBrokenDetected()
                        ScreenCaptureService.softRecoveryAndRestart()
                    }
                }
            }
            return
        }

        // Step 2: Soft recovery already tried — fall back to showing notification
        // Do NOT auto-reset TCC; let the user decide via the sidebar button
        if Self.hasAutoResetThisSession {
            log("ProactiveAssistantsPlugin: All recovery attempts exhausted this session, showing notification")

            AnalyticsManager.shared.screenCaptureBrokenDetected()
            NotificationCenter.default.post(name: .screenCaptureKitBroken, object: nil)
            stopMonitoring()

            NotificationService.shared.sendNotification(
                title: NotificationService.screenCaptureResetTitle,
                message: "Screen recording permission needs to be re-enabled. Click to open Settings.",
                deliverSystemBanner: true
            )
            return
        }

        Self.hasAutoResetThisSession = true
        log("ProactiveAssistantsPlugin: Soft recovery + restart already tried, notifying user")
        AnalyticsManager.shared.screenCaptureBrokenDetected()
        NotificationCenter.default.post(name: .screenCaptureKitBroken, object: nil)
        stopMonitoring()

        NotificationService.shared.sendNotification(
            title: NotificationService.screenCaptureResetTitle,
            message: "Screen recording permission needs to be re-enabled. Click to open Settings.",
            deliverSystemBanner: true
        )
    }
}

// MARK: - Notification Names

extension Notification.Name {
    static let assistantEvent = Notification.Name("assistantEvent")
}

// MARK: - Backward Compatibility Alias

typealias FocusPlugin = ProactiveAssistantsPlugin
typealias MonitoringService = ProactiveAssistantsPlugin