@lattices/cli 0.4.14 → 0.6.0

package/apps/mac/Tests/StageJoinTests.swift

@@ -1,313 +0,0 @@
-import XCTest
-import CoreGraphics
-import AppKit
-
-/// Experiments: can we programmatically create a new stage by joining windows?
-///
-/// Stage Manager groups windows into stages. When a user drags a window from
-/// the strip onto the center stage, it joins that stage. Can we replicate this
-/// via AX, CGS, or simulated events?
-final class StageJoinTests: XCTestCase {
-
-    // MARK: - Helpers
-
-    struct LiveWindow {
-        let wid: UInt32
-        let app: String
-        let pid: Int32
-        let title: String
-        let bounds: CGRect
-        let isOnScreen: Bool
-    }
-
-    /// Get all real app windows (layer 0, >= 50x50)
-    func getRealWindows() -> [LiveWindow] {
-        guard let list = CGWindowListCopyWindowInfo(
-            [.optionAll, .excludeDesktopElements],
-            kCGNullWindowID
-        ) as? [[String: Any]] else { return [] }
-
-        let skip: Set<String> = [
-            "Window Server", "Dock", "Control Center", "SystemUIServer",
-            "Notification Center", "Spotlight", "WindowManager",
-            "Lattices",
-        ]
-
-        return list.compactMap { info in
-            guard let wid = info[kCGWindowNumber as String] as? UInt32,
-                  let owner = info[kCGWindowOwnerName as String] as? String,
-                  let pid = info[kCGWindowOwnerPID as String] as? Int32,
-                  let boundsDict = info[kCGWindowBounds as String] as? NSDictionary
-            else { return nil }
-
-            var rect = CGRect.zero
-            guard CGRectMakeWithDictionaryRepresentation(boundsDict, &rect) else { return nil }
-            let title = info[kCGWindowName as String] as? String ?? ""
-            let layer = info[kCGWindowLayer as String] as? Int ?? 0
-            let isOnScreen = info[kCGWindowIsOnscreen as String] as? Bool ?? false
-
-            guard layer == 0, rect.width >= 50, rect.height >= 50 else { return nil }
-            guard !skip.contains(owner) else { return nil }
-
-            return LiveWindow(wid: wid, app: owner, pid: pid, title: title,
-                            bounds: rect, isOnScreen: isOnScreen)
-        }
-    }
-
-    /// Get AX window elements for a PID
-    func getAXWindows(pid: Int32) -> [AXUIElement] {
-        let app = AXUIElementCreateApplication(pid)
-        var ref: CFTypeRef?
-        guard AXUIElementCopyAttributeValue(app, kAXWindowsAttribute as CFString, &ref) == .success,
-              let windows = ref as? [AXUIElement] else { return [] }
-        return windows
-    }
-
-    /// Move an AX window to a position
-    func moveAXWindow(_ axWin: AXUIElement, to point: CGPoint) -> Bool {
-        var p = point
-        let posValue = AXValueCreate(.cgPoint, &p)!
-        return AXUIElementSetAttributeValue(axWin, kAXPositionAttribute as CFString, posValue) == .success
-    }
-
-    /// Resize an AX window
-    func resizeAXWindow(_ axWin: AXUIElement, to size: CGSize) -> Bool {
-        var s = size
-        let sizeValue = AXValueCreate(.cgSize, &s)!
-        return AXUIElementSetAttributeValue(axWin, kAXSizeAttribute as CFString, sizeValue) == .success
-    }
-
-    /// Raise an AX window
-    func raiseAXWindow(_ axWin: AXUIElement) -> Bool {
-        AXUIElementPerformAction(axWin, kAXRaiseAction as CFString) == .success
-    }
-
-    /// Snapshot which windows are onscreen (active stage)
-    func activeStageWids() -> Set<UInt32> {
-        Set(getRealWindows().filter { $0.isOnScreen && $0.bounds.width > 250 }.map(\.wid))
-    }
-
-    /// Print stage state
-    func printStageState(label: String) {
-        let windows = getRealWindows()
-        let active = windows.filter { $0.isOnScreen && $0.bounds.width > 250 }
-        let strip = windows.filter { $0.isOnScreen && $0.bounds.width < 250 && $0.bounds.origin.x < 220 }
-        print("\n[\(label)]")
-        print("  Active stage: \(active.map { "\($0.app)(\($0.wid))" }.joined(separator: ", "))")
-        print("  Strip: \(Set(strip.map(\.app)).sorted().joined(separator: ", "))")
-    }
-
-    // MARK: - Approach 1: Activate two apps rapidly
-
-    func testJoinByActivation() throws {
-        let smEnabled = UserDefaults(suiteName: "com.apple.WindowManager")?.bool(forKey: "GloballyEnabled") ?? false
-        try XCTSkipUnless(smEnabled, "Stage Manager is OFF")
-
-        let windows = getRealWindows()
-
-        // Find two different apps that are NOT in the current stage
-        let offscreenApps = Dictionary(grouping: windows.filter { !$0.isOnScreen && $0.bounds.width > 250 },
-                                       by: \.app)
-        let candidates = offscreenApps.keys.sorted()
-        guard candidates.count >= 2 else {
-            print("Need at least 2 offscreen apps, found: \(candidates)")
-            return
-        }
-
-        let appA = candidates[0]
-        let appB = candidates[1]
-        let winA = offscreenApps[appA]!.first!
-        let winB = offscreenApps[appB]!.first!
-
-        print("Attempting to join \(appA) and \(appB) by rapid activation")
-        printStageState(label: "BEFORE")
-
-        // Activate app A
-        let nsAppA = NSRunningApplication(processIdentifier: winA.pid)
-        nsAppA?.activate()
-        Thread.sleep(forTimeInterval: 0.3)
-
-        printStageState(label: "After activating \(appA)")
-
-        // Now immediately activate app B — does SM merge them?
-        let nsAppB = NSRunningApplication(processIdentifier: winB.pid)
-        nsAppB?.activate()
-        Thread.sleep(forTimeInterval: 0.5)
-
-        printStageState(label: "After activating \(appB)")
-
-        // Check: are both apps in the active stage?
-        let finalActive = getRealWindows().filter { $0.isOnScreen && $0.bounds.width > 250 }
-        let activeApps = Set(finalActive.map(\.app))
-        let joined = activeApps.contains(appA) && activeApps.contains(appB)
-        print("\nResult: both apps in active stage? \(joined)")
-        print("Active apps: \(activeApps.sorted())")
-    }
-
-    // MARK: - Approach 2: Move offscreen window into active stage area via AX
-
-    func testJoinByAXMove() throws {
-        let smEnabled = UserDefaults(suiteName: "com.apple.WindowManager")?.bool(forKey: "GloballyEnabled") ?? false
-        try XCTSkipUnless(smEnabled, "Stage Manager is OFF")
-
-        let windows = getRealWindows()
-
-        // Find the active stage center
-        let activeWindows = windows.filter { $0.isOnScreen && $0.bounds.width > 250 }
-        guard let anchor = activeWindows.first else {
-            print("No active stage window found")
-            return
-        }
-
-        // Find an offscreen app to pull in
-        let offscreen = windows.filter { !$0.isOnScreen && $0.bounds.width > 250 && $0.app != anchor.app }
-        guard let target = offscreen.first else {
-            print("No offscreen window to test with")
-            return
-        }
-
-        print("Attempting to join \(target.app)[\(target.wid)] into \(anchor.app)'s stage via AX move")
-        printStageState(label: "BEFORE")
-
-        // Get AX window for target
-        let axWindows = getAXWindows(pid: target.pid)
-        guard let axWin = axWindows.first else {
-            print("Could not get AX window for \(target.app)")
-            return
-        }
-
-        // Move it right next to the anchor window
-        let destPoint = CGPoint(x: anchor.bounds.origin.x + 50, y: anchor.bounds.origin.y + 50)
-        let moved = moveAXWindow(axWin, to: destPoint)
-        print("AX move result: \(moved)")
-
-        // Raise it
-        let raised = raiseAXWindow(axWin)
-        print("AX raise result: \(raised)")
-
-        Thread.sleep(forTimeInterval: 0.5)
-        printStageState(label: "After AX move + raise")
-
-        // Did it join the stage?
-        let finalActive = getRealWindows().filter { $0.isOnScreen && $0.bounds.width > 250 }
-        let activeApps = Set(finalActive.map(\.app))
-        let joined = activeApps.contains(target.app) && activeApps.contains(anchor.app)
-        print("\nResult: \(target.app) joined \(anchor.app)'s stage? \(joined)")
-        print("Active apps: \(activeApps.sorted())")
-    }
-
-    // MARK: - Approach 3: AX move + activate target app (without switching stage)
-
-    func testJoinByMoveAndActivate() throws {
-        let smEnabled = UserDefaults(suiteName: "com.apple.WindowManager")?.bool(forKey: "GloballyEnabled") ?? false
-        try XCTSkipUnless(smEnabled, "Stage Manager is OFF")
-
-        let windows = getRealWindows()
-        let activeWindows = windows.filter { $0.isOnScreen && $0.bounds.width > 250 }
-        guard let anchor = activeWindows.first else { return }
-
-        let offscreen = windows.filter { !$0.isOnScreen && $0.bounds.width > 250 && $0.app != anchor.app }
-        guard let target = offscreen.first else { return }
-
-        print("Attempting: move \(target.app) via AX, then activate it")
-        printStageState(label: "BEFORE")
-
-        // Step 1: Move target window into center area via AX
-        let axWindows = getAXWindows(pid: target.pid)
-        guard let axWin = axWindows.first else { return }
-
-        let dest = CGPoint(x: anchor.bounds.midX, y: anchor.bounds.midY)
-        _ = moveAXWindow(axWin, to: dest)
-        _ = resizeAXWindow(axWin, to: CGSize(width: 800, height: 600))
-
-        Thread.sleep(forTimeInterval: 0.2)
-
-        // Step 2: Activate anchor app first (keep it in stage)
-        NSRunningApplication(processIdentifier: anchor.pid)?.activate()
-        Thread.sleep(forTimeInterval: 0.1)
-
-        // Step 3: Raise the target window (without activate, to avoid stage switch)
-        _ = raiseAXWindow(axWin)
-
-        Thread.sleep(forTimeInterval: 0.5)
-        printStageState(label: "After move + raise (no activate)")
-
-        // Step 4: Now try activating both
-        NSRunningApplication(processIdentifier: anchor.pid)?.activate()
-        Thread.sleep(forTimeInterval: 0.1)
-        // Use AX to set focused on target window
-        AXUIElementSetAttributeValue(axWin, kAXFocusedAttribute as CFString, kCFBooleanTrue)
-        AXUIElementSetAttributeValue(axWin, kAXMainAttribute as CFString, kCFBooleanTrue)
-
-        Thread.sleep(forTimeInterval: 0.5)
-        printStageState(label: "After setting focus+main on target")
-
-        let finalActive = getRealWindows().filter { $0.isOnScreen && $0.bounds.width > 250 }
-        let activeApps = Set(finalActive.map(\.app))
-        let joined = activeApps.contains(target.app) && activeApps.contains(anchor.app)
-        print("\nResult: joined? \(joined) — active apps: \(activeApps.sorted())")
-    }
-
-    // MARK: - Approach 4: CGS space manipulation — put both windows on same space
-
-    func testJoinBySameSpace() throws {
-        let smEnabled = UserDefaults(suiteName: "com.apple.WindowManager")?.bool(forKey: "GloballyEnabled") ?? false
-        try XCTSkipUnless(smEnabled, "Stage Manager is OFF")
-
-        // Load CGS functions
-        typealias CGSConnectionID = UInt32
-        typealias CGSMainConnectionIDFunc = @convention(c) () -> CGSConnectionID
-        typealias CGSAddWindowsToSpacesFunc = @convention(c) (CGSConnectionID, CFArray, CFArray) -> Void
-        typealias CGSGetActiveSpaceFunc = @convention(c) (CGSConnectionID) -> Int
-
-        guard let handle = dlopen("/System/Library/PrivateFrameworks/SkyLight.framework/SkyLight", RTLD_LAZY),
-              let mainConnSym = dlsym(handle, "CGSMainConnectionID"),
-              let addToSpacesSym = dlsym(handle, "CGSAddWindowsToSpaces"),
-              let activeSpaceSym = dlsym(handle, "CGSGetActiveSpace")
-        else {
-            print("Could not load SkyLight functions")
-            return
-        }
-
-        let CGSMainConnectionID = unsafeBitCast(mainConnSym, to: CGSMainConnectionIDFunc.self)
-        let CGSAddWindowsToSpaces = unsafeBitCast(addToSpacesSym, to: CGSAddWindowsToSpacesFunc.self)
-        let CGSGetActiveSpace = unsafeBitCast(activeSpaceSym, to: CGSGetActiveSpaceFunc.self)
-
-        let cid = CGSMainConnectionID()
-        let activeSpace = CGSGetActiveSpace(cid)
-        print("Connection: \(cid), Active space: \(activeSpace)")
-
-        let windows = getRealWindows()
-        let activeWindows = windows.filter { $0.isOnScreen && $0.bounds.width > 250 }
-        guard let anchor = activeWindows.first else { return }
-
-        let offscreen = windows.filter { !$0.isOnScreen && $0.bounds.width > 250 && $0.app != anchor.app }
-        guard let target = offscreen.first else { return }
-
-        print("Attempting: add \(target.app)[\(target.wid)] to space \(activeSpace) via CGSAddWindowsToSpaces")
-        printStageState(label: "BEFORE")
-
-        // Add target window to active space
-        let windowIDs = [target.wid] as CFArray
-        let spaceIDs = [activeSpace] as CFArray
-        CGSAddWindowsToSpaces(cid, windowIDs, spaceIDs)
-
-        Thread.sleep(forTimeInterval: 0.5)
-        printStageState(label: "After CGSAddWindowsToSpaces")
-
-        // Also try raising it via AX
-        let axWindows = getAXWindows(pid: target.pid)
-        if let axWin = axWindows.first {
-            _ = raiseAXWindow(axWin)
-            Thread.sleep(forTimeInterval: 0.3)
-            printStageState(label: "After raise")
-        }
-
-        let finalActive = getRealWindows().filter { $0.isOnScreen && $0.bounds.width > 250 }
-        let activeApps = Set(finalActive.map(\.app))
-        let joined = activeApps.contains(target.app) && activeApps.contains(anchor.app)
-        print("\nResult: joined? \(joined) — active apps: \(activeApps.sorted())")
-
-        dlclose(handle)
-    }
-}

package/apps/mac/Tests/StageManagerTests.swift

@@ -1,280 +0,0 @@
-import XCTest
-import CoreGraphics
-import AppKit
-
-final class StageManagerTests: XCTestCase {
-
-    // MARK: - Detection
-
-    func testStageManagerEnabled() {
-        let defaults = UserDefaults(suiteName: "com.apple.WindowManager")
-        let enabled = defaults?.bool(forKey: "GloballyEnabled") ?? false
-        print("Stage Manager enabled: \(enabled)")
-
-        // Also read all known keys
-        let keys = [
-            "GloballyEnabled",
-            "GloballyEnabledEver",
-            "AutoHide",
-            "AppWindowGroupingBehavior",
-            "HideDesktop",
-            "StageManagerHideWidgets",
-            "EnableStandardClickToShowDesktop",
-            "EnableTiledWindowMargins",
-            "EnableTilingByEdgeDrag",
-            "EnableTopTilingByEdgeDrag",
-            "StandardHideDesktopIcons",
-            "StandardHideWidgets",
-        ]
-
-        print("\n=== com.apple.WindowManager preferences ===")
-        for key in keys {
-            let val = defaults?.object(forKey: key)
-            print("  \(key): \(val ?? "nil" as Any)")
-        }
-
-        // Not asserting true/false — just verifying we can read the domain
-        XCTAssertNotNil(defaults, "Should be able to open com.apple.WindowManager domain")
-    }
-
-    // MARK: - Window Classification
-
-    func testClassifyWindows() {
-        let smEnabled = UserDefaults(suiteName: "com.apple.WindowManager")?.bool(forKey: "GloballyEnabled") ?? false
-
-        guard smEnabled else {
-            print("Stage Manager is OFF — skipping window classification")
-            return
-        }
-
-        guard let windowList = CGWindowListCopyWindowInfo(
-            [.optionAll, .excludeDesktopElements],
-            kCGNullWindowID
-        ) as? [[String: Any]] else {
-            XCTFail("Could not get window list")
-            return
-        }
-
-        var activeStage: [(wid: UInt32, app: String, title: String, bounds: CGRect)] = []
-        var stripThumbnails: [(wid: UInt32, app: String, title: String, bounds: CGRect)] = []
-        var hiddenStage: [(wid: UInt32, app: String, title: String, bounds: CGRect)] = []
-        var gestureOverlays: [(wid: UInt32, bounds: CGRect)] = []
-        var appIcons: [(wid: UInt32, bounds: CGRect)] = []
-
-        let mainScreen = NSScreen.main!
-        let stripMaxX: CGFloat = 220 // strip occupies roughly left 220px
-        let thumbnailMaxSize: CGFloat = 250
-
-        for info in windowList {
-            guard let wid = info[kCGWindowNumber as String] as? UInt32,
-                  let owner = info[kCGWindowOwnerName as String] as? String,
-                  let boundsDict = info[kCGWindowBounds as String] as? NSDictionary
-            else { continue }
-
-            var rect = CGRect.zero
-            guard CGRectMakeWithDictionaryRepresentation(boundsDict, &rect) else { continue }
-
-            let title = info[kCGWindowName as String] as? String ?? ""
-            let layer = info[kCGWindowLayer as String] as? Int ?? 0
-            let isOnScreen = info[kCGWindowIsOnscreen as String] as? Bool ?? false
-
-            guard layer == 0 else { continue }
-            guard rect.width >= 10, rect.height >= 10 else { continue }
-
-            // WindowManager process windows (GBOs and app icons)
-            if owner == "WindowManager" {
-                if title == "Gesture Blocking Overlay" || title.isEmpty {
-                    if rect.width <= 80 && rect.height <= 80 {
-                        appIcons.append((wid: wid, bounds: rect))
-                    } else {
-                        gestureOverlays.append((wid: wid, bounds: rect))
-                    }
-                }
-                continue
-            }
-
-            // Skip non-app processes
-            let skipOwners: Set<String> = [
-                "Window Server", "Dock", "Control Center", "SystemUIServer",
-                "Notification Center", "Spotlight",
-            ]
-            if skipOwners.contains(owner) { continue }
-
-            if !isOnScreen {
-                // Hidden in another stage
-                hiddenStage.append((wid: wid, app: owner, title: title, bounds: rect))
-            } else if rect.width < thumbnailMaxSize && rect.height < thumbnailMaxSize
-                        && rect.origin.x < stripMaxX {
-                // Strip thumbnail
-                stripThumbnails.append((wid: wid, app: owner, title: title, bounds: rect))
-            } else if rect.width >= 50 && rect.height >= 50 {
-                // Active stage window
-                activeStage.append((wid: wid, app: owner, title: title, bounds: rect))
-            }
-        }
-
-        print("\n=== Stage Manager Window Classification ===")
-        print("Screen: \(Int(mainScreen.frame.width))x\(Int(mainScreen.frame.height))")
-
-        print("\n--- Active Stage (\(activeStage.count) windows) ---")
-        for w in activeStage {
-            print("  [\(w.wid)] \(w.app) — \"\(w.title)\"")
-            print("         bounds: \(Int(w.bounds.origin.x)),\(Int(w.bounds.origin.y)) \(Int(w.bounds.width))x\(Int(w.bounds.height))")
-        }
-
-        print("\n--- Strip Thumbnails (\(stripThumbnails.count) windows) ---")
-        for w in stripThumbnails {
-            print("  [\(w.wid)] \(w.app) — \"\(w.title)\"")
-            print("         bounds: \(Int(w.bounds.origin.x)),\(Int(w.bounds.origin.y)) \(Int(w.bounds.width))x\(Int(w.bounds.height))")
-        }
-
-        print("\n--- Hidden in Other Stages (\(hiddenStage.count) windows) ---")
-        for w in hiddenStage {
-            print("  [\(w.wid)] \(w.app) — \"\(w.title)\"")
-            print("         bounds: \(Int(w.bounds.origin.x)),\(Int(w.bounds.origin.y)) \(Int(w.bounds.width))x\(Int(w.bounds.height))")
-        }
-
-        print("\n--- Gesture Blocking Overlays (\(gestureOverlays.count)) ---")
-        for g in gestureOverlays {
-            print("  [\(g.wid)] bounds: \(Int(g.bounds.origin.x)),\(Int(g.bounds.origin.y)) \(Int(g.bounds.width))x\(Int(g.bounds.height))")
-        }
-
-        print("\n--- App Icons in Strip (\(appIcons.count)) ---")
-        for a in appIcons {
-            print("  [\(a.wid)] bounds: \(Int(a.bounds.origin.x)),\(Int(a.bounds.origin.y)) \(Int(a.bounds.width))x\(Int(a.bounds.height))")
-        }
-
-        // Try to correlate GBOs to strip thumbnails by proximity
-        print("\n--- GBO ↔ Thumbnail Correlation ---")
-        for gbo in gestureOverlays {
-            let gboCenter = CGPoint(x: gbo.bounds.midX, y: gbo.bounds.midY)
-            var closest: (wid: UInt32, app: String, dist: CGFloat) = (0, "", .greatestFiniteMagnitude)
-            for thumb in stripThumbnails {
-                let thumbCenter = CGPoint(x: thumb.bounds.midX, y: thumb.bounds.midY)
-                let dist = hypot(gboCenter.x - thumbCenter.x, gboCenter.y - thumbCenter.y)
-                if dist < closest.dist {
-                    closest = (thumb.wid, thumb.app, dist)
-                }
-            }
-            if closest.dist < 300 {
-                print("  GBO [\(gbo.wid)] → Thumbnail [\(closest.wid)] \(closest.app) (dist: \(Int(closest.dist))px)")
-            } else {
-                print("  GBO [\(gbo.wid)] → no match (closest: \(Int(closest.dist))px)")
-            }
-        }
-    }
-
-    // MARK: - Stage Grouping Heuristic
-
-    func testInferStageGroups() {
-        let smEnabled = UserDefaults(suiteName: "com.apple.WindowManager")?.bool(forKey: "GloballyEnabled") ?? false
-
-        guard smEnabled else {
-            print("Stage Manager is OFF — skipping stage grouping")
-            return
-        }
-
-        guard let windowList = CGWindowListCopyWindowInfo(
-            [.optionAll, .excludeDesktopElements],
-            kCGNullWindowID
-        ) as? [[String: Any]] else {
-            XCTFail("Could not get window list")
-            return
-        }
-
-        // Stage Manager groups windows together. When "All at Once" is selected,
-        // all windows from one app move together. We can infer groups by looking
-        // at which offscreen windows share similar thumbnail strip positions.
-
-        struct WinInfo {
-            let wid: UInt32
-            let app: String
-            let title: String
-            let bounds: CGRect
-            let isOnScreen: Bool
-            let pid: Int32
-        }
-
-        var appWindows: [String: [WinInfo]] = [:]
-        let skipOwners: Set<String> = [
-            "Window Server", "Dock", "Control Center", "SystemUIServer",
-            "Notification Center", "Spotlight", "WindowManager",
-        ]
-
-        for info in windowList {
-            guard let wid = info[kCGWindowNumber as String] as? UInt32,
-                  let owner = info[kCGWindowOwnerName as String] as? String,
-                  let pid = info[kCGWindowOwnerPID as String] as? Int32,
-                  let boundsDict = info[kCGWindowBounds as String] as? NSDictionary
-            else { continue }
-
-            var rect = CGRect.zero
-            guard CGRectMakeWithDictionaryRepresentation(boundsDict, &rect) else { continue }
-            let title = info[kCGWindowName as String] as? String ?? ""
-            let layer = info[kCGWindowLayer as String] as? Int ?? 0
-            let isOnScreen = info[kCGWindowIsOnscreen as String] as? Bool ?? false
-
-            guard layer == 0, rect.width >= 50, rect.height >= 50 else { continue }
-            guard !skipOwners.contains(owner) else { continue }
-
-            let w = WinInfo(wid: wid, app: owner, title: title, bounds: rect,
-                           isOnScreen: isOnScreen, pid: pid)
-            appWindows[owner, default: []].append(w)
-        }
-
-        // Classify into stages
-        var currentStageApps: Set<String> = []
-        var otherStageApps: Set<String> = []
-
-        for (app, wins) in appWindows {
-            let hasOnScreen = wins.contains { $0.isOnScreen && $0.bounds.width > 250 }
-            if hasOnScreen {
-                currentStageApps.insert(app)
-            } else {
-                otherStageApps.insert(app)
-            }
-        }
-
-        print("\n=== Inferred Stage Groups ===")
-        print("\n🟢 Current Stage:")
-        for app in currentStageApps.sorted() {
-            let wins = appWindows[app]!.filter { $0.isOnScreen }
-            print("  \(app) (\(wins.count) window\(wins.count == 1 ? "" : "s"))")
-            for w in wins {
-                print("    [\(w.wid)] \"\(w.title)\" — \(Int(w.bounds.width))x\(Int(w.bounds.height))")
-            }
-        }
-
-        print("\n🔵 Other Stages:")
-        for app in otherStageApps.sorted() {
-            let wins = appWindows[app]!
-            let onScreen = wins.filter { $0.isOnScreen }
-            let offScreen = wins.filter { !$0.isOnScreen }
-            print("  \(app) (\(offScreen.count) hidden, \(onScreen.count) thumbnail)")
-            for w in offScreen.prefix(3) {
-                print("    [\(w.wid)] \"\(w.title)\" — \(Int(w.bounds.width))x\(Int(w.bounds.height))")
-            }
-            if offScreen.count > 3 { print("    ... and \(offScreen.count - 3) more") }
-        }
-    }
-
-    // MARK: - Preferences Change Detection
-
-    func testStageManagerPrefsObservation() {
-        // Test that we can observe preference changes via polling
-        let defaults = UserDefaults(suiteName: "com.apple.WindowManager")
-        let initial = defaults?.bool(forKey: "GloballyEnabled") ?? false
-        print("Initial Stage Manager state: \(initial)")
-
-        // Quick re-read to verify consistency
-        let reread = defaults?.bool(forKey: "GloballyEnabled") ?? false
-        XCTAssertEqual(initial, reread, "Preference should be stable across reads")
-
-        // Read AppWindowGroupingBehavior
-        let grouping = defaults?.integer(forKey: "AppWindowGroupingBehavior") ?? -1
-        print("AppWindowGroupingBehavior: \(grouping) (\(grouping == 0 ? "All at Once" : grouping == 1 ? "One at a Time" : "unknown"))")
-
-        let autoHide = defaults?.bool(forKey: "AutoHide") ?? false
-        print("AutoHide (strip): \(autoHide)")
-    }
-}