stonerl
diff --git a/‎MenuBarItemService/SourcePIDCache.swift‎
Lines changed: 179 additions & 4 deletions b/‎MenuBarItemService/SourcePIDCache.swift‎
Lines changed: 179 additions & 4 deletions
diff --git a/‎MenuBarItemService/main.swift‎
Lines changed: 4 additions & 0 deletions b/‎MenuBarItemService/main.swift‎
Lines changed: 4 additions & 0 deletions
diff --git a/‎Shared/Utilities/DiagnosticLogger.swift‎
Lines changed: 48 additions & 26 deletions b/‎Shared/Utilities/DiagnosticLogger.swift‎
Lines changed: 48 additions & 26 deletions
@@ -44,6 +44,18 @@ final class SourcePIDCache {
             runningApp.processIdentifier
         }
 
+        /// The app's bundle identifier, if any. Used by diagnostic
+        /// logging to identify which app's AX extras a frame came from.
+        var bundleIdentifier: String? {
+            runningApp.bundleIdentifier
+        }
+
+        /// A localized, human-readable name for the app. Used by
+        /// diagnostic logging when the bundle identifier is absent.
+        var localizedName: String? {
+            runningApp.localizedName
+        }
+
         /// A Boolean value indicating whether the app's extras menu
         /// bar has been successfully created and stored.
         var hasExtrasMenuBar: Bool {
@@ -277,11 +289,19 @@ final class SourcePIDCache {
     }
 
     private func pidsBody(for windows: [WindowInfo]) -> [pid_t?] {
-        let needsScan = windows.contains { window in
+        // Drive the scan via an unresolved window in the batch, not via
+        // `windows.first`. pidBody returns early on a cache hit (line 292),
+        // so passing a cached window skips the AX traversal entirely.
+        // Once macOS 26 began routing some widgets through the marker-pair
+        // fallback that lives in pidBody's scan body, mid-session arrivals
+        // (new app launches that introduce a fresh nil-PID windowID) were
+        // never getting a scan: the first window in their batch was always
+        // an already-cached resolved one, and the scan only ever ran at
+        // session start.
+        if let unresolved = windows.first(where: { window in
             state.withLock { $0.pids[window.windowID] == nil }
-        }
-        if needsScan, let first = windows.first {
-            _ = pidBody(for: first)
+        }) {
+            _ = pidBody(for: unresolved)
         }
         return windows.map { window in
             state.withLock { $0.pids[window.windowID] }
@@ -367,9 +387,164 @@ final class SourcePIDCache {
             }
         }
 
+        // Marker-pair PID resolution.
+        //
+        // On macOS 26 some widgets (Little Snitch's agent observed in
+        // the wild) have their NSStatusItem hosted by Control Center
+        // at the AX layer and do not publish an AXExtrasMenuBar of
+        // their own. The spatial CG-to-AX pass above cannot find a
+        // per-app extras child for them, so the icon stays unresolved
+        // and the namespace falls back to com.apple.controlcenter.
+        //
+        // Structurally, every NSStatusItem-style widget also publishes
+        // a SECOND CG window in the items-only list whose title is
+        // the widget's bundle identifier (verified empirically for
+        // at.obdev.littlesnitch.agent, com.rogueamoeba.soundsource,
+        // com.wireguard.macos, org.eduvpn.app, com.lighting.huesync,
+        // pl.maketheweb.cleanshotx, and others). This marker window
+        // has the same (width, height) as the on-screen icon but
+        // its position is non-deterministic across launches and can
+        // even sit on a different display, which is why this pass
+        // runs here in the XPC where allWindows spans every display
+        // rather than in the main app's per-call list.
+        //
+        // For each unresolved on-screen icon whose title is NOT
+        // bundle-ID-shaped (generic names like "Item-0", or empty),
+        // looks for the unique marker window with matching size and
+        // synthesizes the sourcePID by either using the marker's
+        // CG-layer owning PID (when it is neither Thaw itself nor
+        // Control Center) or by looking up the running app named by
+        // the marker's bundle-ID title. Multi-match cases are skipped
+        // to prevent misattribution. Thaw's own control items and
+        // self-registration windows are excluded so Thaw's PID can
+        // never be attributed to a third-party widget.
+        if !unresolvedWindows.isEmpty {
+            let thawBundleID = "com.stonerl.Thaw"
+            let ccBundleID = "com.apple.controlcenter"
+            let markers = MarkerPairResolver.extractMarkers(
+                from: allWindows.map { win in
+                    (
+                        windowID: win.windowID,
+                        title: win.title,
+                        size: win.bounds.size,
+                        owningPID: win.owningApplication?.processIdentifier
+                    )
+                },
+                thawControlItemPrefix: "Thaw.ControlItem.",
+                thawBundleID: thawBundleID
+            )
+            let unresolvedInfos = allWindows.filter { unresolvedWindows.contains($0.windowID) }
+            let icons = unresolvedInfos.map { win in
+                MarkerPairResolver.UnresolvedIcon(
+                    windowID: win.windowID,
+                    title: win.title,
+                    size: win.bounds.size
+                )
+            }
+            let resolutions = MarkerPairResolver.resolve(
+                unresolvedIcons: icons,
+                markers: markers,
+                thawBundleID: thawBundleID,
+                ccBundleID: ccBundleID,
+                pidToBundleID: { pid in
+                    NSRunningApplication(processIdentifier: pid)?.bundleIdentifier
+                },
+                bundleIDToPID: { bundleID in
+                    NSRunningApplication
+                        .runningApplications(withBundleIdentifier: bundleID)
+                        .first?
+                        .processIdentifier
+                }
+            )
+            for resolution in resolutions {
+                SourcePIDCache.diagLog.info(
+                    "SourcePIDCache marker-pair resolution: windowID=\(resolution.iconWindowID) → PID \(resolution.resolvedPID) via marker windowID=\(resolution.markerWindowID) (title=\(resolution.markerTitle))"
+                )
+                state.withLock { $0.pids[resolution.iconWindowID] = resolution.resolvedPID }
+                unresolvedWindows.remove(resolution.iconWindowID)
+            }
+        }
+
         let finalPID = state.withLock { $0.pids[window.windowID] }
         SourcePIDCache.diagLog.debug("SourcePIDCache.pid: batch resolution finished. Found \(totalMatchesFound) matches. Requested windowID \(window.windowID) -> PID \(finalPID.map { "\($0)" } ?? "nil") (checked \(appsChecked) apps, \(appsWithBar) with extras bar, \(totalChildrenChecked) children)")
 
+        // Diagnostic dump for unresolved windows.
+        //
+        // When at least one window remains unresolved after the batch
+        // loop, log enough state to determine which of three failure
+        // modes is hitting: (a) the suspect app is absent from
+        // NSWorkspace runningApplications, (b) the app is present but
+        // does not expose AXExtrasMenuBar (the per-app menu extras
+        // attribute is unset on macOS 26 for some widgets), or (c)
+        // the app exposes extras but their frames are more than 1pt
+        // off-center from the unresolved CG window bounds (a HiDPI,
+        // multi-display, or coord-system mismatch).
+        //
+        // Quiet path on normal cycles where every window resolves.
+        // The diagnostic re-walks AX children, which can be expensive,
+        // so it only fires when there is actual unresolved state.
+        if !unresolvedWindows.isEmpty {
+            SourcePIDCache.diagLog.debug(
+                "SourcePIDCache diag: \(unresolvedWindows.count) window(s) unresolved after batch, dumping details"
+            )
+
+            // Ad-hoc probe for specific bundles under investigation.
+            // Leave empty in normal builds; populate with bundle IDs
+            // when diagnosing a particular widget's resolution failure
+            // to see whether NSWorkspace sees it and whether it claims
+            // an extras menu bar of its own.
+            let probeBundleIDs: Set<String> = []
+            for bundleID in probeBundleIDs {
+                if let app = apps.first(where: { $0.bundleIdentifier == bundleID }) {
+                    SourcePIDCache.diagLog.debug(
+                        "SourcePIDCache diag probe: \(bundleID) PRESENT pid=\(app.processIdentifier) hasExtrasBar=\(app.hasExtrasMenuBar)"
+                    )
+                } else {
+                    SourcePIDCache.diagLog.debug(
+                        "SourcePIDCache diag probe: \(bundleID) ABSENT from runningApplications"
+                    )
+                }
+            }
+
+            let unresolvedWindowInfos = allWindows.filter { unresolvedWindows.contains($0.windowID) }
+            for window in unresolvedWindowInfos {
+                let target = window.bounds.center
+                var bestDistance = CGFloat.greatestFiniteMagnitude
+                var bestLabel = "(none)"
+                var bestFrame: CGRect?
+                for app in apps {
+                    guard let bar = app.getOrCreateExtrasMenuBar() else { continue }
+                    let children = AXHelpers.children(for: bar)
+                    for child in children {
+                        guard let frame = AXHelpers.frame(for: child) else { continue }
+                        let d = frame.center.distance(to: target)
+                        if d < bestDistance {
+                            bestDistance = d
+                            bestLabel = app.bundleIdentifier ?? app.localizedName ?? "pid=\(app.processIdentifier)"
+                            bestFrame = frame
+                        }
+                    }
+                }
+                let cgOwner = window.owningApplication.map { app in
+                    "\(app.bundleIdentifier ?? app.localizedName ?? "?"):pid=\(app.processIdentifier)"
+                } ?? "nil"
+                SourcePIDCache.diagLog.debug(
+                    "SourcePIDCache diag unresolved: windowID=\(window.windowID) title=\(window.title ?? "nil") bounds=\(window.bounds) center=\(target) | cgOwner=\(cgOwner) ownerName=\(window.ownerName ?? "nil") | closestAXFrame=\(bestFrame.map { "\($0)" } ?? "nil") in app=\(bestLabel) distance=\(bestDistance)"
+                )
+            }
+
+            for app in apps {
+                guard let bar = app.getOrCreateExtrasMenuBar() else { continue }
+                let children = AXHelpers.children(for: bar)
+                let frames = children.compactMap { AXHelpers.frame(for: $0) }
+                guard !frames.isEmpty else { continue }
+                let label = app.bundleIdentifier ?? app.localizedName ?? "pid=\(app.processIdentifier)"
+                SourcePIDCache.diagLog.debug(
+                    "SourcePIDCache diag app=\(label) extrasBar children=\(children.count) frames=\(frames.map { "(x=\($0.minX),y=\($0.minY),w=\($0.width),h=\($0.height))" }.joined(separator: " "))"
+                )
+            }
+        }
+
         return finalPID
     }
 }
@@ -8,6 +8,10 @@
 
 import Foundation
 
+#if DEBUG
+DiagnosticLogger.shared.isEnabled = true
+#endif
+
 SourcePIDCache.shared.start()
 Listener.shared.activate()
 
 
@@ -128,33 +128,55 @@ final class DiagnosticLogger: @unchecked Sendable {
         let fileName = "thaw_\(fileNameFormatter.string(from: Date())).log"
         let fileURL = dir.appendingPathComponent(fileName)
 
-        FileManager.default.createFile(atPath: fileURL.path, contents: nil)
-
-        do {
-            let handle = try FileHandle(forWritingTo: fileURL)
-            handle.seekToEndOfFile()
-            fileHandleLock.withLock { $0 = handle }
-            currentLogFileLock.withLock { $0 = fileURL }
-
-            // Write header
-            let version = Bundle.main.infoDictionary?["CFBundleShortVersionString"] as? String ?? "unknown"
-            let build = Bundle.main.infoDictionary?["CFBundleVersion"] as? String ?? "unknown"
-            let header = """
-            ========================================
-            Thaw Diagnostic Log
-            Started: \(timestampFormatter.string(from: Date()))
-            Version: \(version) (\(build))
-            macOS: \(ProcessInfo.processInfo.operatingSystemVersionString)
-            ========================================\n\n
-            """
-            if let data = header.data(using: .utf8) {
-                handle.write(data)
-            }
-
-            osLog.info("Diagnostic logging started: \(fileURL.path, privacy: .public)")
-        } catch {
-            osLog.error("Failed to open log file at \(fileURL.path): \(error)")
+        // Open with O_APPEND so the main app and the XPC service
+        // can safely write to the same file. Both processes call
+        // openLogFile during startup, often within the same second,
+        // so they land on the same filename. FileManager.createFile
+        // and FileHandle(forWritingTo:) would truncate an existing
+        // file and the two processes' per-fd offsets would race
+        // against each other on the same byte range. POSIX open(2)
+        // with O_APPEND tells the kernel to atomically position
+        // each write at end-of-file, which is atomic between
+        // processes for writes smaller than PIPE_BUF on local
+        // filesystems; O_CREAT creates the file if absent without
+        // touching an existing one. Swift's FileHandle initializers
+        // do not expose these flags, hence the POSIX call.
+        let fd = open(fileURL.path, O_WRONLY | O_APPEND | O_CREAT, 0o644)
+        guard fd >= 0 else {
+            osLog.error("Failed to open log file at \(fileURL.path): errno \(errno)")
+            return
         }
+        let handle = FileHandle(fileDescriptor: fd, closeOnDealloc: true)
+        fileHandleLock.withLock { $0 = handle }
+        currentLogFileLock.withLock { $0 = fileURL }
+
+        // Each process writes its own header into the shared file.
+        // The Process line distinguishes them; chronological order
+        // is preserved by the per-line timestamps.
+        let version = Bundle.main.infoDictionary?["CFBundleShortVersionString"] as? String ?? "unknown"
+        let build = Bundle.main.infoDictionary?["CFBundleVersion"] as? String ?? "unknown"
+        // GitCommitSHA is stamped into Info.plist when run as a
+        // build phase. Defaults to "unknown" when the phase has
+        // not been wired up, which is the only signal users need
+        // to tell whether a given binary carries the expected
+        // commit. Format is the short SHA (git rev-parse --short HEAD)
+        // with a "-dirty" suffix when the working tree was not clean
+        // at build time.
+        let sha = Bundle.main.infoDictionary?["GitCommitSHA"] as? String ?? "unknown"
+        let header = """
+        ========================================
+        Thaw Diagnostic Log
+        Started: \(timestampFormatter.string(from: Date()))
+        Process: \(ProcessInfo.processInfo.processName)
+        Version: \(version) (\(build)) commit \(sha)
+        macOS: \(ProcessInfo.processInfo.operatingSystemVersionString)
+        ========================================\n\n
+        """
+        if let data = header.data(using: .utf8) {
+            handle.write(data)
+        }
+
+        osLog.info("Diagnostic logging started: \(fileURL.path, privacy: .public)")
 
         // Clean up old log files (keep last 5)
         cleanupOldLogFiles(in: dir, keepCount: 5)