@lattices/cli 0.4.0 → 0.4.2

package/app/Sources/MouseFinder.swift

@@ -0,0 +1,222 @@
+import AppKit
+import CoreGraphics
+
+/// Locates the mouse cursor with an animated sonar pulse overlay.
+/// "Find" shows rings at the current cursor position.
+/// "Summon" warps the cursor to screen center (or a given point).
+final class MouseFinder {
+    static let shared = MouseFinder()
+
+    private var overlayWindows: [NSWindow] = []
+    private var dismissTimer: Timer?
+    private var animationTimer: Timer?
+    private var animationStart: CFTimeInterval = 0
+    private let animationDuration: CFTimeInterval = 1.5
+
+    // MARK: - Find (highlight current position)
+
+    func find() {
+        let pos = NSEvent.mouseLocation
+        showSonar(at: pos)
+    }
+
+    // MARK: - Summon (warp to center of the screen the mouse is on, or a specific point)
+
+    func summon(to point: CGPoint? = nil) {
+        let target: NSPoint
+        if let point {
+            target = point
+        } else {
+            let screen = mouseScreen()
+            let frame = screen.frame
+            target = NSPoint(x: frame.midX, y: frame.midY)
+        }
+
+        // CGWarpMouseCursorPosition uses top-left origin
+        let primaryHeight = NSScreen.screens.first?.frame.height ?? 0
+        let cgPoint = CGPoint(x: target.x, y: primaryHeight - target.y)
+        CGWarpMouseCursorPosition(cgPoint)
+        // Re-associate mouse with cursor position after warp
+        CGAssociateMouseAndMouseCursorPosition(1)
+
+        showSonar(at: target)
+    }
+
+    // MARK: - Sonar Animation
+
+    private func showSonar(at nsPoint: NSPoint) {
+        dismiss()
+
+        let screens = NSScreen.screens
+        guard !screens.isEmpty else { return }
+
+        let ringCount = 3
+        let maxRadius: CGFloat = 120
+        let totalSize = maxRadius * 2 + 20
+
+        for screen in screens {
+            // Only show on screens near the cursor
+            let extendedBounds = screen.frame.insetBy(dx: -maxRadius, dy: -maxRadius)
+            guard extendedBounds.contains(nsPoint) else { continue }
+
+            let windowFrame = NSRect(
+                x: nsPoint.x - totalSize / 2,
+                y: nsPoint.y - totalSize / 2,
+                width: totalSize,
+                height: totalSize
+            )
+
+            let window = NSWindow(
+                contentRect: windowFrame,
+                styleMask: .borderless,
+                backing: .buffered,
+                defer: false
+            )
+            window.isOpaque = false
+            window.backgroundColor = .clear
+            window.level = NSWindow.Level(rawValue: Int(CGWindowLevelForKey(.maximumWindow)))
+            window.hasShadow = false
+            window.ignoresMouseEvents = true
+            window.collectionBehavior = [.canJoinAllSpaces, .stationary]
+
+            let sonarView = SonarView(
+                frame: NSRect(origin: .zero, size: windowFrame.size),
+                ringCount: ringCount,
+                maxRadius: maxRadius
+            )
+            window.contentView = sonarView
+
+            window.alphaValue = 0
+            window.orderFrontRegardless()
+            overlayWindows.append(window)
+
+            // Fade in
+            NSAnimationContext.runAnimationGroup { ctx in
+                ctx.duration = 0.1
+                window.animator().alphaValue = 1.0
+            }
+        }
+
+        // Animate the rings expanding using CACurrentMediaTime for state
+        animationStart = CACurrentMediaTime()
+        let interval = 1.0 / 60.0
+
+        animationTimer = Timer.scheduledTimer(withTimeInterval: interval, repeats: true) { [weak self] timer in
+            guard let self else { timer.invalidate(); return }
+            let elapsed = CACurrentMediaTime() - self.animationStart
+            let progress = CGFloat(min(elapsed / self.animationDuration, 1.0))
+
+            for window in self.overlayWindows {
+                (window.contentView as? SonarView)?.progress = progress
+                window.contentView?.needsDisplay = true
+            }
+
+            if progress >= 1.0 {
+                timer.invalidate()
+                self.animationTimer = nil
+            }
+        }
+
+        // Auto-dismiss after animation + hold
+        dismissTimer = Timer.scheduledTimer(withTimeInterval: 2.5, repeats: false) { [weak self] _ in
+            self?.fadeOut()
+        }
+    }
+
+    private func fadeOut() {
+        let windows = overlayWindows
+        NSAnimationContext.runAnimationGroup({ ctx in
+            ctx.duration = 0.4
+            for window in windows {
+                window.animator().alphaValue = 0
+            }
+        }, completionHandler: { [weak self] in
+            self?.dismiss()
+        })
+    }
+
+    func dismiss() {
+        animationTimer?.invalidate()
+        animationTimer = nil
+        dismissTimer?.invalidate()
+        dismissTimer = nil
+        for window in overlayWindows {
+            window.orderOut(nil)
+        }
+        overlayWindows.removeAll()
+    }
+
+    private func mouseScreen() -> NSScreen {
+        let pos = NSEvent.mouseLocation
+        return NSScreen.screens.first(where: { $0.frame.contains(pos) }) ?? NSScreen.screens[0]
+    }
+}
+
+// MARK: - Sonar Ring View
+
+private class SonarView: NSView {
+    let ringCount: Int
+    let maxRadius: CGFloat
+    var progress: CGFloat = 0
+
+    init(frame: NSRect, ringCount: Int, maxRadius: CGFloat) {
+        self.ringCount = ringCount
+        self.maxRadius = maxRadius
+        super.init(frame: frame)
+    }
+
+    required init?(coder: NSCoder) { fatalError() }
+
+    override func draw(_ dirtyRect: NSRect) {
+        guard let ctx = NSGraphicsContext.current?.cgContext else { return }
+
+        let center = CGPoint(x: bounds.midX, y: bounds.midY)
+
+        // Draw rings from outermost to innermost
+        for i in 0..<ringCount {
+            let ringDelay = CGFloat(i) * 0.15
+            let denom = 1.0 - ringDelay * CGFloat(ringCount - 1) / CGFloat(ringCount)
+            let ringProgress = max(0, min(1, (progress - ringDelay) / denom))
+
+            guard ringProgress > 0 else { continue }
+
+            // Ease out cubic
+            let eased = 1.0 - pow(1.0 - ringProgress, 3)
+
+            let radius = maxRadius * eased
+            let alpha = (1.0 - eased) * 0.8
+
+            // Ring stroke
+            ctx.setStrokeColor(NSColor(calibratedRed: 0.4, green: 0.7, blue: 1.0, alpha: alpha).cgColor)
+            ctx.setLineWidth(2.5 - CGFloat(i) * 0.5)
+            ctx.addEllipse(in: CGRect(
+                x: center.x - radius,
+                y: center.y - radius,
+                width: radius * 2,
+                height: radius * 2
+            ))
+            ctx.strokePath()
+        }
+
+        // Center dot — stays visible
+        let dotRadius: CGFloat = 6
+        let dotAlpha = max(0.3, 1.0 - progress * 0.5)
+        ctx.setFillColor(NSColor(calibratedRed: 0.4, green: 0.7, blue: 1.0, alpha: dotAlpha).cgColor)
+        ctx.fillEllipse(in: CGRect(
+            x: center.x - dotRadius,
+            y: center.y - dotRadius,
+            width: dotRadius * 2,
+            height: dotRadius * 2
+        ))
+
+        // Outer glow on center dot
+        ctx.setFillColor(NSColor(calibratedRed: 0.4, green: 0.7, blue: 1.0, alpha: dotAlpha * 0.2).cgColor)
+        let glowRadius: CGFloat = 12
+        ctx.fillEllipse(in: CGRect(
+            x: center.x - glowRadius,
+            y: center.y - glowRadius,
+            width: glowRadius * 2,
+            height: glowRadius * 2
+        ))
+    }
+}

package/app/Sources/ProjectScanner.swift

@@ -15,53 +15,66 @@ class ProjectScanner: ObservableObject {
         self.scanRoot = root
     }
 
+    private static let scanQueue = DispatchQueue(label: "com.lattices.project-scanner", qos: .userInitiated)
+    private var scanInFlight = false
+
     func scan() {
-        let diag = DiagnosticLog.shared
+        guard !scanInFlight else { return }
+        scanInFlight = true
+        let root = scanRoot
+
+        Self.scanQueue.async { [weak self] in
+            guard let self else { return }
+            let diag = DiagnosticLog.shared
+
+            // Use find to locate all .lattices.json files — no manual directory walking
+            let tFind = diag.startTimed("ProjectScanner: find .lattices.json")
+            let task = Process()
+            task.executableURL = URL(fileURLWithPath: "/usr/bin/find")
+            task.arguments = [root, "-name", ".lattices.json", "-maxdepth", "3", "-not", "-path", "*/.git/*", "-not", "-path", "*/node_modules/*"]
+            let pipe = Pipe()
+            task.standardOutput = pipe
+            task.standardError = FileHandle.nullDevice
+            try? task.run()
+            task.waitUntilExit()
+            diag.finish(tFind)
+
+            let data = pipe.fileHandleForReading.readDataToEndOfFile()
+            let output = String(data: data, encoding: .utf8) ?? ""
+            let configPaths = output.split(separator: "\n").map(String.init).filter { !$0.isEmpty }
+
+            let tParse = diag.startTimed("ProjectScanner: parse \(configPaths.count) configs")
+            var found: [Project] = []
+
+            for configPath in configPaths.sorted() {
+                let projectPath = (configPath as NSString).deletingLastPathComponent
+                let name = (projectPath as NSString).lastPathComponent
+                let (devCmd, pm) = self.detectDevCommand(at: projectPath)
+                let paneInfo = self.readPaneInfo(at: configPath)
+
+                var project = Project(
+                    id: projectPath,
+                    path: projectPath,
+                    name: name,
+                    devCommand: devCmd,
+                    packageManager: pm,
+                    hasConfig: true,
+                    paneCount: paneInfo.count,
+                    paneNames: paneInfo.names,
+                    paneSummary: paneInfo.summary,
+                    isRunning: false
+                )
+                project.isRunning = self.isSessionRunning(project.sessionName)
+                found.append(project)
+            }
+            diag.finish(tParse)
 
-        // Use find to locate all .lattices.json files — no manual directory walking
-        let tFind = diag.startTimed("ProjectScanner: find .lattices.json")
-        let task = Process()
-        task.executableURL = URL(fileURLWithPath: "/usr/bin/find")
-        task.arguments = [scanRoot, "-name", ".lattices.json", "-maxdepth", "3", "-not", "-path", "*/.git/*", "-not", "-path", "*/node_modules/*"]
-        let pipe = Pipe()
-        task.standardOutput = pipe
-        task.standardError = FileHandle.nullDevice
-        try? task.run()
-        task.waitUntilExit()
-        diag.finish(tFind)
-
-        let data = pipe.fileHandleForReading.readDataToEndOfFile()
-        let output = String(data: data, encoding: .utf8) ?? ""
-        let configPaths = output.split(separator: "\n").map(String.init).filter { !$0.isEmpty }
-
-        let tParse = diag.startTimed("ProjectScanner: parse \(configPaths.count) configs")
-        var found: [Project] = []
-
-        for configPath in configPaths.sorted() {
-            let projectPath = (configPath as NSString).deletingLastPathComponent
-            let name = (projectPath as NSString).lastPathComponent
-            let (devCmd, pm) = detectDevCommand(at: projectPath)
-            let paneInfo = readPaneInfo(at: configPath)
-
-            var project = Project(
-                id: projectPath,
-                path: projectPath,
-                name: name,
-                devCommand: devCmd,
-                packageManager: pm,
-                hasConfig: true,
-                paneCount: paneInfo.count,
-                paneNames: paneInfo.names,
-                paneSummary: paneInfo.summary,
-                isRunning: false
-            )
-            project.isRunning = isSessionRunning(project.sessionName)
-            found.append(project)
+            diag.info("ProjectScanner: found \(found.count) projects (\(found.filter(\.isRunning).count) running)")
+            DispatchQueue.main.async {
+                self.projects = found
+                self.scanInFlight = false
+            }
         }
-        diag.finish(tParse)
-
-        diag.info("ProjectScanner: found \(found.count) projects (\(found.filter(\.isRunning).count) running)")
-        DispatchQueue.main.async { self.projects = found }
     }
 
     func refreshStatus() {

package/app/Tests/StageDragTests.swift

@@ -0,0 +1,333 @@
+import XCTest
+import CoreGraphics
+import AppKit
+
+/// Attempt to create stages by simulating drag gestures from the strip.
+///
+/// When a user drags a strip thumbnail into the center stage, SM joins them.
+/// Can we replicate this with synthetic mouse events?
+final class StageDragTests: XCTestCase {
+
+    // MARK: - Helpers
+
+    struct LiveWindow {
+        let wid: UInt32
+        let app: String
+        let pid: Int32
+        let title: String
+        let bounds: CGRect
+        let isOnScreen: Bool
+    }
+
+    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)
+        }
+    }
+
+    /// Find strip thumbnails (small onscreen windows on the left edge)
+    func getStripThumbnails() -> [LiveWindow] {
+        getRealWindows().filter {
+            $0.isOnScreen && $0.bounds.width < 250 && $0.bounds.height < 250
+            && $0.bounds.origin.x < 220 && $0.bounds.origin.x >= 0
+        }
+    }
+
+    /// Find active stage windows (large onscreen windows)
+    func getActiveStage() -> [LiveWindow] {
+        getRealWindows().filter { $0.isOnScreen && $0.bounds.width > 250 }
+    }
+
+    func printStageState(label: String) {
+        let active = getActiveStage()
+        let strip = getStripThumbnails()
+        print("\n[\(label)]")
+        print("  Active: \(active.map { "\($0.app)(\($0.wid))" }.joined(separator: ", "))")
+        print("  Strip: \(Set(strip.map(\.app)).sorted().joined(separator: ", "))")
+    }
+
+    // MARK: - Synthetic mouse event helpers
+
+    /// Post a mouse event at a screen coordinate
+    func postMouse(_ type: CGEventType, at point: CGPoint, button: CGMouseButton = .left) {
+        guard let event = CGEvent(
+            mouseEventSource: nil,
+            mouseType: type,
+            mouseCursorPosition: point,
+            mouseButton: button
+        ) else { return }
+        event.post(tap: .cghidEventTap)
+    }
+
+    /// Simulate a smooth drag from point A to point B
+    func simulateDrag(from start: CGPoint, to end: CGPoint, steps: Int = 30, duration: TimeInterval = 0.4) {
+        // Mouse down at start
+        postMouse(.leftMouseDown, at: start)
+        Thread.sleep(forTimeInterval: 0.05)
+
+        // Interpolate drag path
+        for i in 1...steps {
+            let t = CGFloat(i) / CGFloat(steps)
+            let x = start.x + (end.x - start.x) * t
+            let y = start.y + (end.y - start.y) * t
+            postMouse(.leftMouseDragged, at: CGPoint(x: x, y: y))
+            Thread.sleep(forTimeInterval: duration / TimeInterval(steps))
+        }
+
+        // Mouse up at end
+        postMouse(.leftMouseUp, at: end)
+    }
+
+    // MARK: - Approach 5: Drag strip thumbnail to center
+
+    func testJoinByDragFromStrip() throws {
+        let smEnabled = UserDefaults(suiteName: "com.apple.WindowManager")?.bool(forKey: "GloballyEnabled") ?? false
+        try XCTSkipUnless(smEnabled, "Stage Manager is OFF")
+
+        let thumbnails = getStripThumbnails()
+        let active = getActiveStage()
+
+        guard !thumbnails.isEmpty else {
+            print("No strip thumbnails found")
+            return
+        }
+        guard let anchor = active.first else {
+            print("No active stage window")
+            return
+        }
+
+        // Target specific apps: Chrome, iTerm2, Vox
+        let activeApps = Set(active.map(\.app))
+        let preferred = ["Google Chrome", "iTerm2", "Vox"]
+        guard let thumb = thumbnails.first(where: { preferred.contains($0.app) && !activeApps.contains($0.app) })
+              ?? thumbnails.first(where: { !activeApps.contains($0.app) }) else {
+            print("No suitable strip thumbnail found")
+            return
+        }
+
+        let thumbCenter = CGPoint(x: thumb.bounds.midX, y: thumb.bounds.midY)
+        let stageCenter = CGPoint(x: anchor.bounds.midX, y: anchor.bounds.midY)
+
+        print("Dragging \(thumb.app) thumbnail from strip (\(Int(thumbCenter.x)),\(Int(thumbCenter.y))) to center (\(Int(stageCenter.x)),\(Int(stageCenter.y)))")
+        printStageState(label: "BEFORE")
+
+        simulateDrag(from: thumbCenter, to: stageCenter, steps: 40, duration: 0.6)
+
+        Thread.sleep(forTimeInterval: 0.8)
+        printStageState(label: "After drag to center")
+
+        let finalActive = getActiveStage()
+        let finalApps = Set(finalActive.map(\.app))
+        let joined = finalApps.contains(thumb.app) && activeApps.isSubset(of: finalApps)
+        print("\nResult: \(thumb.app) joined stage? \(joined)")
+        print("Active apps: \(finalApps.sorted())")
+    }
+
+    // MARK: - Approach 6: Drag thumbnail to top half (join zone)
+
+    func testJoinByDragToTopHalf() throws {
+        let smEnabled = UserDefaults(suiteName: "com.apple.WindowManager")?.bool(forKey: "GloballyEnabled") ?? false
+        try XCTSkipUnless(smEnabled, "Stage Manager is OFF")
+
+        let thumbnails = getStripThumbnails()
+        let active = getActiveStage()
+
+        guard !thumbnails.isEmpty, let anchor = active.first else { return }
+
+        let activeApps = Set(active.map(\.app))
+        let preferred6 = ["Google Chrome", "iTerm2", "Vox"]
+        guard let thumb = thumbnails.first(where: { preferred6.contains($0.app) && !activeApps.contains($0.app) })
+              ?? thumbnails.first(where: { !activeApps.contains($0.app) }) else { return }
+
+        // SM has specific drop zones. Try dragging to the top half of the active
+        // stage area — this might be the "join" zone vs "replace" zone.
+        let thumbCenter = CGPoint(x: thumb.bounds.midX, y: thumb.bounds.midY)
+        let topHalf = CGPoint(x: anchor.bounds.midX, y: anchor.bounds.origin.y + 100)
+
+        print("Dragging \(thumb.app) to top-half of active area (\(Int(topHalf.x)),\(Int(topHalf.y)))")
+        printStageState(label: "BEFORE")
+
+        simulateDrag(from: thumbCenter, to: topHalf, steps: 50, duration: 0.8)
+
+        Thread.sleep(forTimeInterval: 0.8)
+        printStageState(label: "After drag to top half")
+
+        let finalApps = Set(getActiveStage().map(\.app))
+        let joined = finalApps.contains(thumb.app) && activeApps.isSubset(of: finalApps)
+        print("\nResult: joined? \(joined) — active: \(finalApps.sorted())")
+    }
+
+    // MARK: - Approach 7: Long press on thumbnail, then drag
+
+    func testJoinByLongPressDrag() throws {
+        let smEnabled = UserDefaults(suiteName: "com.apple.WindowManager")?.bool(forKey: "GloballyEnabled") ?? false
+        try XCTSkipUnless(smEnabled, "Stage Manager is OFF")
+
+        let thumbnails = getStripThumbnails()
+        let active = getActiveStage()
+
+        guard !thumbnails.isEmpty, let anchor = active.first else { return }
+
+        let activeApps = Set(active.map(\.app))
+        let preferred7 = ["Google Chrome", "iTerm2", "Vox"]
+        guard let thumb = thumbnails.first(where: { preferred7.contains($0.app) && !activeApps.contains($0.app) })
+              ?? thumbnails.first(where: { !activeApps.contains($0.app) }) else { return }
+
+        let thumbCenter = CGPoint(x: thumb.bounds.midX, y: thumb.bounds.midY)
+        let stageCenter = CGPoint(x: anchor.bounds.midX, y: anchor.bounds.midY)
+
+        print("Long-press + drag \(thumb.app) from strip to center")
+        printStageState(label: "BEFORE")
+
+        // Long press: mouse down + wait
+        postMouse(.leftMouseDown, at: thumbCenter)
+        Thread.sleep(forTimeInterval: 0.8) // Hold for long press recognition
+
+        // Slow drag out of strip area
+        let steps = 60
+        let duration: TimeInterval = 1.0
+        for i in 1...steps {
+            let t = CGFloat(i) / CGFloat(steps)
+            let x = thumbCenter.x + (stageCenter.x - thumbCenter.x) * t
+            let y = thumbCenter.y + (stageCenter.y - thumbCenter.y) * t
+            postMouse(.leftMouseDragged, at: CGPoint(x: x, y: y))
+            Thread.sleep(forTimeInterval: duration / TimeInterval(steps))
+        }
+
+        // Hold at destination briefly
+        Thread.sleep(forTimeInterval: 0.3)
+        postMouse(.leftMouseUp, at: stageCenter)
+
+        Thread.sleep(forTimeInterval: 1.0)
+        printStageState(label: "After long-press drag")
+
+        let finalApps = Set(getActiveStage().map(\.app))
+        let joined = finalApps.contains(thumb.app) && activeApps.isSubset(of: finalApps)
+        print("\nResult: joined? \(joined) — active: \(finalApps.sorted())")
+    }
+
+    // MARK: - Approach 8: Click thumbnail while holding Option key
+
+    func testJoinByOptionClick() throws {
+        let smEnabled = UserDefaults(suiteName: "com.apple.WindowManager")?.bool(forKey: "GloballyEnabled") ?? false
+        try XCTSkipUnless(smEnabled, "Stage Manager is OFF")
+
+        let thumbnails = getStripThumbnails()
+        let active = getActiveStage()
+
+        guard !thumbnails.isEmpty else { return }
+
+        let activeApps = Set(active.map(\.app))
+        let preferred8 = ["Google Chrome", "iTerm2", "Vox"]
+        guard let thumb = thumbnails.first(where: { preferred8.contains($0.app) && !activeApps.contains($0.app) })
+              ?? thumbnails.first(where: { !activeApps.contains($0.app) }) else { return }
+
+        let thumbCenter = CGPoint(x: thumb.bounds.midX, y: thumb.bounds.midY)
+
+        print("Option-clicking \(thumb.app) thumbnail at (\(Int(thumbCenter.x)),\(Int(thumbCenter.y)))")
+        printStageState(label: "BEFORE")
+
+        // Option + click on strip thumbnail
+        guard let downEvent = CGEvent(
+            mouseEventSource: nil,
+            mouseType: .leftMouseDown,
+            mouseCursorPosition: thumbCenter,
+            mouseButton: .left
+        ) else { return }
+        downEvent.flags = .maskAlternate // Option key
+        downEvent.post(tap: .cghidEventTap)
+
+        Thread.sleep(forTimeInterval: 0.05)
+
+        guard let upEvent = CGEvent(
+            mouseEventSource: nil,
+            mouseType: .leftMouseUp,
+            mouseCursorPosition: thumbCenter,
+            mouseButton: .left
+        ) else { return }
+        upEvent.flags = .maskAlternate
+        upEvent.post(tap: .cghidEventTap)
+
+        Thread.sleep(forTimeInterval: 0.8)
+        printStageState(label: "After Option-click")
+
+        let finalApps = Set(getActiveStage().map(\.app))
+        let joined = finalApps.contains(thumb.app) && activeApps.isSubset(of: finalApps)
+        print("\nResult: joined? \(joined) — active: \(finalApps.sorted())")
+    }
+
+    // MARK: - Approach 9: Shift-click (common modifier for "add to selection")
+
+    func testJoinByShiftClick() throws {
+        let smEnabled = UserDefaults(suiteName: "com.apple.WindowManager")?.bool(forKey: "GloballyEnabled") ?? false
+        try XCTSkipUnless(smEnabled, "Stage Manager is OFF")
+
+        let thumbnails = getStripThumbnails()
+        let active = getActiveStage()
+
+        guard !thumbnails.isEmpty else { return }
+
+        let activeApps = Set(active.map(\.app))
+        let preferred9 = ["Google Chrome", "iTerm2", "Vox"]
+        guard let thumb = thumbnails.first(where: { preferred9.contains($0.app) && !activeApps.contains($0.app) })
+              ?? thumbnails.first(where: { !activeApps.contains($0.app) }) else { return }
+
+        let thumbCenter = CGPoint(x: thumb.bounds.midX, y: thumb.bounds.midY)
+
+        print("Shift-clicking \(thumb.app) thumbnail")
+        printStageState(label: "BEFORE")
+
+        guard let downEvent = CGEvent(
+            mouseEventSource: nil,
+            mouseType: .leftMouseDown,
+            mouseCursorPosition: thumbCenter,
+            mouseButton: .left
+        ) else { return }
+        downEvent.flags = .maskShift
+        downEvent.post(tap: .cghidEventTap)
+
+        Thread.sleep(forTimeInterval: 0.05)
+
+        guard let upEvent = CGEvent(
+            mouseEventSource: nil,
+            mouseType: .leftMouseUp,
+            mouseCursorPosition: thumbCenter,
+            mouseButton: .left
+        ) else { return }
+        upEvent.flags = .maskShift
+        upEvent.post(tap: .cghidEventTap)
+
+        Thread.sleep(forTimeInterval: 0.8)
+        printStageState(label: "After Shift-click")
+
+        let finalApps = Set(getActiveStage().map(\.app))
+        let joined = finalApps.contains(thumb.app) && activeApps.isSubset(of: finalApps)
+        print("\nResult: joined? \(joined) — active: \(finalApps.sorted())")
+    }
+}