@lattices/cli 0.4.5 → 0.4.6

package/app/Info.plist

@@ -15,9 +15,9 @@
     <key>CFBundlePackageType</key>
     <string>APPL</string>
     <key>CFBundleVersion</key>
-    <string>0.4.5</string>
+    <string>0.4.6</string>
     <key>CFBundleShortVersionString</key>
-    <string>0.4.5</string>
+    <string>0.4.6</string>
     <key>LSMinimumSystemVersion</key>
     <string>13.0</string>
     <key>LSUIElement</key>

package/app/Lattices.app/Contents/Info.plist

@@ -15,9 +15,9 @@
     <key>CFBundlePackageType</key>
     <string>APPL</string>
     <key>CFBundleVersion</key>
-    <string>0.4.5</string>
+    <string>0.4.6</string>
     <key>CFBundleShortVersionString</key>
-    <string>0.4.5</string>
+    <string>0.4.6</string>
     <key>LSMinimumSystemVersion</key>
     <string>13.0</string>
     <key>LSUIElement</key>

package/app/Sources/{AppDelegate.swift → AppShell/AppDelegate.swift}

@@ -91,6 +91,10 @@ class AppDelegate: NSObject, NSApplicationDelegate, NSPopoverDelegate {
         store.register(action: .unifiedWindow) { ScreenMapWindowController.shared.toggle() }
         store.register(action: .bezel) { Self.showWorkspaceInspector() }
         store.register(action: .cheatSheet) { SettingsWindowController.shared.show() }
+        store.register(action: .desktopInventory) {
+            DiagnosticLog.shared.info("Hotkey: desktopInventory triggered")
+            ScreenMapWindowController.shared.showPage(.desktopInventory)
+        }
         store.register(action: .voiceCommand) {
             DiagnosticLog.shared.info("Hotkey: voiceCommand triggered")
             VoiceCommandWindow.shared.toggle()

package/app/Sources/{AppShellView.swift → AppShell/AppShellView.swift}

@@ -56,6 +56,10 @@ struct AppShellView: View {
         .background(Palette.bg)
         .onAppear {
             commandState.onDismiss = { windowController.activePage = .home }
+            syncPageState(windowController.activePage)
+        }
+        .onChange(of: windowController.activePage) { page in
+            syncPageState(page)
         }
     }
 
@@ -116,7 +120,7 @@ struct AppShellView: View {
                 windowController.activePage = page
             })
         case .desktopInventory:
-            CommandModeView(state: commandState)
+            CommandModeView(state: commandState, presentation: .embedded)
         case .pi:
             PiWorkspaceView()
         case .settings:
@@ -134,4 +138,9 @@ struct AppShellView: View {
             )
         }
     }
+
+    private func syncPageState(_ page: AppPage) {
+        if page == .screenMap { controller.enter() }
+        if page == .desktopInventory { commandState.enter() }
+    }
 }

package/app/Sources/{HotkeyStore.swift → Core/Actions/HotkeyStore.swift}

@@ -40,7 +40,7 @@ enum HotkeyAction: String, CaseIterable, Codable {
         case .screenMap:       return "Screen Map"
         case .bezel:           return "Window Bezel"
         case .cheatSheet:      return "Cheat Sheet"
-        case .desktopInventory: return "Search"
+        case .desktopInventory: return "Window Selector"
         case .omniSearch:      return "Search"
         case .voiceCommand:    return "Voice Command"
         case .handsOff:        return "Hands-Off Mode"
@@ -231,6 +231,7 @@ class HotkeyStore: ObservableObject {
         bind(.unifiedWindow, 18, hyper)  // Hyper+1 (Workspace Home)
         bind(.bezel,     19, hyper)      // Hyper+2
         bind(.hud,       20, hyper)      // Hyper+3 (HUD overlay)
+        bind(.desktopInventory, 5, hyper) // Hyper+G
         bind(.voiceCommand, 21, hyper)   // Hyper+4 (moved from Hyper+3)
         let cmdCtrl = UInt32(cmdKey | controlKey)
         bind(.handsOff, 46, cmdCtrl)          // Ctrl+Cmd+M

package/app/Sources/{IntentEngine.swift → Core/Actions/IntentEngine.swift}

@@ -1,31 +1,5 @@
 import AppKit
 
-// MARK: - Intent Definition
-
-struct IntentDef {
-    let name: String
-    let description: String
-    let examples: [String]           // Example phrases that map to this intent
-    let slots: [IntentSlot]          // Named parameters extracted from the utterance
-    let handler: (IntentRequest) throws -> JSON
-}
-
-struct IntentSlot {
-    let name: String
-    let type: String                 // "string", "int", "position", "query"
-    let required: Bool
-    let description: String
-    let enumValues: [String]?        // For constrained slots like tile positions
-}
-
-struct IntentRequest {
-    let intent: String
-    let slots: [String: JSON]
-    let rawText: String?             // Original transcription, for fallback matching
-    let confidence: Double?          // Transcription confidence from voice service
-    let source: String?              // "vox", "siri", "cli", etc.
-}
-
 // MARK: - Intent Engine
 
 final class IntentEngine {
@@ -133,6 +107,8 @@ final class IntentEngine {
                            description: "Target window ID", enumValues: nil),
                 IntentSlot(name: "session", type: "string", required: false,
                            description: "Target session name", enumValues: nil),
+                IntentSlot(name: "selection", type: "bool", required: false,
+                           description: "Apply to the active multi-window selection instead of a single window", enumValues: nil),
             ],
             handler: { req in
                 guard let posStr = req.slots["position"]?.stringValue else {
@@ -176,6 +152,34 @@ final class IntentEngine {
                     throw IntentError.targetNotFound("No window found for app '\(app)'")
                 }
 
+                if req.slots["selection"]?.boolValue == true {
+                    let selectionIds = WindowSelectionStore.shared.windowIds
+                    guard !selectionIds.isEmpty else {
+                        throw IntentError.targetNotFound("No active window selection")
+                    }
+
+                    if selectionIds.count == 1,
+                       let wid = selectionIds.first,
+                       let entry = DesktopModel.shared.windows[wid] {
+                        tileEntry(entry)
+                        return .object([
+                            "ok": .bool(true),
+                            "target": .string("selection"),
+                            "wid": .int(Int(wid)),
+                            "position": .string(posStr)
+                        ])
+                    }
+
+                    return try LatticesApi.shared.dispatch(
+                        method: "space.optimize",
+                        params: .object([
+                            "scope": .string("selection"),
+                            "windowIds": .array(selectionIds.map { .int(Int($0)) }),
+                            "region": .string(posStr)
+                        ])
+                    )
+                }
+
                 // Default: tile frontmost window
                 DispatchQueue.main.async {
                     WindowTiler.tileFrontmostViaAX(to: placement)
@@ -401,6 +405,8 @@ final class IntentEngine {
                            description: "Constrain the grid to a screen region. Uses tile position names.",
                            enumValues: ["left", "right", "top", "bottom", "top-left", "top-right", "bottom-left", "bottom-right",
                                         "left-third", "center-third", "right-third"]),
+                IntentSlot(name: "selection", type: "bool", required: false,
+                           description: "Use the active selected windows instead of all visible windows", enumValues: nil),
             ],
             handler: { req in
                 var params: [String: JSON] = [:]
@@ -413,6 +419,18 @@ final class IntentEngine {
                 if let region = req.slots["region"]?.stringValue {
                     params["region"] = .string(region)
                 }
+                if req.slots["selection"]?.boolValue == true {
+                    let selectionIds = WindowSelectionStore.shared.windowIds
+                    guard !selectionIds.isEmpty else {
+                        throw IntentError.targetNotFound("No active window selection")
+                    }
+                    params["scope"] = .string("selection")
+                    params["windowIds"] = .array(selectionIds.map { .int(Int($0)) })
+                    return try LatticesApi.shared.dispatch(
+                        method: "space.optimize",
+                        params: .object(params)
+                    )
+                }
                 return try LatticesApi.shared.dispatch(
                     method: "layout.distribute",
                     params: params.isEmpty ? nil : .object(params)

package/app/Sources/Core/Actions/IntentSchema.swift

@@ -0,0 +1,94 @@
+import Foundation
+
+struct IntentDef {
+    let name: String
+    let description: String
+    let examples: [String]
+    let slots: [IntentSlot]
+    let handler: (IntentRequest) throws -> JSON
+}
+
+struct IntentSlot {
+    let name: String
+    let type: String
+    let required: Bool
+    let description: String
+    let enumValues: [String]?
+    let defaultValue: JSON?
+
+    init(
+        name: String,
+        type: String,
+        required: Bool,
+        description: String,
+        enumValues: [String]? = nil,
+        defaultValue: JSON? = nil
+    ) {
+        self.name = name
+        self.type = type
+        self.required = required
+        self.description = description
+        self.enumValues = enumValues
+        self.defaultValue = defaultValue
+    }
+}
+
+struct IntentRequest {
+    let intent: String
+    let slots: [String: JSON]
+    let rawText: String?
+    let confidence: Double?
+    let source: String?
+}
+
+enum SlotType {
+    case string
+    case int
+    case bool
+    case position
+    case query
+    case app
+    case session
+    case layer
+    case enumerated([String])
+
+    var typeLabel: String {
+        switch self {
+        case .string: return "string"
+        case .int: return "int"
+        case .bool: return "bool"
+        case .position: return "position"
+        case .query: return "query"
+        case .app: return "app"
+        case .session: return "session"
+        case .layer: return "layer"
+        case .enumerated: return "string"
+        }
+    }
+
+    var enumValues: [String]? {
+        guard case .enumerated(let values) = self else { return nil }
+        return values
+    }
+}
+
+typealias SlotDef = IntentSlot
+
+extension IntentSlot {
+    init(
+        name: String,
+        type: SlotType,
+        required: Bool = true,
+        description: String = "",
+        defaultValue: JSON? = nil
+    ) {
+        self.init(
+            name: name,
+            type: type.typeLabel,
+            required: required,
+            description: description,
+            enumValues: type.enumValues,
+            defaultValue: defaultValue
+        )
+    }
+}

package/app/Sources/{Intents → Core/Actions/Intents}/LatticeIntent.swift

@@ -12,31 +12,6 @@ protocol LatticeIntent {
     func perform(slots: [String: JSON]) throws -> JSON
 }
 
-// MARK: - Slot Definition
-
-enum SlotType {
-    case string                           // Free-form text
-    case position                         // Tile position (left, right, maximize, etc.)
-    case app                              // Running app name
-    case session                          // Active tmux session
-    case layer                            // Layer name
-    case enumerated([String])             // Fixed set of values
-}
-
-struct SlotDef {
-    let name: String
-    let type: SlotType
-    let required: Bool
-    let defaultValue: JSON?
-
-    init(name: String, type: SlotType, required: Bool = true, defaultValue: JSON? = nil) {
-        self.name = name
-        self.type = type
-        self.required = required
-        self.defaultValue = defaultValue
-    }
-}
-
 // MARK: - Compiled Phrase Template
 
 struct CompiledPhrase {

package/app/Sources/{VoiceIntentResolver.swift → Core/Actions/VoiceIntentResolver.swift}

@@ -141,10 +141,43 @@ final class VoiceIntentResolver {
     private func extractSlots(for intentName: String, input: String) -> ExtractedSlots {
         switch intentName {
         case "tile_window":
-            guard let position = resolvePosition(in: input) else {
+            var slots: [String: JSON] = [:]
+            var boost = 0.0
+
+            if let position = resolvePosition(in: input) {
+                slots["position"] = .string(position)
+                boost += 0.28
+            } else {
                 return ExtractedSlots(slots: [:], boost: 0)
             }
-            return ExtractedSlots(slots: ["position": .string(position)], boost: 0.28)
+
+            if refersToSelection(in: input) {
+                slots["selection"] = .bool(true)
+                boost += 0.08
+            }
+
+            return ExtractedSlots(slots: slots, boost: boost)
+
+        case "distribute":
+            var slots: [String: JSON] = [:]
+            var boost = 0.0
+
+            if let region = resolvePosition(in: input) {
+                slots["region"] = .string(region)
+                boost += 0.18
+            }
+
+            if let app = detectKnownApp(in: input) {
+                slots["app"] = .string(app)
+                boost += 0.14
+            }
+
+            if refersToSelection(in: input) {
+                slots["selection"] = .bool(true)
+                boost += 0.12
+            }
+
+            return ExtractedSlots(slots: slots, boost: boost)
 
         case "focus":
             if let app = detectKnownApp(in: input) ?? extractEntity(in: input, prefixes: focusPrefixes) {
@@ -426,6 +459,15 @@ final class VoiceIntentResolver {
         return nil
     }
 
+    private func refersToSelection(in input: String) -> Bool {
+        let markers = [
+            "grid that", "grid these", "grid those",
+            "tile that", "tile these", "tile those",
+            "selected windows", "selection", "selected", "these windows", "those windows", "them"
+        ]
+        return markers.contains(where: input.contains)
+    }
+
     private func detectKnownApp(in input: String) -> String? {
         for app in knownApps() {
             let lower = app.lowercased()
@@ -601,7 +643,7 @@ final class VoiceIntentResolver {
         "search": ["find", "search", "look for", "where is", "where d", "locate", "lost", "show me all", "windows"],
         "list_windows": ["what s open", "list windows", "which windows", "what do i have open"],
         "list_sessions": ["list sessions", "what s running", "which projects", "show my sessions"],
-        "distribute": ["distribute", "spread", "organize", "arrange", "tidy", "clean up", "grid"],
+        "distribute": ["distribute", "spread", "organize", "arrange", "tidy", "clean up", "grid", "selected", "selection"],
         "create_layer": ["create layer", "save layout", "snapshot", "remember this layout"],
         "kill": ["kill", "stop", "shut down", "close", "terminate", "end"],
         "scan": ["scan", "rescan", "ocr", "read the screen", "what s on my screen", "screen text"],
@@ -662,7 +704,7 @@ final class VoiceIntentResolver {
         "search": ["where d my slack go", "pull up everything with dewey in it", "show me all the chrome windows", "dewey"],
         "list_windows": ["what do i have open", "what windows do i have"],
         "list_sessions": ["show me my sessions", "which projects are active"],
-        "distribute": ["tidy up", "line everything up", "clean up the windows"],
+        "distribute": ["tidy up", "line everything up", "clean up the windows", "grid that in the bottom half", "arrange the selected windows"],
         "create_layer": ["snapshot this", "remember this layout"],
         "kill": ["close the dewey session", "stop my session"],
         "scan": ["what s on my screen", "read the screen", "give me a fresh scan"],

package/app/Sources/{DesktopModel.swift → Core/Desktop/DesktopModel.swift}

@@ -106,8 +106,7 @@ final class DesktopModel: ObservableObject {
     }
 
     func windowForSession(_ session: String) -> WindowEntry? {
-        let tag = Terminal.windowTag(for: session)
-        return windows.values.first { $0.title.contains(tag) }
+        SessionWindowLocator.cachedWindow(forSession: session, in: windows)
     }
 
     /// Assign a layer tag to a window (in-memory only)
@@ -205,12 +204,7 @@ final class DesktopModel: ObservableObject {
 
             let spaceIds = WindowTiler.getSpacesForWindow(wid)
 
-            // Extract lattices session tag from title: [lattices:session-name]
-            var latticesSession: String?
-            if let range = title.range(of: #"\[lattices:([^\]]+)\]"#, options: .regularExpression) {
-                let match = String(title[range])
-                latticesSession = String(match.dropFirst(9).dropLast(1)) // drop "[lattices:" and "]"
-            }
+            let latticesSession = SessionWindowLocator.extractSessionName(from: title)
 
             var entry = WindowEntry(
                 wid: wid,

package/app/Sources/Core/Desktop/SessionWindowLocator.swift

@@ -0,0 +1,139 @@
+import AppKit
+import ApplicationServices
+import CoreGraphics
+
+struct LocatedWindow {
+    let wid: UInt32
+    let pid: pid_t
+}
+
+enum SessionWindowLocator {
+    static func tag(for session: String) -> String {
+        Terminal.windowTag(for: session)
+    }
+
+    static func extractSessionName(from title: String) -> String? {
+        guard let range = title.range(of: #"\[lattices:([^\]]+)\]"#, options: .regularExpression) else {
+            return nil
+        }
+        let match = String(title[range])
+        return String(match.dropFirst(10).dropLast(1))
+    }
+
+    static func matches(session: String, title: String, extractedSessionName: String? = nil) -> Bool {
+        if extractedSessionName == session {
+            return true
+        }
+        return title.contains(tag(for: session))
+    }
+
+    static func cachedWindow(forSession session: String, in windows: [UInt32: WindowEntry]) -> WindowEntry? {
+        windows.values.first { entry in
+            matches(session: session, title: entry.title, extractedSessionName: entry.latticesSession)
+        }
+    }
+
+    static func cachedWindow(forSession session: String, desktopModel: DesktopModel = .shared) -> WindowEntry? {
+        cachedWindow(forSession: session, in: desktopModel.windows)
+    }
+
+    static func findCGWindow(tag: String) -> LocatedWindow? {
+        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 LocatedWindow(wid: wid, pid: pid)
+            }
+        }
+        return nil
+    }
+
+    static func findWindow(session: String, terminal: Terminal) -> LocatedWindow? {
+        findWindow(tag: tag(for: session), terminal: terminal)
+    }
+
+    static func findWindow(tag: String, terminal: Terminal) -> LocatedWindow? {
+        if let match = findCGWindow(tag: tag) {
+            return match
+        }
+
+        if let ax = findAXWindow(terminal: terminal, tag: tag),
+           let wid = matchCGWindow(pid: ax.pid, axWindow: ax.window) {
+            return LocatedWindow(wid: wid, pid: ax.pid)
+        }
+
+        return nil
+    }
+
+    static func findAXWindow(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("SessionWindowLocator.findAXWindow: \(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("SessionWindowLocator.findAXWindow: AX error \(err.rawValue) — Accessibility not granted?")
+            return nil
+        }
+
+        diag.info("SessionWindowLocator.findAXWindow: \(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("SessionWindowLocator.findAXWindow: matched \"\(title)\"")
+                return (pid, win)
+            } else {
+                diag.info("  skip: \"\(title)\"")
+            }
+        }
+
+        diag.warn("SessionWindowLocator.findAXWindow: no window matched tag \(tag)")
+        return nil
+    }
+
+    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
+    }
+}

package/app/Sources/Core/Desktop/WindowPreviewCard.swift

@@ -0,0 +1,100 @@
+import AppKit
+import SwiftUI
+
+struct WindowPreviewCardStyle {
+    var containerCornerRadius: CGFloat = 10
+    var imageCornerRadius: CGFloat = 8
+    var imagePadding: CGFloat = 8
+    var background: Color = Palette.surface.opacity(0.8)
+    var border: Color = Palette.border
+}
+
+struct WindowPreviewCard<Overlay: View>: View {
+    let image: NSImage?
+    let isLoading: Bool
+    let appName: String
+    var loadingTitle: String = "Capturing preview"
+    var unavailableTitle: String = "Preview unavailable"
+    var style: WindowPreviewCardStyle = WindowPreviewCardStyle()
+    var holdingPreviousPreview: Bool = false
+    @ViewBuilder let overlay: () -> Overlay
+
+    var body: some View {
+        ZStack {
+            RoundedRectangle(cornerRadius: style.containerCornerRadius)
+                .fill(style.background)
+                .overlay(
+                    RoundedRectangle(cornerRadius: style.containerCornerRadius)
+                        .strokeBorder(style.border, lineWidth: 0.5)
+                )
+
+            if let image {
+                Image(nsImage: image)
+                    .resizable()
+                    .aspectRatio(contentMode: .fit)
+                    .clipShape(RoundedRectangle(cornerRadius: style.imageCornerRadius))
+                    .padding(style.imagePadding)
+                    .opacity(holdingPreviousPreview ? 0.88 : 1)
+            } else if isLoading {
+                WindowPreviewPlaceholder(
+                    icon: "photo",
+                    title: loadingTitle,
+                    subtitle: appName
+                )
+            } else {
+                WindowPreviewPlaceholder(
+                    icon: "eye.slash",
+                    title: unavailableTitle,
+                    subtitle: appName
+                )
+            }
+
+            overlay()
+        }
+    }
+}
+
+extension WindowPreviewCard where Overlay == EmptyView {
+    init(
+        image: NSImage?,
+        isLoading: Bool,
+        appName: String,
+        loadingTitle: String = "Capturing preview",
+        unavailableTitle: String = "Preview unavailable",
+        style: WindowPreviewCardStyle = WindowPreviewCardStyle(),
+        holdingPreviousPreview: Bool = false
+    ) {
+        self.init(
+            image: image,
+            isLoading: isLoading,
+            appName: appName,
+            loadingTitle: loadingTitle,
+            unavailableTitle: unavailableTitle,
+            style: style,
+            holdingPreviousPreview: holdingPreviousPreview,
+            overlay: { EmptyView() }
+        )
+    }
+}
+
+private struct WindowPreviewPlaceholder: View {
+    let icon: String
+    let title: String
+    let subtitle: String
+
+    var body: some View {
+        VStack(spacing: 8) {
+            Image(systemName: icon)
+                .font(.system(size: 18, weight: .medium))
+                .foregroundColor(Palette.textMuted.opacity(0.7))
+            Text(title)
+                .font(Typo.monoBold(10))
+                .foregroundColor(Palette.textMuted)
+            Text(subtitle)
+                .font(Typo.mono(9))
+                .foregroundColor(Palette.textDim)
+                .lineLimit(1)
+        }
+        .padding(16)
+    }
+}