@arach/lattices 0.2.1 → 0.6.1

package/app/Sources/WindowTiler.swift

@@ -1,1755 +0,0 @@
-import AppKit
-import CoreGraphics
-
-// Private API: get CGWindowID from an AXUIElement
-@_silgen_name("_AXUIElementGetWindow")
-func _AXUIElementGetWindow(_ element: AXUIElement, _ windowID: UnsafeMutablePointer<CGWindowID>) -> AXError
-
-// MARK: - SkyLight Private APIs (instant window moves, no animation)
-// Loaded at runtime via dlsym — graceful fallback if unavailable.
-
-private let skyLight: UnsafeMutableRawPointer? = dlopen("/System/Library/PrivateFrameworks/SkyLight.framework/SkyLight", RTLD_NOW)
-
-private typealias SLSMainConnectionIDFunc = @convention(c) () -> Int32
-private typealias SLSMoveWindowFunc = @convention(c) (Int32, UInt32, UnsafeMutablePointer<CGPoint>) -> CGError
-
-private let _SLSMainConnectionID: SLSMainConnectionIDFunc? = {
-    guard let sl = skyLight, let sym = dlsym(sl, "SLSMainConnectionID") else { return nil }
-    return unsafeBitCast(sym, to: SLSMainConnectionIDFunc.self)
-}()
-
-private let _SLSMoveWindow: SLSMoveWindowFunc? = {
-    guard let sl = skyLight, let sym = dlsym(sl, "SLSMoveWindow") else { return nil }
-    return unsafeBitCast(sym, to: SLSMoveWindowFunc.self)
-}()
-
-// MARK: - Window Highlight Overlay
-
-final class WindowHighlight {
-    static let shared = WindowHighlight()
-
-    private var overlayWindow: NSWindow?
-    private var fadeTimer: Timer?
-
-    /// Flash a green border overlay at the given screen frame
-    func flash(frame: NSRect, duration: TimeInterval = 1.2) {
-        dismiss()
-
-        let inset: CGFloat = -8  // slightly larger than the window
-        let expandedFrame = frame.insetBy(dx: inset, dy: inset)
-
-        let window = NSWindow(
-            contentRect: expandedFrame,
-            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 borderView = HighlightBorderView(frame: NSRect(origin: .zero, size: expandedFrame.size))
-        window.contentView = borderView
-
-        window.alphaValue = 0
-        window.orderFrontRegardless()
-
-        overlayWindow = window
-
-        // Fade in
-        NSAnimationContext.runAnimationGroup { ctx in
-            ctx.duration = 0.15
-            window.animator().alphaValue = 1.0
-        }
-
-        // Schedule fade out
-        fadeTimer = Timer.scheduledTimer(withTimeInterval: duration, repeats: false) { [weak self] _ in
-            self?.fadeOut()
-        }
-    }
-
-    func dismiss() {
-        fadeTimer?.invalidate()
-        fadeTimer = nil
-        overlayWindow?.orderOut(nil)
-        overlayWindow = nil
-    }
-
-    private func fadeOut() {
-        guard let window = overlayWindow else { return }
-        NSAnimationContext.runAnimationGroup({ ctx in
-            ctx.duration = 0.3
-            window.animator().alphaValue = 0
-        }, completionHandler: { [weak self] in
-            self?.dismiss()
-        })
-    }
-}
-
-private class HighlightBorderView: NSView {
-    override func draw(_ dirtyRect: NSRect) {
-        let borderWidth: CGFloat = 4
-        let cornerRadius: CGFloat = 12
-
-        // Outer glow
-        let glowRect = bounds.insetBy(dx: 1, dy: 1)
-        let glowPath = NSBezierPath(roundedRect: glowRect, xRadius: cornerRadius + 2, yRadius: cornerRadius + 2)
-        glowPath.lineWidth = borderWidth + 4
-        NSColor(calibratedRed: 0.2, green: 0.9, blue: 0.4, alpha: 0.15).setStroke()
-        glowPath.stroke()
-
-        // Main border
-        let rect = bounds.insetBy(dx: borderWidth / 2 + 2, dy: borderWidth / 2 + 2)
-        let path = NSBezierPath(roundedRect: rect, xRadius: cornerRadius, yRadius: cornerRadius)
-        path.lineWidth = borderWidth
-        NSColor(calibratedRed: 0.2, green: 0.9, blue: 0.4, alpha: 0.9).setStroke()
-        path.stroke()
-    }
-}
-
-enum TilePosition: String, CaseIterable, Identifiable {
-    case left        = "left"
-    case right       = "right"
-    case top         = "top"
-    case bottom      = "bottom"
-    case topLeft     = "top-left"
-    case topRight    = "top-right"
-    case bottomLeft  = "bottom-left"
-    case bottomRight = "bottom-right"
-    case maximize    = "maximize"
-    case center      = "center"
-    case leftThird   = "left-third"
-    case centerThird = "center-third"
-    case rightThird  = "right-third"
-
-    var id: String { rawValue }
-
-    var label: String {
-        switch self {
-        case .left:        return "Left"
-        case .right:       return "Right"
-        case .top:         return "Top"
-        case .bottom:      return "Bottom"
-        case .topLeft:     return "Top Left"
-        case .topRight:    return "Top Right"
-        case .bottomLeft:  return "Bottom Left"
-        case .bottomRight: return "Bottom Right"
-        case .maximize:    return "Max"
-        case .center:      return "Center"
-        case .leftThird:   return "Left Third"
-        case .centerThird: return "Center Third"
-        case .rightThird:  return "Right Third"
-        }
-    }
-
-    var icon: String {
-        switch self {
-        case .left:        return "rectangle.lefthalf.filled"
-        case .right:       return "rectangle.righthalf.filled"
-        case .top:         return "rectangle.tophalf.filled"
-        case .bottom:      return "rectangle.bottomhalf.filled"
-        case .topLeft:     return "rectangle.inset.topleft.filled"
-        case .topRight:    return "rectangle.inset.topright.filled"
-        case .bottomLeft:  return "rectangle.inset.bottomleft.filled"
-        case .bottomRight: return "rectangle.inset.bottomright.filled"
-        case .maximize:    return "rectangle.fill"
-        case .center:      return "rectangle.center.inset.filled"
-        case .leftThird:   return "rectangle.leadingthird.inset.filled"
-        case .centerThird: return "rectangle.center.inset.filled"
-        case .rightThird:  return "rectangle.trailingthird.inset.filled"
-        }
-    }
-
-    /// Returns (x, y, w, h) as fractions of screen
-    var rect: (CGFloat, CGFloat, CGFloat, CGFloat) {
-        switch self {
-        case .left:        return (0,     0,   0.5,   1.0)
-        case .right:       return (0.5,   0,   0.5,   1.0)
-        case .top:         return (0,     0,   1.0,   0.5)
-        case .bottom:      return (0,     0.5, 1.0,   0.5)
-        case .topLeft:     return (0,     0,   0.5,   0.5)
-        case .topRight:    return (0.5,   0,   0.5,   0.5)
-        case .bottomLeft:  return (0,     0.5, 0.5,   0.5)
-        case .bottomRight: return (0.5,   0.5, 0.5,   0.5)
-        case .maximize:    return (0,     0,   1.0,   1.0)
-        case .center:      return (0.15,  0.1, 0.7,   0.8)
-        case .leftThird:   return (0,     0,   0.333, 1.0)
-        case .centerThird: return (0.333, 0,   0.334, 1.0)
-        case .rightThird:  return (0.667, 0,   0.333, 1.0)
-        }
-    }
-}
-
-// MARK: - Private CGS API for Spaces (loaded dynamically from SkyLight)
-
-struct SpaceInfo: Identifiable {
-    let id: Int      // CGS space ID
-    let index: Int   // 1-based index within its display
-    let display: Int // 0-based display index
-    let isCurrent: Bool
-}
-
-struct DisplaySpaces {
-    let displayIndex: Int
-    let displayId: String
-    let spaces: [SpaceInfo]
-    let currentSpaceId: Int
-}
-
-private enum CGS {
-    // Use Int32 for CGS connection IDs (C `int`), UInt64 for space IDs
-    typealias MainConnectionIDFunc = @convention(c) () -> Int32
-    typealias GetActiveSpaceFunc = @convention(c) (Int32) -> UInt64
-    typealias CopyManagedDisplaySpacesFunc = @convention(c) (Int32) -> CFArray
-    typealias CopySpacesForWindowsFunc = @convention(c) (Int32, Int32, CFArray) -> CFArray
-    typealias SetCurrentSpaceFunc = @convention(c) (Int32, CFString, UInt64) -> Void
-
-    private static let handle = dlopen("/System/Library/PrivateFrameworks/SkyLight.framework/SkyLight", RTLD_LAZY)
-
-    static let mainConnectionID: MainConnectionIDFunc? = {
-        guard let h = handle, let sym = dlsym(h, "CGSMainConnectionID") else { return nil }
-        return unsafeBitCast(sym, to: MainConnectionIDFunc.self)
-    }()
-
-    static let getActiveSpace: GetActiveSpaceFunc? = {
-        guard let h = handle, let sym = dlsym(h, "CGSGetActiveSpace") else { return nil }
-        return unsafeBitCast(sym, to: GetActiveSpaceFunc.self)
-    }()
-
-    static let copyManagedDisplaySpaces: CopyManagedDisplaySpacesFunc? = {
-        guard let h = handle, let sym = dlsym(h, "CGSCopyManagedDisplaySpaces") else { return nil }
-        return unsafeBitCast(sym, to: CopyManagedDisplaySpacesFunc.self)
-    }()
-
-    static let copySpacesForWindows: CopySpacesForWindowsFunc? = {
-        guard let h = handle, let sym = dlsym(h, "SLSCopySpacesForWindows") else { return nil }
-        return unsafeBitCast(sym, to: CopySpacesForWindowsFunc.self)
-    }()
-
-    static let setCurrentSpace: SetCurrentSpaceFunc? = {
-        guard let h = handle, let sym = dlsym(h, "SLSManagedDisplaySetCurrentSpace") else { return nil }
-        return unsafeBitCast(sym, to: SetCurrentSpaceFunc.self)
-    }()
-
-    // Move windows between spaces
-    typealias AddWindowsToSpacesFunc = @convention(c) (Int32, CFArray, CFArray) -> Void
-    typealias RemoveWindowsFromSpacesFunc = @convention(c) (Int32, CFArray, CFArray) -> Void
-
-    static let addWindowsToSpaces: AddWindowsToSpacesFunc? = {
-        guard let h = handle else { return nil }
-        guard let sym = dlsym(h, "CGSAddWindowsToSpaces") ?? dlsym(h, "SLSAddWindowsToSpaces") else { return nil }
-        return unsafeBitCast(sym, to: AddWindowsToSpacesFunc.self)
-    }()
-
-    static let removeWindowsFromSpaces: RemoveWindowsFromSpacesFunc? = {
-        guard let h = handle else { return nil }
-        guard let sym = dlsym(h, "CGSRemoveWindowsFromSpaces") ?? dlsym(h, "SLSRemoveWindowsFromSpaces") else { return nil }
-        return unsafeBitCast(sym, to: RemoveWindowsFromSpacesFunc.self)
-    }()
-}
-
-enum WindowTiler {
-    /// Whether CGS move-between-spaces APIs are available
-    static var canMoveWindowsBetweenSpaces: Bool {
-        CGS.addWindowsToSpaces != nil && CGS.removeWindowsFromSpaces != nil
-    }
-
-    /// Convert fractional rect to AppleScript bounds {left, top, right, bottom}
-    /// AppleScript uses top-left origin; NSScreen uses bottom-left origin
-    private static func appleScriptBounds(for position: TilePosition, screen: NSScreen? = nil) -> (Int, Int, Int, Int) {
-        let targetScreen = screen ?? NSScreen.main
-        guard let targetScreen else { return (0, 0, 960, 540) }
-        let full = targetScreen.frame
-        let visible = targetScreen.visibleFrame
-
-        let visTop = Int(full.height - visible.maxY)
-        let visLeft = Int(visible.minX)
-        let visW = Int(visible.width)
-        let visH = Int(visible.height)
-
-        let (fx, fy, fw, fh) = position.rect
-        let x1 = visLeft + Int(CGFloat(visW) * fx)
-        let y1 = visTop + Int(CGFloat(visH) * fy)
-        let x2 = x1 + Int(CGFloat(visW) * fw)
-        let y2 = y1 + Int(CGFloat(visH) * fh)
-        return (x1, y1, x2, y2)
-    }
-
-    /// Compute AX-coordinate frame for a tile position on a given screen
-    static func tileFrame(for position: TilePosition, on screen: NSScreen) -> CGRect {
-        let visible = screen.visibleFrame
-        guard let primary = NSScreen.screens.first else { return .zero }
-        let primaryH = primary.frame.height
-        let axTop = primaryH - visible.maxY
-        let (fx, fy, fw, fh) = position.rect
-        return CGRect(
-            x: visible.origin.x + visible.width * fx,
-            y: axTop + visible.height * fy,
-            width: visible.width * fw,
-            height: visible.height * fh
-        )
-    }
-
-    /// Compute AX-coordinate frame for a tile position within a raw display CGRect (CG/AX coords)
-    static func tileFrame(for position: TilePosition, inDisplay displayRect: CGRect) -> CGRect {
-        let (fx, fy, fw, fh) = position.rect
-        return CGRect(
-            x: displayRect.origin.x + displayRect.width * fx,
-            y: displayRect.origin.y + displayRect.height * fy,
-            width: displayRect.width * fw,
-            height: displayRect.height * fh
-        )
-    }
-
-    /// Compute AX-coordinate frame from fractional (x, y, w, h) within a raw display CGRect
-    static func tileFrame(fractions: (CGFloat, CGFloat, CGFloat, CGFloat), inDisplay displayRect: CGRect) -> CGRect {
-        let (fx, fy, fw, fh) = fractions
-        return CGRect(
-            x: displayRect.origin.x + displayRect.width * fx,
-            y: displayRect.origin.y + displayRect.height * fy,
-            width: displayRect.width * fw,
-            height: displayRect.height * fh
-        )
-    }
-
-    /// Tile a specific terminal window on a given screen.
-    /// Fast path: DesktopModel → AX. Fallback: AX search → AppleScript last resort.
-    static func tile(session: String, terminal: Terminal, to position: TilePosition, on screen: NSScreen) {
-        let diag = DiagnosticLog.shared
-        let t = diag.startTimed("tile: \(session) → \(position.rawValue)")
-
-        // Fast path: use DesktopModel cache → single AX move
-        if let entry = DesktopModel.shared.windowForSession(session) {
-            let frame = tileFrame(for: position, on: screen)
-            batchMoveAndRaiseWindows([(wid: entry.wid, pid: entry.pid, frame: frame)])
-            diag.success("tile fast path (DesktopModel): \(session)")
-            diag.finish(t)
-            return
-        }
-
-        // AX fallback: search terminal windows by title tag
-        let tag = Terminal.windowTag(for: session)
-        if let (pid, axWindow) = findWindowViaAX(terminal: terminal, tag: tag) {
-            let targetFrame = tileFrame(for: position, on: screen)
-            var newPos = CGPoint(x: targetFrame.origin.x, y: targetFrame.origin.y)
-            var newSize = CGSize(width: targetFrame.width, height: targetFrame.height)
-            let win = axWindow
-            if let sv = AXValueCreate(.cgSize, &newSize) {
-                AXUIElementSetAttributeValue(win, kAXSizeAttribute as CFString, sv)
-            }
-            if let pv = AXValueCreate(.cgPoint, &newPos) {
-                AXUIElementSetAttributeValue(win, kAXPositionAttribute as CFString, pv)
-            }
-            if let sv = AXValueCreate(.cgSize, &newSize) {
-                AXUIElementSetAttributeValue(win, kAXSizeAttribute as CFString, sv)
-            }
-            if let pv = AXValueCreate(.cgPoint, &newPos) {
-                AXUIElementSetAttributeValue(win, kAXPositionAttribute as CFString, pv)
-            }
-            AXUIElementPerformAction(win, kAXRaiseAction as CFString)
-            if let app = NSRunningApplication(processIdentifier: pid) { app.activate() }
-            diag.success("tile AX fallback: \(session)")
-            diag.finish(t)
-            return
-        }
-
-        // AppleScript last resort (slow, single-monitor)
-        diag.warn("tile AppleScript last resort: \(session)")
-        let bounds = appleScriptBounds(for: position, screen: screen)
-        switch terminal {
-        case .terminal:
-            tileAppleScript(app: "Terminal", tag: tag, bounds: bounds)
-        case .iterm2:
-            tileAppleScript(app: "iTerm2", tag: tag, bounds: bounds)
-        default:
-            tileFrontmost(bounds: bounds)
-        }
-        diag.finish(t)
-    }
-
-    /// Tile a specific terminal window (found by lattices session tag) to a position.
-    /// Uses the same fast path strategy as tile(session:terminal:to:on:) with main screen.
-    static func tile(session: String, terminal: Terminal, to position: TilePosition) {
-        let screen = NSScreen.main ?? NSScreen.screens[0]
-        tile(session: session, terminal: terminal, to: position, on: screen)
-    }
-
-    /// Tile the frontmost window (works for any terminal)
-    static func tileFrontmost(to position: TilePosition) {
-        tileFrontmost(bounds: appleScriptBounds(for: position))
-    }
-
-    // MARK: - Spaces
-
-    /// Get spaces organized by display
-    static func getDisplaySpaces() -> [DisplaySpaces] {
-        guard let mainConn = CGS.mainConnectionID,
-              let copyManaged = CGS.copyManagedDisplaySpaces else { return [] }
-
-        let cid = mainConn()
-        guard let managed = copyManaged(cid) as? [[String: Any]] else { return [] }
-
-        var result: [DisplaySpaces] = []
-        for (displayIdx, display) in managed.enumerated() {
-            let displayId = display["Display Identifier"] as? String ?? ""
-            let rawSpaces = display["Spaces"] as? [[String: Any]] ?? []
-            let currentDict = display["Current Space"] as? [String: Any]
-            let currentId = currentDict?["id64"] as? Int ?? currentDict?["ManagedSpaceID"] as? Int ?? 0
-
-            var spaces: [SpaceInfo] = []
-            for (spaceIdx, space) in rawSpaces.enumerated() {
-                let sid = space["id64"] as? Int ?? space["ManagedSpaceID"] as? Int ?? 0
-                let type = space["type"] as? Int ?? 0
-                if type == 0 {
-                    spaces.append(SpaceInfo(
-                        id: sid,
-                        index: spaceIdx + 1,
-                        display: displayIdx,
-                        isCurrent: sid == currentId
-                    ))
-                }
-            }
-
-            result.append(DisplaySpaces(
-                displayIndex: displayIdx,
-                displayId: displayId,
-                spaces: spaces,
-                currentSpaceId: currentId
-            ))
-        }
-        return result
-    }
-
-    /// Get the current active Space ID
-    static func getCurrentSpace() -> Int {
-        guard let mainConn = CGS.mainConnectionID, let getActive = CGS.getActiveSpace else { return 0 }
-        return Int(getActive(mainConn()))
-    }
-
-    /// Find a window by its title tag and return its CGWindowID and owner PID
-    static func findWindow(tag: String) -> (wid: UInt32, pid: pid_t)? {
-        guard let windowList = CGWindowListCopyWindowInfo([.optionAll, .excludeDesktopElements], kCGNullWindowID) as? [[String: Any]] else {
-            return nil
-        }
-        for info in windowList {
-            if let name = info[kCGWindowName as String] as? String,
-               name.contains(tag),
-               let wid = info[kCGWindowNumber as String] as? UInt32,
-               let pid = info[kCGWindowOwnerPID as String] as? pid_t {
-                return (wid, pid)
-            }
-        }
-        return nil
-    }
-
-    /// Get the space ID(s) a window is on
-    static func getSpacesForWindow(_ wid: UInt32) -> [Int] {
-        guard let mainConn = CGS.mainConnectionID,
-              let copySpaces = CGS.copySpacesForWindows else { return [] }
-        let cid = mainConn()
-        let arr = [NSNumber(value: wid)] as CFArray
-        guard let result = copySpaces(cid, 0x7, arr) as? [NSNumber] else { return [] }
-        return result.map { $0.intValue }
-    }
-
-    /// Switch a display to a specific Space
-    static func switchToSpace(spaceId: Int) {
-        guard let mainConn = CGS.mainConnectionID,
-              let setSpace = CGS.setCurrentSpace else { return }
-
-        let cid = mainConn()
-
-        // Find which display this space belongs to
-        let allDisplays = getDisplaySpaces()
-        for display in allDisplays {
-            if display.spaces.contains(where: { $0.id == spaceId }) {
-                setSpace(cid, display.displayId as CFString, UInt64(spaceId))
-                return
-            }
-        }
-    }
-
-    // MARK: - Move Window Between Spaces
-
-    enum MoveResult {
-        case success(method: String)
-        case alreadyOnSpace
-        case windowNotFound
-        case failed(reason: String)
-    }
-
-    /// Move a session's terminal window to a different Space.
-    /// Note: On macOS 14.5+ the CGS move APIs are silently denied.
-    /// When that happens we fall back to just switching the user's view.
-    static func moveWindowToSpace(session: String, terminal: Terminal, spaceId: Int) -> MoveResult {
-        let diag = DiagnosticLog.shared
-        let tag = Terminal.windowTag(for: session)
-        diag.info("moveWindowToSpace: session=\(session) tag=\(tag) targetSpace=\(spaceId)")
-
-        // Find the window — CG first, then AX→CG fallback
-        let wid: UInt32
-        if let (w, _) = findWindow(tag: tag) {
-            wid = w
-            diag.info("moveWindowToSpace: found via CG wid=\(w)")
-        } else if let (pid, axWindow) = findWindowViaAX(terminal: terminal, tag: tag),
-                  let w = matchCGWindow(pid: pid, axWindow: axWindow) {
-            wid = w
-            diag.info("moveWindowToSpace: found via AX→CG wid=\(w)")
-        } else {
-            diag.warn("moveWindowToSpace: window not found for tag \(tag) — switching view only")
-            switchToSpace(spaceId: spaceId)
-            return .windowNotFound
-        }
-
-        // Check current spaces
-        let currentSpaces = getSpacesForWindow(wid)
-        diag.info("moveWindowToSpace: wid=\(wid) currentSpaces=\(currentSpaces)")
-        if currentSpaces.contains(spaceId) {
-            diag.info("moveWindowToSpace: already on target space — switching view")
-            switchToSpace(spaceId: spaceId)
-            return .alreadyOnSpace
-        }
-
-        // Try CGS direct move (works on older macOS, silently denied on 14.5+)
-        if let result = moveViaCGS(wid: wid, fromSpaces: currentSpaces, toSpace: spaceId) {
-            return result
-        }
-
-        // CGS unavailable — just switch the user's view
-        diag.info("moveWindowToSpace: CGS unavailable, switching view to space")
-        switchToSpace(spaceId: spaceId)
-        return .success(method: "switch-view")
-    }
-
-    /// Attempt CGS-based window move. Returns nil if APIs are unavailable.
-    private static func moveViaCGS(wid: UInt32, fromSpaces: [Int], toSpace: Int) -> MoveResult? {
-        let diag = DiagnosticLog.shared
-        guard let mainConn = CGS.mainConnectionID,
-              let addToSpaces = CGS.addWindowsToSpaces,
-              let removeFromSpaces = CGS.removeWindowsFromSpaces else {
-            return nil
-        }
-
-        let cid = mainConn()
-        let windowArray = [NSNumber(value: wid)] as CFArray
-        let targetArray = [NSNumber(value: toSpace)] as CFArray
-
-        addToSpaces(cid, windowArray, targetArray)
-        if !fromSpaces.isEmpty {
-            let sourceArray = fromSpaces.map { NSNumber(value: $0) } as CFArray
-            removeFromSpaces(cid, windowArray, sourceArray)
-        }
-
-        // Verify the move took effect (macOS 14.5+ silently denies)
-        let newSpaces = getSpacesForWindow(wid)
-        if newSpaces.contains(toSpace) && !fromSpaces.allSatisfy({ newSpaces.contains($0) }) {
-            diag.success("moveViaCGS: successfully moved wid=\(wid) to space \(toSpace)")
-            return .success(method: "CGS")
-        }
-
-        // CGS was silently denied — switch the view instead
-        diag.warn("moveViaCGS: silently denied (macOS 14.5+ restriction) — switching view")
-        switchToSpace(spaceId: toSpace)
-        return .success(method: "switch-view")
-    }
-
-    /// Navigate to a session's window: switch to its Space, raise it, highlight it
-    /// Falls back through CG → AX → AppleScript depending on available permissions
-    static func navigateToWindow(session: String, terminal: Terminal) {
-        let diag = DiagnosticLog.shared
-        let t = diag.startTimed("navigateToWindow: \(session)")
-        let tag = Terminal.windowTag(for: session)
-
-        // Path 1: CG window lookup (needs Screen Recording permission for window names)
-        if let (wid, pid) = findWindow(tag: tag) {
-            diag.success("Path 1 (CG): found wid=\(wid) pid=\(pid)")
-            navigateToKnownWindow(wid: wid, pid: pid, tag: tag, session: session, terminal: terminal)
-            diag.finish(t)
-            return
-        }
-        diag.warn("Path 1 (CG): findWindow failed — no Screen Recording?")
-
-        // Path 2: AX API fallback (needs Accessibility permission)
-        if let (pid, axWindow) = findWindowViaAX(terminal: terminal, tag: tag) {
-            diag.success("Path 2 (AX): found window for \(terminal.rawValue) pid=\(pid)")
-            // Try to match AX window → CG window for space switching
-            if let wid = matchCGWindow(pid: pid, axWindow: axWindow) {
-                diag.success("Path 2 (AX→CG): matched CG wid=\(wid)")
-                navigateToKnownWindow(wid: wid, pid: pid, tag: tag, session: session, terminal: terminal)
-            } else {
-                diag.warn("Path 2 (AX): no CG match — raising without space switch")
-                AXUIElementPerformAction(axWindow, kAXRaiseAction as CFString)
-                AXUIElementSetAttributeValue(axWindow, kAXMainAttribute as CFString, kCFBooleanTrue)
-                if let app = NSRunningApplication(processIdentifier: pid) {
-                    app.activate()
-                }
-                if let frame = axWindowFrame(axWindow) {
-                    diag.info("Highlighting via AX frame: \(frame)")
-                    DispatchQueue.main.async { WindowHighlight.shared.flash(frame: frame) }
-                } else {
-                    diag.error("axWindowFrame returned nil — no highlight")
-                }
-            }
-            diag.finish(t)
-            return
-        }
-        diag.warn("Path 2 (AX): findWindowViaAX failed — no Accessibility?")
-
-        // Path 3: AppleScript / bare activate fallback
-        diag.warn("Path 3: falling back to AppleScript/activate")
-        activateViaAppleScript(session: session, tag: tag, terminal: terminal)
-        diag.finish(t)
-    }
-
-    private static func navigateToKnownWindow(wid: UInt32, pid: pid_t, tag: String, session: String, terminal: Terminal) {
-        let diag = DiagnosticLog.shared
-        let windowSpaces = getSpacesForWindow(wid)
-        let currentSpace = getCurrentSpace()
-        diag.info("navigateToKnown: wid=\(wid) spaces=\(windowSpaces) current=\(currentSpace)")
-
-        if let windowSpace = windowSpaces.first, windowSpace != currentSpace {
-            diag.info("Switching from space \(currentSpace) → \(windowSpace)")
-            switchToSpace(spaceId: windowSpace)
-            DispatchQueue.main.asyncAfter(deadline: .now() + 0.2) {
-                raiseWindow(pid: pid, tag: tag, terminal: terminal)
-                highlightWindow(session: session)
-            }
-        } else {
-            diag.info("Window on current space — raising + highlighting")
-            raiseWindow(pid: pid, tag: tag, terminal: terminal)
-            highlightWindow(session: session)
-        }
-    }
-
-    /// Find a terminal window by title tag using AX API (requires Accessibility permission)
-    private static func findWindowViaAX(terminal: Terminal, tag: String) -> (pid: pid_t, window: AXUIElement)? {
-        let diag = DiagnosticLog.shared
-        guard let app = NSWorkspace.shared.runningApplications.first(where: {
-            $0.bundleIdentifier == terminal.bundleId
-        }) else {
-            diag.error("findWindowViaAX: \(terminal.rawValue) (\(terminal.bundleId)) not running")
-            return nil
-        }
-
-        let pid = app.processIdentifier
-        let appRef = AXUIElementCreateApplication(pid)
-        var windowsRef: CFTypeRef?
-        let err = AXUIElementCopyAttributeValue(appRef, kAXWindowsAttribute as CFString, &windowsRef)
-        guard err == .success, let windows = windowsRef as? [AXUIElement] else {
-            diag.error("findWindowViaAX: AX error \(err.rawValue) — Accessibility not granted?")
-            return nil
-        }
-
-        diag.info("findWindowViaAX: \(windows.count) windows for \(terminal.rawValue), searching for \(tag)")
-        for win in windows {
-            var titleRef: CFTypeRef?
-            AXUIElementCopyAttributeValue(win, kAXTitleAttribute as CFString, &titleRef)
-            let title = titleRef as? String ?? "<no title>"
-            if title.contains(tag) {
-                diag.success("findWindowViaAX: matched \"\(title)\"")
-                return (pid, win)
-            } else {
-                diag.info("  skip: \"\(title)\"")
-            }
-        }
-        diag.warn("findWindowViaAX: no window matched tag \(tag)")
-        return nil
-    }
-
-    /// Match an AX window to its CG window ID using PID + bounds comparison
-    private static func matchCGWindow(pid: pid_t, axWindow: AXUIElement) -> UInt32? {
-        var posRef: CFTypeRef?
-        var sizeRef: CFTypeRef?
-        AXUIElementCopyAttributeValue(axWindow, kAXPositionAttribute as CFString, &posRef)
-        AXUIElementCopyAttributeValue(axWindow, kAXSizeAttribute as CFString, &sizeRef)
-        guard let pv = posRef, let sv = sizeRef else { return nil }
-
-        var pos = CGPoint.zero
-        var size = CGSize.zero
-        AXValueGetValue(pv as! AXValue, .cgPoint, &pos)
-        AXValueGetValue(sv as! AXValue, .cgSize, &size)
-
-        guard let windowList = CGWindowListCopyWindowInfo([.optionAll, .excludeDesktopElements], kCGNullWindowID) as? [[String: Any]] else { return nil }
-
-        for info in windowList {
-            guard let wPid = info[kCGWindowOwnerPID as String] as? pid_t,
-                  wPid == pid,
-                  let wid = info[kCGWindowNumber as String] as? UInt32,
-                  let boundsDict = info[kCGWindowBounds as String] as? NSDictionary else { continue }
-            var rect = CGRect.zero
-            if CGRectMakeWithDictionaryRepresentation(boundsDict, &rect) {
-                if abs(rect.origin.x - pos.x) < 2 && abs(rect.origin.y - pos.y) < 2 &&
-                   abs(rect.width - size.width) < 2 && abs(rect.height - size.height) < 2 {
-                    return wid
-                }
-            }
-        }
-        return nil
-    }
-
-    /// Get NSRect from an AX window element (AX uses top-left origin, convert to NS bottom-left)
-    private static func axWindowFrame(_ window: AXUIElement) -> NSRect? {
-        var posRef: CFTypeRef?
-        var sizeRef: CFTypeRef?
-        AXUIElementCopyAttributeValue(window, kAXPositionAttribute as CFString, &posRef)
-        AXUIElementCopyAttributeValue(window, kAXSizeAttribute as CFString, &sizeRef)
-        guard let pv = posRef, let sv = sizeRef else { return nil }
-
-        var pos = CGPoint.zero
-        var size = CGSize.zero
-        AXValueGetValue(pv as! AXValue, .cgPoint, &pos)
-        AXValueGetValue(sv as! AXValue, .cgSize, &size)
-
-        guard let primaryScreen = NSScreen.screens.first else { return nil }
-        let primaryHeight = primaryScreen.frame.height
-        return NSRect(x: pos.x, y: primaryHeight - pos.y - size.height, width: size.width, height: size.height)
-    }
-
-    /// Last-resort: use AppleScript for Terminal/iTerm2, or bare activate for others
-    private static func activateViaAppleScript(session: String, tag: String, terminal: Terminal) {
-        switch terminal {
-        case .terminal:
-            runScript("""
-            tell application "Terminal"
-                activate
-                repeat with w in windows
-                    if name of w contains "\(tag)" then
-                        set index of w to 1
-                        exit repeat
-                    end if
-                end repeat
-            end tell
-            """)
-        case .iterm2:
-            runScript("""
-            tell application "iTerm2"
-                activate
-                repeat with w in windows
-                    if name of w contains "\(tag)" then
-                        select w
-                        exit repeat
-                    end if
-                end repeat
-            end tell
-            """)
-        default:
-            if let app = NSWorkspace.shared.runningApplications.first(where: {
-                $0.bundleIdentifier == terminal.bundleId
-            }) {
-                app.activate()
-            }
-        }
-    }
-
-    /// Raise a specific window using AX API + AppleScript
-    private static func raiseWindow(pid: pid_t, tag: String, terminal: Terminal) {
-        let diag = DiagnosticLog.shared
-        let appRef = AXUIElementCreateApplication(pid)
-        var windowsRef: CFTypeRef?
-        let err = AXUIElementCopyAttributeValue(appRef, kAXWindowsAttribute as CFString, &windowsRef)
-        var raised = false
-        if err == .success, let windows = windowsRef as? [AXUIElement] {
-            for win in windows {
-                var titleRef: CFTypeRef?
-                AXUIElementCopyAttributeValue(win, kAXTitleAttribute as CFString, &titleRef)
-                if let title = titleRef as? String, title.contains(tag) {
-                    AXUIElementPerformAction(win, kAXRaiseAction as CFString)
-                    AXUIElementSetAttributeValue(win, kAXMainAttribute as CFString, kCFBooleanTrue)
-                    diag.success("raiseWindow: raised \"\(title)\"")
-                    raised = true
-                    break
-                }
-            }
-        }
-        if !raised {
-            diag.warn("raiseWindow: could not find window with tag \(tag) via AX (err=\(err.rawValue))")
-        }
-
-        if let app = NSRunningApplication(processIdentifier: pid) {
-            app.activate()
-            diag.info("raiseWindow: activated \(app.localizedName ?? "pid:\(pid)")")
-        }
-    }
-
-    // MARK: - Highlight
-
-    /// Flash a highlight border around a session's terminal window
-    static func highlightWindow(session: String) {
-        let diag = DiagnosticLog.shared
-        let tag = Terminal.windowTag(for: session)
-        diag.info("highlightWindow: tag=\(tag)")
-
-        // Path 1: CG approach (needs Screen Recording)
-        if let (wid, _) = findWindow(tag: tag) {
-            diag.info("highlight via CG: wid=\(wid)")
-            guard let windowList = CGWindowListCopyWindowInfo([.optionAll, .excludeDesktopElements], kCGNullWindowID) as? [[String: Any]] else { return }
-            for info in windowList {
-                if let num = info[kCGWindowNumber as String] as? UInt32, num == wid,
-                   let dict = info[kCGWindowBounds as String] as? NSDictionary {
-                    var rect = CGRect.zero
-                    if CGRectMakeWithDictionaryRepresentation(dict, &rect) {
-                        guard let primaryScreen = NSScreen.screens.first else { return }
-                        let primaryHeight = primaryScreen.frame.height
-                        let nsRect = NSRect(
-                            x: rect.origin.x,
-                            y: primaryHeight - rect.origin.y - rect.height,
-                            width: rect.width,
-                            height: rect.height
-                        )
-                        diag.success("highlight CG flash at \(Int(nsRect.origin.x)),\(Int(nsRect.origin.y)) \(Int(nsRect.width))×\(Int(nsRect.height))")
-                        DispatchQueue.main.async { WindowHighlight.shared.flash(frame: nsRect) }
-                    }
-                    return
-                }
-            }
-            diag.warn("highlight CG: wid \(wid) not in window list")
-            return
-        }
-
-        // Path 2: AX fallback — search installed terminals for the tagged window
-        diag.info("highlight: CG failed, trying AX fallback across \(Terminal.installed.count) terminals")
-        for terminal in Terminal.installed {
-            if let (_, axWindow) = findWindowViaAX(terminal: terminal, tag: tag),
-               let frame = axWindowFrame(axWindow) {
-                diag.success("highlight AX flash at \(Int(frame.origin.x)),\(Int(frame.origin.y)) \(Int(frame.width))×\(Int(frame.height))")
-                DispatchQueue.main.async { WindowHighlight.shared.flash(frame: frame) }
-                return
-            }
-        }
-        diag.error("highlight: no method found window — no highlight shown")
-    }
-
-    // MARK: - Window Info
-
-    struct WindowInfo {
-        let spaceIndex: Int           // 1-based space number
-        let displayIndex: Int         // 0-based display index
-        let tilePosition: TilePosition?  // inferred from bounds, nil if free-form
-        let wid: UInt32
-    }
-
-    /// Get spatial info for a session's terminal window (space, display, tile position)
-    static func getWindowInfo(session: String, terminal: Terminal) -> WindowInfo? {
-        let tag = Terminal.windowTag(for: session)
-
-        // Find the window
-        let wid: UInt32
-        if let (w, _) = findWindow(tag: tag) {
-            wid = w
-        } else if let (pid, axWindow) = findWindowViaAX(terminal: terminal, tag: tag),
-                  let w = matchCGWindow(pid: pid, axWindow: axWindow) {
-            wid = w
-        } else {
-            return nil
-        }
-
-        // Determine which space/display the window is on
-        let windowSpaces = getSpacesForWindow(wid)
-        let allDisplays = getDisplaySpaces()
-
-        var spaceIndex = 1
-        var displayIndex = 0
-
-        if let windowSpaceId = windowSpaces.first {
-            for display in allDisplays {
-                if let space = display.spaces.first(where: { $0.id == windowSpaceId }) {
-                    spaceIndex = space.index
-                    displayIndex = display.displayIndex
-                    break
-                }
-            }
-        }
-
-        let tile = inferTilePosition(wid: wid)
-
-        return WindowInfo(
-            spaceIndex: spaceIndex,
-            displayIndex: displayIndex,
-            tilePosition: tile,
-            wid: wid
-        )
-    }
-
-    /// Infer tile position from a window frame + screen without re-querying CGWindowList
-    static func inferTilePosition(frame: WindowFrame, screen: NSScreen) -> TilePosition? {
-        let visible = screen.visibleFrame
-        let full = screen.frame
-
-        // CG top-left origin → visible frame top-left origin
-        let primaryHeight = NSScreen.screens.first?.frame.height ?? full.height
-        let visTop = primaryHeight - visible.maxY
-        let fx = (frame.x - visible.origin.x) / visible.width
-        let fy = (frame.y - visTop) / visible.height
-        let fw = frame.w / visible.width
-        let fh = frame.h / visible.height
-
-        let tolerance: CGFloat = 0.05
-
-        for position in TilePosition.allCases {
-            let (px, py, pw, ph) = position.rect
-            if abs(fx - CGFloat(px)) < tolerance && abs(fy - CGFloat(py)) < tolerance &&
-               abs(fw - CGFloat(pw)) < tolerance && abs(fh - CGFloat(ph)) < tolerance {
-                return position
-            }
-        }
-        return nil
-    }
-
-    /// Infer tile position from a window's current bounds relative to its screen
-    private static func inferTilePosition(wid: UInt32) -> TilePosition? {
-        guard let windowList = CGWindowListCopyWindowInfo([.optionAll, .excludeDesktopElements], kCGNullWindowID) as? [[String: Any]] else {
-            return nil
-        }
-
-        // Find the window's bounds
-        var windowRect = CGRect.zero
-        for info in windowList {
-            if let num = info[kCGWindowNumber as String] as? UInt32, num == wid,
-               let dict = info[kCGWindowBounds as String] as? NSDictionary {
-                CGRectMakeWithDictionaryRepresentation(dict, &windowRect)
-                break
-            }
-        }
-        guard windowRect.width > 0 else { return nil }
-
-        // Find which screen contains the window center
-        let centerX = windowRect.midX
-        let centerY = windowRect.midY
-        guard let primaryScreen = NSScreen.screens.first else { return nil }
-        let primaryHeight = primaryScreen.frame.height
-
-        // CG uses top-left origin; convert to NS bottom-left for screen matching
-        let nsCenterY = primaryHeight - centerY
-
-        let screen = NSScreen.screens.first(where: {
-            $0.frame.contains(NSPoint(x: centerX, y: nsCenterY))
-        }) ?? NSScreen.main ?? primaryScreen
-
-        let visible = screen.visibleFrame
-        let full = screen.frame
-
-        // Convert CG rect to fractional coordinates relative to visible frame
-        // CG top-left origin → visible frame top-left origin
-        let visTop = full.height - visible.maxY + full.origin.y
-        let fx = (windowRect.origin.x - visible.origin.x) / visible.width
-        let fy = (windowRect.origin.y - visTop) / visible.height
-        let fw = windowRect.width / visible.width
-        let fh = windowRect.height / visible.height
-
-        let tolerance: CGFloat = 0.05
-
-        for position in TilePosition.allCases {
-            let (px, py, pw, ph) = position.rect
-            if abs(fx - px) < tolerance && abs(fy - py) < tolerance &&
-               abs(fw - pw) < tolerance && abs(fh - ph) < tolerance {
-                return position
-            }
-        }
-
-        return nil
-    }
-
-    // MARK: - By-ID Window Operations (Desktop Inventory)
-
-    /// Navigate to an arbitrary window by its CG window ID: switch space, raise, highlight
-    static func navigateToWindowById(wid: UInt32, pid: Int32) {
-        let diag = DiagnosticLog.shared
-        diag.info("navigateToWindowById: wid=\(wid) pid=\(pid)")
-
-        // Switch to window's space if needed
-        let windowSpaces = getSpacesForWindow(wid)
-        let currentSpace = getCurrentSpace()
-
-        if let windowSpace = windowSpaces.first, windowSpace != currentSpace {
-            diag.info("Switching from space \(currentSpace) → \(windowSpace)")
-            switchToSpace(spaceId: windowSpace)
-            DispatchQueue.main.asyncAfter(deadline: .now() + 0.2) {
-                raiseWindowById(wid: wid, pid: pid)
-                highlightWindowById(wid: wid)
-            }
-        } else {
-            raiseWindowById(wid: wid, pid: pid)
-            highlightWindowById(wid: wid)
-        }
-    }
-
-    /// Flash a highlight border on any window by its CG window ID
-    static func highlightWindowById(wid: UInt32) {
-        guard let frame = cgWindowFrame(wid: wid) else {
-            DiagnosticLog.shared.warn("highlightWindowById: no frame for wid=\(wid)")
-            return
-        }
-        DispatchQueue.main.async { WindowHighlight.shared.flash(frame: frame) }
-    }
-
-    /// Tile any window by its CG window ID to a position using AX API
-    static func tileWindowById(wid: UInt32, pid: Int32, to position: TilePosition) {
-        let diag = DiagnosticLog.shared
-        diag.info("tileWindowById: wid=\(wid) pid=\(pid) pos=\(position.rawValue)")
-
-        // Find the screen the window is on
-        guard let windowFrame = cgWindowFrame(wid: wid) else {
-            diag.warn("tileWindowById: no frame for wid=\(wid)")
-            return
-        }
-        let screen = NSScreen.screens.first(where: {
-            $0.frame.contains(NSPoint(x: windowFrame.midX, y: windowFrame.midY))
-        }) ?? NSScreen.main ?? NSScreen.screens[0]
-
-        let visible = screen.visibleFrame
-        let (fx, fy, fw, fh) = position.rect
-
-        // Calculate target in NS coordinates (bottom-left origin)
-        let targetX = visible.origin.x + visible.width * fx
-        let targetY = visible.origin.y + visible.height * (1.0 - fy - fh)
-        let targetW = visible.width * fw
-        let targetH = visible.height * fh
-
-        // Convert NS bottom-left → AX top-left origin
-        guard let primaryScreen = NSScreen.screens.first else { return }
-        let primaryHeight = primaryScreen.frame.height
-        let axX = targetX
-        let axY = primaryHeight - targetY - targetH
-
-        // Find the AX window matching this CG wid by frame comparison
-        guard let axWindow = findAXWindowByFrame(wid: wid, pid: pid) else {
-            diag.warn("tileWindowById: couldn't match AX window for wid=\(wid)")
-            return
-        }
-
-        // Set position and size via AX
-        var newPos = CGPoint(x: axX, y: axY)
-        var newSize = CGSize(width: targetW, height: targetH)
-
-        if let posValue = AXValueCreate(.cgPoint, &newPos) {
-            AXUIElementSetAttributeValue(axWindow, kAXPositionAttribute as CFString, posValue)
-        }
-        if let sizeValue = AXValueCreate(.cgSize, &newSize) {
-            AXUIElementSetAttributeValue(axWindow, kAXSizeAttribute as CFString, sizeValue)
-        }
-
-        diag.success("tileWindowById: tiled wid=\(wid) to \(position.rawValue)")
-    }
-
-    /// Distribute windows in a smart grid layout (delegates to batch operation)
-    static func tileDistributeHorizontally(windows: [(wid: UInt32, pid: Int32)]) {
-        batchRaiseAndDistribute(windows: windows)
-    }
-
-    /// Distribute ALL visible non-Lattices windows into a smart grid on the screen with the most windows.
-    static func distributeVisible() {
-        let diag = DiagnosticLog.shared
-        let t = diag.startTimed("distributeVisible")
-
-        let allEntries = DesktopModel.shared.allWindows()
-        let visible = allEntries.filter { entry in
-            entry.isOnScreen && entry.app != "Lattices" && entry.frame.w > 50 && entry.frame.h > 50
-        }
-
-        guard !visible.isEmpty else {
-            diag.info("distributeVisible: no visible windows to distribute")
-            diag.finish(t)
-            return
-        }
-
-        let windows = visible.map { (wid: $0.wid, pid: $0.pid) }
-        diag.info("distributeVisible: \(windows.count) windows")
-        batchRaiseAndDistribute(windows: windows)
-        diag.finish(t)
-    }
-
-    /// Get NSRect (bottom-left origin) for a known CG window ID
-    private static func cgWindowFrame(wid: UInt32) -> NSRect? {
-        guard let windowList = CGWindowListCopyWindowInfo([.optionAll, .excludeDesktopElements], kCGNullWindowID) as? [[String: Any]] else { return nil }
-        for info in windowList {
-            if let num = info[kCGWindowNumber as String] as? UInt32, num == wid,
-               let dict = info[kCGWindowBounds as String] as? NSDictionary {
-                var rect = CGRect.zero
-                if CGRectMakeWithDictionaryRepresentation(dict, &rect) {
-                    guard let primaryScreen = NSScreen.screens.first else { return nil }
-                    let primaryHeight = primaryScreen.frame.height
-                    return NSRect(
-                        x: rect.origin.x,
-                        y: primaryHeight - rect.origin.y - rect.height,
-                        width: rect.width,
-                        height: rect.height
-                    )
-                }
-            }
-        }
-        return nil
-    }
-
-    /// Raise a window by matching its CG window ID to an AX element via frame comparison
-    private static func raiseWindowById(wid: UInt32, pid: Int32) {
-        let diag = DiagnosticLog.shared
-
-        if let axWindow = findAXWindowByFrame(wid: wid, pid: pid) {
-            AXUIElementPerformAction(axWindow, kAXRaiseAction as CFString)
-            AXUIElementSetAttributeValue(axWindow, kAXMainAttribute as CFString, kCFBooleanTrue)
-            diag.success("raiseWindowById: raised wid=\(wid)")
-        } else {
-            diag.warn("raiseWindowById: couldn't match AX window for wid=\(wid)")
-        }
-
-        if let app = NSRunningApplication(processIdentifier: pid) {
-            app.activate()
-        }
-    }
-
-    /// Raise multiple windows at once, re-activating our app once at the end
-    static func raiseWindowsAndReactivate(windows: [(wid: UInt32, pid: Int32)]) {
-        let diag = DiagnosticLog.shared
-        var activatedPids = Set<Int32>()
-        for win in windows {
-            if let axWindow = findAXWindowByFrame(wid: win.wid, pid: win.pid) {
-                AXUIElementPerformAction(axWindow, kAXRaiseAction as CFString)
-                AXUIElementSetAttributeValue(axWindow, kAXMainAttribute as CFString, kCFBooleanTrue)
-            }
-            if !activatedPids.contains(win.pid) {
-                if let app = NSRunningApplication(processIdentifier: win.pid) {
-                    app.activate()
-                    activatedPids.insert(win.pid)
-                }
-            }
-        }
-        diag.success("raiseWindowsAndReactivate: raised \(windows.count) windows")
-        DispatchQueue.main.asyncAfter(deadline: .now() + 0.1) {
-            NSApp.activate(ignoringOtherApps: true)
-        }
-    }
-
-    /// Raise a window to front and then re-activate our own app so the panel stays visible
-    static func raiseWindowAndReactivate(wid: UInt32, pid: Int32) {
-        let diag = DiagnosticLog.shared
-        diag.info("raiseWindowAndReactivate: wid=\(wid) pid=\(pid)")
-
-        // Switch to window's space if needed
-        let windowSpaces = getSpacesForWindow(wid)
-        let currentSpace = getCurrentSpace()
-
-        let doRaise = {
-            if let axWindow = findAXWindowByFrame(wid: wid, pid: pid) {
-                AXUIElementPerformAction(axWindow, kAXRaiseAction as CFString)
-                AXUIElementSetAttributeValue(axWindow, kAXMainAttribute as CFString, kCFBooleanTrue)
-                diag.success("raiseWindowAndReactivate: raised wid=\(wid)")
-            }
-            // Activate target app briefly so window comes to front
-            if let app = NSRunningApplication(processIdentifier: pid) {
-                app.activate()
-            }
-            // Re-activate our app so the panel stays visible
-            DispatchQueue.main.asyncAfter(deadline: .now() + 0.15) {
-                NSApp.activate(ignoringOtherApps: true)
-            }
-        }
-
-        if let windowSpace = windowSpaces.first, windowSpace != currentSpace {
-            diag.info("Switching from space \(currentSpace) → \(windowSpace)")
-            switchToSpace(spaceId: windowSpace)
-            DispatchQueue.main.asyncAfter(deadline: .now() + 0.2) { doRaise() }
-        } else {
-            doRaise()
-        }
-    }
-
-    // MARK: - Batch Window Operations
-
-    /// Move multiple windows to target frames in one shot.
-    /// Single CGWindowList query, single AX query per process, all moves synchronous.
-    static func batchMoveWindows(_ moves: [(wid: UInt32, pid: Int32, frame: CGRect)]) {
-        guard !moves.isEmpty else { return }
-        let diag = DiagnosticLog.shared
-
-        // Group by pid so we query each app's AX windows once
-        var byPid: [Int32: [(wid: UInt32, target: CGRect)]] = [:]
-        for move in moves {
-            byPid[move.pid, default: []].append((wid: move.wid, target: move.frame))
-        }
-
-        // For each process: get AX windows, match by CGWindowID, move+resize
-        var moved = 0
-        var failed = 0
-        for (pid, windowMoves) in byPid {
-            let appRef = AXUIElementCreateApplication(pid)
-            var windowsRef: CFTypeRef?
-            let err = AXUIElementCopyAttributeValue(appRef, kAXWindowsAttribute as CFString, &windowsRef)
-            guard err == .success, let axWindows = windowsRef as? [AXUIElement] else {
-                diag.info("[batchMove] AX query failed for pid \(pid)")
-                failed += windowMoves.count
-                continue
-            }
-
-            // Build wid → AXUIElement map using _AXUIElementGetWindow
-            var axByWid: [UInt32: AXUIElement] = [:]
-            for axWin in axWindows {
-                var windowId: CGWindowID = 0
-                if _AXUIElementGetWindow(axWin, &windowId) == .success {
-                    axByWid[windowId] = axWin
-                }
-            }
-
-            for wm in windowMoves {
-                guard let axWin = axByWid[wm.wid] else {
-                    diag.info("[batchMove] no AX match for wid \(wm.wid)")
-                    failed += 1
-                    continue
-                }
-
-                applyFrameToAXWindow(axWin, wid: wm.wid, target: wm.target)
-                moved += 1
-            }
-        }
-        if failed > 0 {
-            diag.info("[batchMove] \(failed) windows failed to match")
-        }
-        diag.success("batchMoveWindows: moved \(moved)/\(moves.count) windows")
-    }
-
-    /// Apply position+size to a single AX window. No delays, no retries — just set and go.
-    private static func applyFrameToAXWindow(_ axWin: AXUIElement, wid: UInt32, target: CGRect) {
-        var newPos = CGPoint(x: target.origin.x, y: target.origin.y)
-        var newSize = CGSize(width: target.width, height: target.height)
-
-        // Size first (avoids clipping at screen edges), then position
-        if let sv = AXValueCreate(.cgSize, &newSize) {
-            AXUIElementSetAttributeValue(axWin, kAXSizeAttribute as CFString, sv)
-        }
-        if let pv = AXValueCreate(.cgPoint, &newPos) {
-            AXUIElementSetAttributeValue(axWin, kAXPositionAttribute as CFString, pv)
-        }
-    }
-
-    /// Read back current AX position+size for a window element.
-    static func readAXFrame(_ axWin: AXUIElement) -> CGRect? {
-        var posRef: CFTypeRef?
-        var sizeRef: CFTypeRef?
-        guard AXUIElementCopyAttributeValue(axWin, kAXPositionAttribute as CFString, &posRef) == .success,
-              AXUIElementCopyAttributeValue(axWin, kAXSizeAttribute as CFString, &sizeRef) == .success else {
-            return nil
-        }
-        var pos = CGPoint.zero
-        var size = CGSize.zero
-        guard AXValueGetValue(posRef as! AXValue, .cgPoint, &pos),
-              AXValueGetValue(sizeRef as! AXValue, .cgSize, &size) else {
-            return nil
-        }
-        return CGRect(origin: pos, size: size)
-    }
-
-    /// Verify which windows drifted from their targets using CGWindowList.
-    /// Returns array of moves that still need correction.
-    static func verifyMoves(_ moves: [(wid: UInt32, pid: Int32, frame: CGRect)], tolerance: CGFloat = 4) -> [(wid: UInt32, pid: Int32, frame: CGRect)] {
-        guard let rawList = CGWindowListCopyWindowInfo([.optionAll, .excludeDesktopElements], kCGNullWindowID) as? [[String: Any]] else {
-            return moves  // can't verify, return all
-        }
-
-        var actualByWid: [UInt32: CGRect] = [:]
-        for info in rawList {
-            guard let wid = info[kCGWindowNumber as String] as? UInt32,
-                  let bounds = info[kCGWindowBounds as String] as? [String: Any],
-                  let x = bounds["X"] as? CGFloat, let y = bounds["Y"] as? CGFloat,
-                  let w = bounds["Width"] as? CGFloat, let h = bounds["Height"] as? CGFloat else { continue }
-            actualByWid[wid] = CGRect(x: x, y: y, width: w, height: h)
-        }
-
-        let diag = DiagnosticLog.shared
-        var drifted: [(wid: UInt32, pid: Int32, frame: CGRect)] = []
-        for move in moves {
-            guard let actual = actualByWid[move.wid] else {
-                drifted.append(move)
-                continue
-            }
-            let dx = abs(actual.origin.x - move.frame.origin.x)
-            let dy = abs(actual.origin.y - move.frame.origin.y)
-            let dw = abs(actual.width - move.frame.width)
-            let dh = abs(actual.height - move.frame.height)
-            if dx > tolerance || dy > tolerance || dw > tolerance || dh > tolerance {
-                diag.info("[verify] wid \(move.wid) drifted: target \(move.frame) actual \(actual) (dx=\(Int(dx)) dy=\(Int(dy)) dw=\(Int(dw)) dh=\(Int(dh)))")
-                drifted.append(move)
-            }
-        }
-        return drifted
-    }
-
-    /// Raise and focus a single window by its CGWindowID.
-    static func focusWindow(wid: UInt32, pid: Int32) {
-        let appRef = AXUIElementCreateApplication(pid)
-        var windowsRef: CFTypeRef?
-        guard AXUIElementCopyAttributeValue(appRef, kAXWindowsAttribute as CFString, &windowsRef) == .success,
-              let axWindows = windowsRef as? [AXUIElement] else { return }
-
-        for axWin in axWindows {
-            var windowId: CGWindowID = 0
-            if _AXUIElementGetWindow(axWin, &windowId) == .success, windowId == wid {
-                AXUIElementPerformAction(axWin, kAXRaiseAction as CFString)
-                AXUIElementSetAttributeValue(axWin, kAXMainAttribute as CFString, kCFBooleanTrue)
-                break
-            }
-        }
-
-        if let app = NSRunningApplication(processIdentifier: pid) {
-            app.activate()
-        }
-    }
-
-    /// Move AND raise windows in a single CG+AX pass (avoids duplicate lookups).
-    /// Does not reactivate lattices at the end — caller controls that.
-    static func batchMoveAndRaiseWindows(_ moves: [(wid: UInt32, pid: Int32, frame: CGRect)]) {
-        guard !moves.isEmpty else { return }
-        let diag = DiagnosticLog.shared
-
-        var byPid: [Int32: [(wid: UInt32, target: CGRect)]] = [:]
-        for move in moves {
-            byPid[move.pid, default: []].append((wid: move.wid, target: move.frame))
-        }
-
-        var processed = 0
-        var activatedPids = Set<Int32>()
-
-        for (pid, windowMoves) in byPid {
-            let appRef = AXUIElementCreateApplication(pid)
-            var windowsRef: CFTypeRef?
-            let err = AXUIElementCopyAttributeValue(appRef, kAXWindowsAttribute as CFString, &windowsRef)
-            guard err == .success, let axWindows = windowsRef as? [AXUIElement] else { continue }
-
-            // Build wid → AXUIElement map using _AXUIElementGetWindow
-            var axByWid: [UInt32: AXUIElement] = [:]
-            for axWin in axWindows {
-                var windowId: CGWindowID = 0
-                if _AXUIElementGetWindow(axWin, &windowId) == .success {
-                    axByWid[windowId] = axWin
-                }
-            }
-
-            for wm in windowMoves {
-                guard let axWin = axByWid[wm.wid] else { continue }
-
-                var newPos = CGPoint(x: wm.target.origin.x, y: wm.target.origin.y)
-                var newSize = CGSize(width: wm.target.width, height: wm.target.height)
-
-                // Position → Size → Position (double-set avoids clipping/snapping)
-                if let pv = AXValueCreate(.cgPoint, &newPos) {
-                    AXUIElementSetAttributeValue(axWin, kAXPositionAttribute as CFString, pv)
-                }
-                if let sv = AXValueCreate(.cgSize, &newSize) {
-                    AXUIElementSetAttributeValue(axWin, kAXSizeAttribute as CFString, sv)
-                }
-                if let pv = AXValueCreate(.cgPoint, &newPos) {
-                    AXUIElementSetAttributeValue(axWin, kAXPositionAttribute as CFString, pv)
-                }
-
-                // Raise
-                AXUIElementPerformAction(axWin, kAXRaiseAction as CFString)
-                AXUIElementSetAttributeValue(axWin, kAXMainAttribute as CFString, kCFBooleanTrue)
-
-                processed += 1
-            }
-
-            // Activate each app once so its windows come to front
-            if !activatedPids.contains(pid) {
-                if let app = NSRunningApplication(processIdentifier: pid) {
-                    app.activate()
-                    activatedPids.insert(pid)
-                }
-            }
-        }
-        diag.success("batchMoveAndRaiseWindows: processed \(processed)/\(moves.count) windows")
-    }
-
-    // MARK: - Grid Layout Strategy
-
-    /// Optimal grid shapes for common window counts.
-    /// Returns array of column counts per row (top row first).
-    /// e.g. 5 → [3, 2] means 3 on top row, 2 on bottom row.
-    static func gridShape(for count: Int) -> [Int] {
-        switch count {
-        case 1:  return [1]
-        case 2:  return [2]
-        case 3:  return [3]
-        case 4:  return [2, 2]
-        case 5:  return [3, 2]
-        case 6:  return [3, 3]
-        case 7:  return [4, 3]
-        case 8:  return [4, 4]
-        case 9:  return [3, 3, 3]
-        case 10: return [5, 5]
-        case 11: return [4, 4, 3]
-        case 12: return [4, 4, 4]
-        default:
-            // General: bias toward more columns (landscape screens)
-            let cols = Int(ceil(sqrt(Double(count) * 1.5)))
-            var rows: [Int] = []
-            var remaining = count
-            while remaining > 0 {
-                rows.append(min(cols, remaining))
-                remaining -= cols
-            }
-            return rows
-        }
-    }
-
-    /// Compute grid slot rects in AX coordinates (top-left origin) for N windows
-    static func computeGridSlots(count: Int, screen: NSScreen) -> [CGRect] {
-        guard count > 0 else { return [] }
-        let visible = screen.visibleFrame
-        guard let primaryScreen = NSScreen.screens.first else { return [] }
-        let primaryHeight = primaryScreen.frame.height
-
-        // AX Y of visible top edge
-        let axTop = primaryHeight - visible.maxY
-        let shape = gridShape(for: count)
-        let rowCount = shape.count
-        let rowH = visible.height / CGFloat(rowCount)
-
-        var slots: [CGRect] = []
-        for (row, cols) in shape.enumerated() {
-            let colW = visible.width / CGFloat(cols)
-            let axY = axTop + CGFloat(row) * rowH
-            for col in 0..<cols {
-                let x = visible.origin.x + CGFloat(col) * colW
-                slots.append(CGRect(x: x, y: axY, width: colW, height: rowH))
-            }
-        }
-        return slots
-    }
-
-    /// Raise multiple windows and arrange in smart grid — single CG query, single AX query per process
-    static func batchRaiseAndDistribute(windows: [(wid: UInt32, pid: Int32)]) {
-        guard !windows.isEmpty else { return }
-        let diag = DiagnosticLog.shared
-
-        // Find screen from first window
-        guard let firstFrame = cgWindowFrame(wid: windows[0].wid) else {
-            diag.warn("batchRaiseAndDistribute: no frame for first window wid=\(windows[0].wid)")
-            return
-        }
-        let screen = NSScreen.screens.first(where: {
-            $0.frame.contains(NSPoint(x: firstFrame.midX, y: firstFrame.midY))
-        }) ?? NSScreen.main ?? NSScreen.screens[0]
-
-        let visible = screen.visibleFrame
-        let screenFrame = screen.frame
-        let primaryHeight = NSScreen.screens.first?.frame.height ?? 0
-        let shape = gridShape(for: windows.count)
-        let desc = shape.map(String.init).joined(separator: "+")
-
-        diag.info("Grid layout: \(windows.count) windows → [\(desc)]")
-        diag.info("  Screen: \(screen.localizedName) \(Int(screenFrame.width))x\(Int(screenFrame.height))")
-        diag.info("  Visible: origin=(\(Int(visible.origin.x)),\(Int(visible.origin.y))) size=\(Int(visible.width))x\(Int(visible.height))")
-        diag.info("  Primary height: \(Int(primaryHeight))")
-
-        // Pre-compute all target slots
-        let slots = computeGridSlots(count: windows.count, screen: screen)
-        guard slots.count == windows.count else {
-            diag.warn("  Slot count mismatch: \(slots.count) slots for \(windows.count) windows")
-            return
-        }
-
-        for (i, slot) in slots.enumerated() {
-            diag.info("  Slot \(i): x=\(Int(slot.origin.x)) y=\(Int(slot.origin.y)) w=\(Int(slot.width)) h=\(Int(slot.height))")
-        }
-
-        // Single CG query for frame lookup
-        let windowList = CGWindowListCopyWindowInfo([.optionAll, .excludeDesktopElements], kCGNullWindowID) as? [[String: Any]] ?? []
-        var cgFrames: [UInt32: CGRect] = [:]
-        var cgNames: [UInt32: String] = [:]
-        for info in windowList {
-            guard let num = info[kCGWindowNumber as String] as? UInt32,
-                  let dict = info[kCGWindowBounds as String] as? NSDictionary else { continue }
-            var rect = CGRect.zero
-            if CGRectMakeWithDictionaryRepresentation(dict, &rect) { cgFrames[num] = rect }
-            cgNames[num] = info[kCGWindowOwnerName as String] as? String
-        }
-
-        // Log before frames
-        for (i, win) in windows.enumerated() {
-            let app = cgNames[win.wid] ?? "?"
-            if let cg = cgFrames[win.wid] {
-                diag.info("  Before[\(i)] wid=\(win.wid) \(app): x=\(Int(cg.origin.x)) y=\(Int(cg.origin.y)) w=\(Int(cg.width)) h=\(Int(cg.height))")
-            } else {
-                diag.warn("  Before[\(i)] wid=\(win.wid) \(app): NO CG FRAME")
-            }
-        }
-
-        // Group by pid for AX queries, keep slot mapping
-        var widToSlot: [UInt32: Int] = [:]
-        for (i, win) in windows.enumerated() { widToSlot[win.wid] = i }
-
-        var byPid: [Int32: [(wid: UInt32, target: CGRect)]] = [:]
-        for (i, win) in windows.enumerated() {
-            byPid[win.pid, default: []].append((wid: win.wid, target: slots[i]))
-        }
-
-        struct AXWin { let el: AXUIElement; let pos: CGPoint; let size: CGSize }
-
-        // Pass 1: Move all windows to target positions (no raise yet)
-        var moved = 0
-        var failed: [UInt32] = []
-        var resolvedAXElements: [(slotIdx: Int, el: AXUIElement)] = [] // for raise pass
-
-        for (pid, windowMoves) in byPid {
-            let appRef = AXUIElementCreateApplication(pid)
-            var windowsRef: CFTypeRef?
-            let err = AXUIElementCopyAttributeValue(appRef, kAXWindowsAttribute as CFString, &windowsRef)
-            guard err == .success, let axWindows = windowsRef as? [AXUIElement] else {
-                diag.warn("  AX query failed for pid=\(pid) err=\(err.rawValue)")
-                failed.append(contentsOf: windowMoves.map(\.wid))
-                continue
-            }
-
-            var axCache: [AXWin] = []
-            for axWin in axWindows {
-                var posRef: CFTypeRef?; var sizeRef: CFTypeRef?
-                AXUIElementCopyAttributeValue(axWin, kAXPositionAttribute as CFString, &posRef)
-                AXUIElementCopyAttributeValue(axWin, kAXSizeAttribute as CFString, &sizeRef)
-                guard let pv = posRef, let sv = sizeRef else { continue }
-                var pos = CGPoint.zero; var size = CGSize.zero
-                AXValueGetValue(pv as! AXValue, .cgPoint, &pos)
-                AXValueGetValue(sv as! AXValue, .cgSize, &size)
-                axCache.append(AXWin(el: axWin, pos: pos, size: size))
-            }
-
-            for wm in windowMoves {
-                guard let cgRect = cgFrames[wm.wid] else {
-                    diag.warn("  wid=\(wm.wid): no CG frame, skipping")
-                    failed.append(wm.wid)
-                    continue
-                }
-                guard let ax = axCache.first(where: {
-                    abs(cgRect.origin.x - $0.pos.x) < 2 && abs(cgRect.origin.y - $0.pos.y) < 2 &&
-                    abs(cgRect.width - $0.size.width) < 2 && abs(cgRect.height - $0.size.height) < 2
-                }) else {
-                    diag.warn("  wid=\(wm.wid): CG frame (\(Int(cgRect.origin.x)),\(Int(cgRect.origin.y)) \(Int(cgRect.width))x\(Int(cgRect.height))) — no AX match among \(axCache.count) AX windows")
-                    for (j, axw) in axCache.enumerated() {
-                        diag.info("    AX[\(j)]: pos=(\(Int(axw.pos.x)),\(Int(axw.pos.y))) size=\(Int(axw.size.width))x\(Int(axw.size.height))")
-                    }
-                    failed.append(wm.wid)
-                    continue
-                }
-
-                let slotIdx = widToSlot[wm.wid] ?? -1
-                // Move only — raise comes later
-                var newPos = CGPoint(x: wm.target.origin.x, y: wm.target.origin.y)
-                var newSize = CGSize(width: wm.target.width, height: wm.target.height)
-                let posOk = AXValueCreate(.cgPoint, &newPos).map {
-                    AXUIElementSetAttributeValue(ax.el, kAXPositionAttribute as CFString, $0)
-                }
-                let sizeOk = AXValueCreate(.cgSize, &newSize).map {
-                    AXUIElementSetAttributeValue(ax.el, kAXSizeAttribute as CFString, $0)
-                }
-                diag.info("  Move[\(slotIdx)] wid=\(wm.wid): target=(\(Int(wm.target.origin.x)),\(Int(wm.target.origin.y))) \(Int(wm.target.width))x\(Int(wm.target.height)) posErr=\(posOk?.rawValue ?? -1) sizeErr=\(sizeOk?.rawValue ?? -1)")
-                resolvedAXElements.append((slotIdx: slotIdx, el: ax.el))
-                moved += 1
-            }
-        }
-
-        // Pass 2: Raise all windows in slot order so they all come to front
-        // Sort by slot index so the layout order is predictable
-        resolvedAXElements.sort { $0.slotIdx < $1.slotIdx }
-        for item in resolvedAXElements {
-            AXUIElementPerformAction(item.el, kAXRaiseAction as CFString)
-        }
-        diag.info("  Raised \(resolvedAXElements.count) windows in slot order")
-
-        // Pass 3: Activate all apps so windows come to front of other apps
-        var activatedPids = Set<Int32>()
-        for win in windows {
-            if !activatedPids.contains(win.pid) {
-                if let app = NSRunningApplication(processIdentifier: win.pid) { app.activate() }
-                activatedPids.insert(win.pid)
-            }
-        }
-
-        if !failed.isEmpty {
-            diag.warn("batchRaiseAndDistribute: failed wids=\(failed)")
-        }
-        diag.success("batchRaiseAndDistribute: moved \(moved)/\(windows.count) [\(desc) grid]")
-        DispatchQueue.main.asyncAfter(deadline: .now() + 0.05) {
-            NSApp.activate(ignoringOtherApps: true)
-        }
-    }
-
-    /// Batch restore windows to saved frames (single CG query)
-    static func batchRestoreWindows(_ restores: [(wid: UInt32, pid: Int32, frame: WindowFrame)]) {
-        let moves = restores.map { (wid: $0.wid, pid: $0.pid,
-                                     frame: CGRect(x: $0.frame.x, y: $0.frame.y,
-                                                   width: $0.frame.w, height: $0.frame.h)) }
-        batchMoveWindows(moves)
-    }
-
-    /// Restore a window to a saved frame (CG coordinates: top-left origin)
-    static func restoreWindowFrame(wid: UInt32, pid: Int32, frame: WindowFrame) {
-        guard let axWindow = findAXWindowByFrame(wid: wid, pid: pid) else {
-            DiagnosticLog.shared.warn("restoreWindowFrame: couldn't match AX window for wid=\(wid)")
-            return
-        }
-        var newPos = CGPoint(x: frame.x, y: frame.y)
-        var newSize = CGSize(width: frame.w, height: frame.h)
-        if let posValue = AXValueCreate(.cgPoint, &newPos) {
-            AXUIElementSetAttributeValue(axWindow, kAXPositionAttribute as CFString, posValue)
-        }
-        if let sizeValue = AXValueCreate(.cgSize, &newSize) {
-            AXUIElementSetAttributeValue(axWindow, kAXSizeAttribute as CFString, sizeValue)
-        }
-        DiagnosticLog.shared.success("restoreWindowFrame: restored wid=\(wid)")
-    }
-
-    /// Find the AX window element for a given CG window ID by matching frames
-    static func findAXWindowByFrame(wid: UInt32, pid: Int32) -> AXUIElement? {
-        // Get CG frame for the window
-        guard let windowList = CGWindowListCopyWindowInfo([.optionAll, .excludeDesktopElements], kCGNullWindowID) as? [[String: Any]] else { return nil }
-
-        var cgRect = CGRect.zero
-        for info in windowList {
-            if let num = info[kCGWindowNumber as String] as? UInt32, num == wid,
-               let dict = info[kCGWindowBounds as String] as? NSDictionary {
-                CGRectMakeWithDictionaryRepresentation(dict, &cgRect)
-                break
-            }
-        }
-        guard cgRect.width > 0 else { return nil }
-
-        // Find AX window with matching frame
-        let appRef = AXUIElementCreateApplication(pid)
-        var windowsRef: CFTypeRef?
-        let err = AXUIElementCopyAttributeValue(appRef, kAXWindowsAttribute as CFString, &windowsRef)
-        guard err == .success, let windows = windowsRef as? [AXUIElement] else { return nil }
-
-        for win in windows {
-            var posRef: CFTypeRef?
-            var sizeRef: CFTypeRef?
-            AXUIElementCopyAttributeValue(win, kAXPositionAttribute as CFString, &posRef)
-            AXUIElementCopyAttributeValue(win, kAXSizeAttribute as CFString, &sizeRef)
-            guard let pv = posRef, let sv = sizeRef else { continue }
-
-            var pos = CGPoint.zero
-            var size = CGSize.zero
-            AXValueGetValue(pv as! AXValue, .cgPoint, &pos)
-            AXValueGetValue(sv as! AXValue, .cgSize, &size)
-
-            if abs(cgRect.origin.x - pos.x) < 2 && abs(cgRect.origin.y - pos.y) < 2 &&
-               abs(cgRect.width - size.width) < 2 && abs(cgRect.height - size.height) < 2 {
-                return win
-            }
-        }
-        return nil
-    }
-
-    // MARK: - Any-App Tiling via Accessibility
-
-    /// Tile the frontmost window of any app to a position using AX API.
-    /// Works for any application (Finder, Chrome, etc.), not just terminals.
-    static func tileFrontmostViaAX(to position: TilePosition) {
-        // 1. Get frontmost application
-        guard let frontApp = NSWorkspace.shared.frontmostApplication,
-              frontApp.bundleIdentifier != "com.arach.lattices" else { return }
-
-        let appRef = AXUIElementCreateApplication(frontApp.processIdentifier)
-
-        // 2. Get focused window
-        var focusedRef: CFTypeRef?
-        guard AXUIElementCopyAttributeValue(appRef, kAXFocusedWindowAttribute as CFString, &focusedRef) == .success,
-              let axWindow = focusedRef else { return }
-
-        let win = axWindow as! AXUIElement
-
-        // 3. Read current position → find containing screen (AX coords: top-left origin)
-        var posRef: CFTypeRef?
-        var sizeRef: CFTypeRef?
-        AXUIElementCopyAttributeValue(win, kAXPositionAttribute as CFString, &posRef)
-        AXUIElementCopyAttributeValue(win, kAXSizeAttribute as CFString, &sizeRef)
-
-        var currentPos = CGPoint.zero
-        var currentSize = CGSize.zero
-        if let pv = posRef { AXValueGetValue(pv as! AXValue, .cgPoint, &currentPos) }
-        if let sv = sizeRef { AXValueGetValue(sv as! AXValue, .cgSize, &currentSize) }
-
-        let primaryHeight = NSScreen.screens.first?.frame.height ?? 1080
-        let nsCenterX = currentPos.x + currentSize.width / 2
-        let nsCenterY = primaryHeight - (currentPos.y + currentSize.height / 2)
-        let screen = NSScreen.screens.first(where: {
-            $0.frame.contains(NSPoint(x: nsCenterX, y: nsCenterY))
-        }) ?? NSScreen.main ?? NSScreen.screens[0]
-
-        // 4. Compute target frame (AX/CGS coords: top-left origin)
-        let targetFrame = tileFrame(for: position, on: screen)
-        var newPos = CGPoint(x: targetFrame.origin.x, y: targetFrame.origin.y)
-        var newSize = CGSize(width: targetFrame.width, height: targetFrame.height)
-
-        // 5. Try SkyLight fast path (instant, no animation)
-        var wid: CGWindowID = 0
-        let hasSkyLight = _SLSMainConnectionID != nil
-            && _SLSMoveWindow != nil
-            && _AXUIElementGetWindow(win, &wid) == .success
-            && wid != 0
-
-        if hasSkyLight {
-            let cid = _SLSMainConnectionID!()
-
-            // Resize via AX (app must handle its own content layout)
-            if let sv = AXValueCreate(.cgSize, &newSize) {
-                AXUIElementSetAttributeValue(win, kAXSizeAttribute as CFString, sv)
-            }
-
-            // Move via SkyLight (instant, no animation)
-            if _SLSMoveWindow!(cid, UInt32(wid), &newPos) != .success {
-                // SLS move failed — fall back to AX position
-                if let pv = AXValueCreate(.cgPoint, &newPos) {
-                    AXUIElementSetAttributeValue(win, kAXPositionAttribute as CFString, pv)
-                }
-            }
-        } else {
-            // 6. AX fallback: size then position
-            if let sv = AXValueCreate(.cgSize, &newSize) {
-                AXUIElementSetAttributeValue(win, kAXSizeAttribute as CFString, sv)
-            }
-            if let pv = AXValueCreate(.cgPoint, &newPos) {
-                AXUIElementSetAttributeValue(win, kAXPositionAttribute as CFString, pv)
-            }
-        }
-    }
-
-    // MARK: - Private
-
-    private static func tileAppleScript(app: String, tag: String, bounds: (Int, Int, Int, Int)) {
-        let (x1, y1, x2, y2) = bounds
-        let script = """
-        tell application "\(app)"
-            repeat with w in windows
-                if name of w contains "\(tag)" then
-                    set bounds of w to {\(x1), \(y1), \(x2), \(y2)}
-                    set index of w to 1
-                    exit repeat
-                end if
-            end repeat
-        end tell
-        """
-        runScript(script)
-    }
-
-    private static func tileFrontmost(bounds: (Int, Int, Int, Int)) {
-        let (x1, y1, x2, y2) = bounds
-        let script = """
-        tell application "System Events"
-            set frontApp to name of first application process whose frontmost is true
-        end tell
-        tell application frontApp
-            set bounds of front window to {\(x1), \(y1), \(x2), \(y2)}
-        end tell
-        """
-        runScript(script)
-    }
-
-    private static func runScript(_ script: String) {
-        let task = Process()
-        task.executableURL = URL(fileURLWithPath: "/usr/bin/osascript")
-        task.arguments = ["-e", script]
-        task.standardOutput = FileHandle.nullDevice
-        task.standardError = FileHandle.nullDevice
-        try? task.run()
-    }
-}