@lattices/cli 0.3.0 → 0.4.1

package/app/Sources/WorkspaceManager.swift

@@ -78,7 +78,7 @@ class WorkspaceManager: ObservableObject {
 
     private let configPath: String
     private let gridConfigPath: String
-    private let tmuxPath = "/opt/homebrew/bin/tmux"
+    private var tmuxPath: String { TmuxQuery.resolvedPath ?? "/opt/homebrew/bin/tmux" }
     private let activeLayerKey = "lattices.activeLayerIndex"
 
     init() {
@@ -173,13 +173,15 @@ class WorkspaceManager: ObservableObject {
 
     /// Resolve a tile string to fractions: check user presets first, then built-in TilePosition
     func resolveTileFractions(_ tile: String) -> (CGFloat, CGFloat, CGFloat, CGFloat)? {
-        if let preset = gridPresets[tile] {
-            return preset.fractions
-        }
-        if let position = TilePosition(rawValue: tile) {
-            return position.rect
+        resolvePlacement(tile)?.fractions
+    }
+
+    func resolvePlacement(_ tile: String) -> PlacementSpec? {
+        if let preset = gridPresets[tile],
+           let placement = FractionalPlacement(x: preset.x, y: preset.y, w: preset.w, h: preset.h) {
+            return .fractions(placement)
         }
-        return nil
+        return PlacementSpec(string: tile)
     }
 
     // MARK: - Tab Groups
@@ -275,7 +277,7 @@ class WorkspaceManager: ObservableObject {
 
     /// Resolve a session name to a tile target: (wid, pid, frame).
     /// Returns nil if the window isn't tracked or has no tile position.
-    private func batchTarget(session: String, position: TilePosition, screen: NSScreen) -> (wid: UInt32, pid: Int32, frame: CGRect)? {
+    private func batchTarget(session: String, position: PlacementSpec, screen: NSScreen) -> (wid: UInt32, pid: Int32, frame: CGRect)? {
         guard let entry = windowForSession(session) else { return nil }
         let frame = WindowTiler.tileFrame(for: position, on: screen)
         return (entry.wid, entry.pid, frame)
@@ -309,6 +311,71 @@ class WorkspaceManager: ObservableObject {
         return (running, total)
     }
 
+    // MARK: - Layer Focus (raise only)
+
+    /// Switch to a layer by raising all its windows in place — no launching, no tiling, no moving.
+    /// This is the default hotkey action: just bring the layer's windows to the front.
+    func focusLayer(index: Int) {
+        guard let config, let layers = config.layers, index < layers.count else { return }
+        if index == activeLayerIndex { return }
+
+        let diag = DiagnosticLog.shared
+        let t = diag.startTimed("focusLayer \(activeLayerIndex)→\(index)")
+
+        DesktopModel.shared.poll()
+
+        let targetLayer = layers[index]
+        var windowsToRaise: [(wid: UInt32, pid: Int32)] = []
+
+        for lp in targetLayer.projects {
+            if let groupId = lp.group, let grp = group(byId: groupId) {
+                // Raise all tab windows in the group
+                for tab in grp.tabs {
+                    let sessionName = Self.sessionName(for: tab.path)
+                    if let entry = windowForSession(sessionName) {
+                        windowsToRaise.append((entry.wid, entry.pid))
+                    }
+                }
+                continue
+            }
+
+            if let appName = lp.app {
+                if let entry = DesktopModel.shared.windowForApp(app: appName, title: lp.title) {
+                    windowsToRaise.append((entry.wid, entry.pid))
+                }
+                continue
+            }
+
+            guard let path = lp.path else { continue }
+            let sessionName = Self.sessionName(for: path)
+            if let entry = windowForSession(sessionName) {
+                windowsToRaise.append((entry.wid, entry.pid))
+            }
+
+            // Also raise companion windows
+            let companions = projectWindows(at: path)
+            for cw in companions {
+                guard let appName = cw.app else { continue }
+                if let entry = DesktopModel.shared.windowForApp(app: appName, title: cw.title) {
+                    windowsToRaise.append((entry.wid, entry.pid))
+                }
+            }
+        }
+
+        if !windowsToRaise.isEmpty {
+            WindowTiler.raiseWindowsAndReactivate(windows: windowsToRaise)
+        }
+
+        activeLayerIndex = index
+        UserDefaults.standard.set(index, forKey: activeLayerKey)
+
+        let allLabels = layers.map(\.label)
+        LayerBezel.shared.show(label: targetLayer.label, index: index, total: layers.count, allLabels: allLabels)
+        HandsOffSession.shared.playCachedCue("Switched.")
+
+        diag.finish(t)
+    }
+
     // MARK: - Unified Layer Tiling
 
     /// Unified entry point for arranging a layer's windows.
@@ -332,14 +399,17 @@ class WorkspaceManager: ObservableObject {
         let scanner = ProjectScanner.shared
         let targetLayer = layers[index]
 
+        // Fresh poll so we see windows on all Spaces before matching
+        DesktopModel.shared.poll()
+
         // Tile debug log (written to ~/.lattices/tile-debug.log)
         let debugPath = (FileManager.default.homeDirectoryForCurrentUser.path as NSString).appendingPathComponent(".lattices/tile-debug.log")
         var debugLines: [String] = ["tileLayer index=\(index) launch=\(launch) force=\(force) layer=\(targetLayer.id)"]
 
         // Phase 1: classify each project
         var batchMoves: [(wid: UInt32, pid: Int32, frame: CGRect)] = []
-        var fallbacks: [(session: String, position: TilePosition, screen: NSScreen)] = []
-        var launchQueue: [(session: String, position: TilePosition?, screen: NSScreen, launchAction: () -> Void)] = []
+        var fallbacks: [(session: String, position: PlacementSpec, screen: NSScreen)] = []
+        var launchQueue: [(session: String, position: PlacementSpec?, screen: NSScreen, launchAction: () -> Void)] = []
 
         // Log screen info
         for (i, s) in NSScreen.screens.enumerated() {
@@ -351,7 +421,7 @@ class WorkspaceManager: ObservableObject {
 
             if let groupId = lp.group, let grp = group(byId: groupId) {
                 let firstTabSession = grp.tabs.first.map { Self.sessionName(for: $0.path) } ?? ""
-                let position = lp.tile.flatMap { TilePosition(rawValue: $0) }
+                let position = lp.tile.flatMap { resolvePlacement($0) }
                 let groupRunning = isGroupRunning(grp)
 
                 if groupRunning, let pos = position,
@@ -373,12 +443,19 @@ class WorkspaceManager: ObservableObject {
 
             // App-based window matching
             if let appName = lp.app {
-                let position = lp.tile.flatMap { TilePosition(rawValue: $0) }
+                let position = lp.tile.flatMap { resolvePlacement($0) }
                 if let entry = DesktopModel.shared.windowForApp(app: appName, title: lp.title) {
                     if let pos = position {
                         let frame = WindowTiler.tileFrame(for: pos, on: lpScreen)
                         batchMoves.append((entry.wid, entry.pid, frame))
                     }
+                } else if let found = Self.findAppWindow(app: appName, title: lp.title) {
+                    // Window exists but wasn't in DesktopModel (e.g. different Space) — tile it
+                    diag.info("  found app via CGWindowList fallback: \(appName) wid=\(found.wid)")
+                    if let pos = position {
+                        let frame = WindowTiler.tileFrame(for: pos, on: lpScreen)
+                        batchMoves.append((found.wid, found.pid, frame))
+                    }
                 } else if launch {
                     diag.info("  launch app: \(appName)")
                     let capturedLp = lp
@@ -407,13 +484,13 @@ class WorkspaceManager: ObservableObject {
             guard let path = lp.path else { continue }
             let sessionName = Self.sessionName(for: path)
             let project = scanner.projects.first(where: { $0.path == path })
-            let position = lp.tile.flatMap { TilePosition(rawValue: $0) }
+            let position = lp.tile.flatMap { resolvePlacement($0) }
             // Check scanner first, fall back to direct tmux check for projects without .lattices.json
             let isRunning = project?.isRunning == true || shell([tmuxPath, "has-session", "-t", sessionName]) == 0
 
             if isRunning {
                 let foundWindow = windowForSession(sessionName)
-                let msg = "  \(sessionName): running=\(isRunning) window=\(foundWindow?.wid ?? 0) tile=\(position?.rawValue ?? "nil") desktopCount=\(DesktopModel.shared.windows.count)"
+                let msg = "  \(sessionName): running=\(isRunning) window=\(foundWindow?.wid ?? 0) tile=\(position?.wireValue ?? "nil") desktopCount=\(DesktopModel.shared.windows.count)"
                 diag.info(msg)
                 debugLines.append(msg)
                 if let pos = position,
@@ -422,7 +499,7 @@ class WorkspaceManager: ObservableObject {
                     debugLines.append("    → batch move wid=\(target.wid) frame=\(target.frame)")
                 } else if let pos = position {
                     fallbacks.append((sessionName, pos, lpScreen))
-                    debugLines.append("    → fallback \(pos.rawValue)")
+                    debugLines.append("    → fallback \(pos.wireValue)")
                 }
             } else if launch {
                 if let project {
@@ -443,7 +520,7 @@ class WorkspaceManager: ObservableObject {
             for cw in companions {
                 guard let appName = cw.app else { continue }
                 let cwScreen = screen(for: cw.display ?? lp.display) ?? lpScreen
-                let cwPosition = cw.tile.flatMap { TilePosition(rawValue: $0) }
+                let cwPosition = cw.tile.flatMap { resolvePlacement($0) }
                 if let entry = DesktopModel.shared.windowForApp(app: appName, title: cw.title) {
                     if let pos = cwPosition {
                         let frame = WindowTiler.tileFrame(for: pos, on: cwScreen)
@@ -486,7 +563,7 @@ class WorkspaceManager: ObservableObject {
         for (i, fb) in fallbacks.enumerated() {
             let delay = Double(i) * 0.15 + 0.1
             DispatchQueue.main.asyncAfter(deadline: .now() + delay) {
-                diag.info("  tile fallback: \(fb.session) → \(fb.position.rawValue)")
+                diag.info("  tile fallback: \(fb.session) → \(fb.position.wireValue)")
                 WindowTiler.navigateToWindow(session: fb.session, terminal: terminal)
                 WindowTiler.tile(session: fb.session, terminal: terminal, to: fb.position, on: fb.screen)
             }
@@ -498,7 +575,7 @@ class WorkspaceManager: ObservableObject {
             DispatchQueue.main.asyncAfter(deadline: .now() + delay) {
                 item.launchAction()
                 if let pos = item.position {
-                    let t = diag.startTimed("tile launched: \(item.session) → \(pos.rawValue)")
+                    let t = diag.startTimed("tile launched: \(item.session) → \(pos.wireValue)")
                     WindowTiler.tile(session: item.session, terminal: terminal, to: pos, on: item.screen)
                     diag.finish(t)
                 }
@@ -558,6 +635,38 @@ class WorkspaceManager: ObservableObject {
         }
     }
 
+    // MARK: - App Window Fallback (CGWindowList .optionAll)
+
+    /// Find an app window across ALL Spaces via CGWindowList (bypasses DesktopModel cache)
+    static func findAppWindow(app: String, title: String?) -> (wid: UInt32, pid: Int32)? {
+        guard let list = CGWindowListCopyWindowInfo(
+            [.optionAll, .excludeDesktopElements],
+            kCGNullWindowID
+        ) as? [[String: Any]] else { return nil }
+
+        for info in list {
+            guard let ownerName = info[kCGWindowOwnerName as String] as? String,
+                  ownerName.localizedCaseInsensitiveContains(app),
+                  let wid = info[kCGWindowNumber as String] as? UInt32,
+                  let pid = info[kCGWindowOwnerPID as String] as? Int32,
+                  let layer = info[kCGWindowLayer as String] as? Int, layer == 0,
+                  let boundsDict = info[kCGWindowBounds as String] as? NSDictionary
+            else { continue }
+
+            var rect = CGRect.zero
+            guard CGRectMakeWithDictionaryRepresentation(boundsDict, &rect),
+                  rect.width >= 50, rect.height >= 50 else { continue }
+
+            if let title {
+                let windowTitle = info[kCGWindowName as String] as? String ?? ""
+                guard windowTitle.localizedCaseInsensitiveContains(title) else { continue }
+            }
+
+            return (wid, pid)
+        }
+        return nil
+    }
+
     // MARK: - Session Name Helper
 
     /// Replicates Project.sessionName logic from a bare path

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())")
+    }
+}