@lattices/cli 0.3.0 → 0.4.1

package/app/Sources/CheatSheetHUD.swift

@@ -29,7 +29,7 @@ final class CheatSheetHUD {
         let hosting = NSHostingView(rootView: view)
 
         let p = NSPanel(
-            contentRect: NSRect(x: 0, y: 0, width: 520, height: 420),
+            contentRect: NSRect(x: 0, y: 0, width: 520, height: 480),
             styleMask: [.borderless, .nonactivatingPanel],
             backing: .buffered,
             defer: false
@@ -48,7 +48,7 @@ final class CheatSheetHUD {
         let screen = NSScreen.screens.first(where: { $0.frame.contains(mouseLocation) }) ?? NSScreen.main ?? NSScreen.screens.first!
         let screenFrame = screen.visibleFrame
         let x = screenFrame.midX - 260
-        let y = screenFrame.midY - 210
+        let y = screenFrame.midY - 240
         p.setFrameOrigin(NSPoint(x: x, y: y))
 
         p.alphaValue = 0
@@ -66,6 +66,7 @@ final class CheatSheetHUD {
     func dismiss() {
         guard let p = panel else { return }
         removeMonitors()
+        TileZoneOverlay.shared.dismiss()
 
         NSAnimationContext.runAnimationGroup({ ctx in
             ctx.duration = 0.2
@@ -79,10 +80,17 @@ final class CheatSheetHUD {
     // MARK: - Event monitors
 
     private func installMonitors() {
-        // Escape key dismisses (global — panel is non-activating so keys go to frontmost app)
+        // Key handling (global — panel is non-activating so keys go to frontmost app)
         localMonitor = NSEvent.addGlobalMonitorForEvents(matching: .keyDown) { [weak self] event in
             if event.keyCode == 53 { // Escape
                 self?.dismiss()
+            } else if event.keyCode == 49 { // Space — toggle voice command
+                let audio = AudioLayer.shared
+                if audio.isListening {
+                    audio.stopVoiceCommand()
+                } else {
+                    audio.startVoiceCommand()
+                }
             }
         }
 
@@ -103,6 +111,8 @@ final class CheatSheetHUD {
 
 struct CheatSheetView: View {
     @ObservedObject private var hotkeyStore = HotkeyStore.shared
+    @ObservedObject private var audioLayer = AudioLayer.shared
+    @State private var hoveredAction: HotkeyAction?
 
     var body: some View {
         VStack(spacing: 0) {
@@ -140,19 +150,37 @@ struct CheatSheetView: View {
 
             Spacer(minLength: 0)
 
+            // Voice feedback strip
+            if audioLayer.isListening || audioLayer.lastTranscript != nil || audioLayer.executionResult != nil {
+                Rectangle().fill(Palette.border).frame(height: 0.5)
+                voiceFeedback
+            }
+
             Rectangle().fill(Palette.border).frame(height: 0.5)
 
             // Footer
-            HStack {
+            HStack(spacing: 20) {
                 Spacer()
-                Text("Press ESC to dismiss")
-                    .font(Typo.caption(10))
-                    .foregroundColor(Palette.textMuted)
+                HStack(spacing: 6) {
+                    keyBadge("Space")
+                    Image(systemName: audioLayer.isListening ? "mic.fill" : "mic")
+                        .font(.system(size: 11))
+                        .foregroundColor(audioLayer.isListening ? Palette.running : Palette.text)
+                    Text(audioLayer.isListening ? "Listening..." : "Voice")
+                        .font(Typo.geistMono(11))
+                        .foregroundColor(audioLayer.isListening ? Palette.running : Palette.text)
+                }
+                HStack(spacing: 6) {
+                    keyBadge("ESC")
+                    Text("Dismiss")
+                        .font(Typo.geistMono(11))
+                        .foregroundColor(Palette.textMuted)
+                }
                 Spacer()
             }
-            .padding(.vertical, 8)
+            .padding(.vertical, 10)
         }
-        .frame(width: 520, height: 420)
+        .frame(width: 520, height: 480)
         .background(
             RoundedRectangle(cornerRadius: 12)
                 .fill(Palette.bg)
@@ -170,6 +198,15 @@ struct CheatSheetView: View {
         VStack(alignment: .leading, spacing: 10) {
             columnHeader("Tiling")
 
+            // Modifier prefix
+            HStack(spacing: 3) {
+                keyBadge("Ctrl")
+                keyBadge("Option")
+                Text("+")
+                    .font(Typo.caption(11))
+                    .foregroundColor(Palette.textMuted)
+            }
+
             // 3x3 grid
             VStack(spacing: 2) {
                 HStack(spacing: 2) {
@@ -217,8 +254,107 @@ struct CheatSheetView: View {
             // Center + Distribute
             shortcutRow(action: .tileCenter)
             shortcutRow(action: .tileDistribute)
+
+            // Hovered shortcut detail
+            if let hovered = hoveredAction, let binding = hotkeyStore.bindings[hovered] {
+                HStack(spacing: 3) {
+                    ForEach(binding.displayParts, id: \.self) { part in
+                        keyBadge(part)
+                    }
+                    Text("→ \(hovered.label)")
+                        .font(Typo.caption(11))
+                        .foregroundColor(Palette.textDim)
+                }
+                .transition(.opacity)
+                .animation(.easeInOut(duration: 0.1), value: hoveredAction)
+            }
         }
         .frame(maxWidth: .infinity, alignment: .leading)
+        .onHover { over in
+            if !over {
+                hoveredAction = nil
+                TileZoneOverlay.shared.dismiss()
+            }
+        }
+        .onDisappear {
+            hoveredAction = nil
+            TileZoneOverlay.shared.dismiss()
+        }
+    }
+
+    // MARK: - Voice Feedback
+
+    private var voiceFeedback: some View {
+        VStack(alignment: .leading, spacing: 6) {
+            if audioLayer.isListening {
+                HStack(spacing: 8) {
+                    Circle()
+                        .fill(Palette.running)
+                        .frame(width: 8, height: 8)
+                    Text("Listening...")
+                        .font(Typo.geistMono(12))
+                        .foregroundColor(Palette.running)
+                    Spacer()
+                    Text("Press Space to stop")
+                        .font(Typo.caption(10))
+                        .foregroundColor(Palette.textMuted)
+                }
+            } else if let transcript = audioLayer.lastTranscript {
+                // Show what was heard
+                HStack(spacing: 6) {
+                    Image(systemName: "quote.opening")
+                        .font(.system(size: 10))
+                        .foregroundColor(Palette.textMuted)
+                    Text(transcript)
+                        .font(Typo.geistMono(12))
+                        .foregroundColor(Palette.text)
+                        .lineLimit(1)
+                }
+
+                // Show matched intent + result
+                if let intent = audioLayer.matchedIntent {
+                    HStack(spacing: 6) {
+                        Image(systemName: "arrow.right")
+                            .font(.system(size: 9))
+                            .foregroundColor(Palette.textMuted)
+                        Text(intent.replacingOccurrences(of: "_", with: " "))
+                            .font(Typo.geistMonoBold(11))
+                            .foregroundColor(Palette.text)
+
+                        if !audioLayer.matchedSlots.isEmpty {
+                            let slotText = audioLayer.matchedSlots
+                                .map { "\($0.key): \($0.value)" }
+                                .joined(separator: ", ")
+                            Text(slotText)
+                                .font(Typo.caption(10))
+                                .foregroundColor(Palette.textDim)
+                        }
+
+                        Spacer()
+
+                        if let result = audioLayer.executionResult {
+                            Text(result == "ok" ? "Done" : result)
+                                .font(Typo.caption(10))
+                                .foregroundColor(result == "ok" ? Palette.running : Palette.kill)
+                        }
+                    }
+                } else if let result = audioLayer.executionResult {
+                    HStack(spacing: 6) {
+                        Image(systemName: "questionmark.circle")
+                            .font(.system(size: 10))
+                            .foregroundColor(Palette.textMuted)
+                        Text(result)
+                            .font(Typo.caption(10))
+                            .foregroundColor(Palette.textMuted)
+                    }
+                }
+            }
+        }
+        .padding(.horizontal, 20)
+        .padding(.vertical, 10)
+        .background(Color.black.opacity(0.15))
+        .animation(.easeInOut(duration: 0.15), value: audioLayer.isListening)
+        .animation(.easeInOut(duration: 0.15), value: audioLayer.lastTranscript)
     }
 
     // MARK: - App Column
@@ -228,10 +364,11 @@ struct CheatSheetView: View {
             columnHeader("App")
 
             shortcutRow(action: .palette)
-            shortcutRow(action: .screenMap)
+            shortcutRow(action: .unifiedWindow)
             shortcutRow(action: .bezel)
+            shortcutRow(action: .hud)
+            shortcutRow(action: .voiceCommand)
             shortcutRow(action: .cheatSheet)
-            shortcutRow(action: .desktopInventory)
         }
     }
 
@@ -262,25 +399,34 @@ struct CheatSheetView: View {
     private func tileCell(action: HotkeyAction, label: String) -> some View {
         let binding = hotkeyStore.bindings[action]
         let badgeText = binding?.displayParts.last ?? ""
+        let isHovered = hoveredAction == action
 
-        return VStack(spacing: 3) {
-            Text(label)
-                .font(Typo.caption(9))
-                .foregroundColor(Palette.textDim)
+        return VStack(spacing: 2) {
             Text(badgeText)
-                .font(Typo.geistMonoBold(9))
-                .foregroundColor(Palette.text)
+                .font(Typo.geistMonoBold(12))
+                .foregroundColor(isHovered ? Color.blue : Palette.text)
+            Text(label)
+                .font(Typo.caption(8))
+                .foregroundColor(isHovered ? Palette.text : Palette.textMuted)
         }
         .frame(maxWidth: .infinity)
         .frame(height: 38)
         .background(
             RoundedRectangle(cornerRadius: 4)
-                .fill(Palette.surface)
+                .fill(isHovered ? Color.blue.opacity(0.15) : Palette.surface)
                 .overlay(
                     RoundedRectangle(cornerRadius: 4)
-                        .strokeBorder(Palette.border, lineWidth: 0.5)
+                        .strokeBorder(isHovered ? Color.blue.opacity(0.5) : Palette.border, lineWidth: 0.5)
                 )
         )
+        .onHover { over in
+            if over {
+                hoveredAction = action
+                if let pos = action.tilePosition {
+                    TileZoneOverlay.shared.show(position: pos)
+                }
+            }
+        }
     }
 
     private func shortcutRow(action: HotkeyAction) -> some View {
@@ -330,3 +476,99 @@ struct CheatSheetView: View {
             )
     }
 }
+
+// MARK: - HotkeyAction → TilePosition mapping
+
+extension HotkeyAction {
+    var tilePosition: TilePosition? {
+        switch self {
+        case .tileLeft:        return .left
+        case .tileRight:       return .right
+        case .tileTop:         return .top
+        case .tileBottom:      return .bottom
+        case .tileTopLeft:     return .topLeft
+        case .tileTopRight:    return .topRight
+        case .tileBottomLeft:  return .bottomLeft
+        case .tileBottomRight: return .bottomRight
+        case .tileMaximize:    return .maximize
+        case .tileCenter:      return .center
+        case .tileLeftThird:   return .leftThird
+        case .tileCenterThird: return .centerThird
+        case .tileRightThird:  return .rightThird
+        default:               return nil
+        }
+    }
+}
+
+// MARK: - TileZoneOverlay
+
+final class TileZoneOverlay {
+    static let shared = TileZoneOverlay()
+
+    private var panel: NSPanel?
+
+    func show(position: TilePosition) {
+        // Instant teardown (no animation) when switching between cells
+        if let p = panel {
+            p.orderOut(nil)
+            self.panel = nil
+        }
+
+        // Use the screen where the mouse is (same as CheatSheetHUD)
+        let mouseLocation = NSEvent.mouseLocation
+        let screen = NSScreen.screens.first(where: { $0.frame.contains(mouseLocation) }) ?? NSScreen.main ?? NSScreen.screens.first!
+        let visible = screen.visibleFrame
+
+        let (fx, fy, fw, fh) = position.rect
+        // visibleFrame origin is bottom-left in AppKit coordinates
+        let zoneRect = NSRect(
+            x: visible.origin.x + visible.width * fx,
+            y: visible.origin.y + visible.height * (1 - fy - fh),
+            width: visible.width * fw,
+            height: visible.height * fh
+        )
+
+        let p = NSPanel(
+            contentRect: zoneRect,
+            styleMask: [.borderless, .nonactivatingPanel],
+            backing: .buffered,
+            defer: false
+        )
+        p.isOpaque = false
+        p.backgroundColor = .clear
+        p.level = .floating
+        p.hasShadow = false
+        p.hidesOnDeactivate = false
+        p.isReleasedWhenClosed = false
+        p.ignoresMouseEvents = true
+
+        let overlay = NSView(frame: NSRect(origin: .zero, size: zoneRect.size))
+        overlay.wantsLayer = true
+        overlay.layer?.backgroundColor = NSColor.systemBlue.withAlphaComponent(0.08).cgColor
+        overlay.layer?.borderColor = NSColor.systemBlue.withAlphaComponent(0.4).cgColor
+        overlay.layer?.borderWidth = 2
+        overlay.layer?.cornerRadius = 8
+        p.contentView = overlay
+
+        p.alphaValue = 0
+        p.orderFrontRegardless()
+
+        NSAnimationContext.runAnimationGroup { ctx in
+            ctx.duration = 0.12
+            p.animator().alphaValue = 1.0
+        }
+
+        self.panel = p
+    }
+
+    func dismiss() {
+        guard let p = panel else { return }
+        NSAnimationContext.runAnimationGroup({ ctx in
+            ctx.duration = 0.1
+            p.animator().alphaValue = 0
+        }) { [weak self] in
+            p.orderOut(nil)
+            self?.panel = nil
+        }
+    }
+}

package/app/Sources/DaemonProtocol.swift

@@ -98,4 +98,17 @@ enum JSON: Codable, Equatable {
         guard case .bool(let b) = self else { return nil }
         return b
     }
+
+    var arrayValue: [JSON]? {
+        guard case .array(let a) = self else { return nil }
+        return a
+    }
+
+    var numericDouble: Double? {
+        switch self {
+        case .double(let d): return d
+        case .int(let i): return Double(i)
+        default: return nil
+        }
+    }
 }

package/app/Sources/DaemonServer.swift

@@ -394,6 +394,14 @@ final class DaemonServer: ObservableObject {
                     "totalBlocks": .int(totalBlocks)
                 ])
             )
+        case .voiceCommand(let text, let confidence):
+            daemonEvent = DaemonEvent(
+                event: "voice.command",
+                data: .object([
+                    "text": .string(text),
+                    "confidence": .double(confidence)
+                ])
+            )
         }
         broadcast(daemonEvent)
     }

package/app/Sources/DesktopModel.swift

@@ -1,13 +1,67 @@
 import AppKit
+import ApplicationServices
 import CoreGraphics
 
 final class DesktopModel: ObservableObject {
     static let shared = DesktopModel()
 
+    /// System helper processes that should never appear in search results or window lists.
+    /// These are XPC services, agents, and background helpers — not user-facing apps.
+    private static let systemHelperProcesses: Set<String> = [
+        // Apple system helpers
+        "CredentialsProviderExtensionHost",
+        "AuthenticationServicesAgent",
+        "SafariPasswordExtension",
+        "com.apple.WebKit.WebAuthn",
+        "SharedWebCredentialRunner",
+        "ViewBridgeAuxiliary",
+        "universalaccessd",
+        "CoreServicesUIAgent",
+        "UserNotificationCenter",
+        "AutoFillPanelService",
+        "AutoFill",
+        "CoreLocationAgent",
+        "SecurityAgent",
+        "coreautha",
+        "coreauth",
+        "talagent",
+        "CommCenter",
+        "AXVisualSupportAgent",
+        "SystemUIServer",
+        "Dock",
+        "Window Server",
+        "WindowManager",
+        "NotificationCenter",
+        "ControlCenter",
+        "Spotlight",
+        "Keychain Access",
+        "loginwindow",
+        "ScreenSaverEngine",
+        "SoftwareUpdateNotificationManager",
+        "WiFiAgent",
+        "pboard",
+        "storeuid",
+        // Third-party helpers
+        "CursorUIViewService",
+        "Electron Helper",
+        "Google Chrome Helper",
+    ]
+
+    /// Suffixes that indicate a helper/service process, not a user-facing app
+    private static let helperSuffixes = ["Service", "Agent", "Helper", "Extension", "Daemon", "XPCService"]
+
+    /// Real apps that happen to match helper suffixes — don't filter these
+    private static let knownRealApps: Set<String> = [
+        "Finder",
+        "Activity Monitor",
+    ]
+
     @Published private(set) var windows: [UInt32: WindowEntry] = [:]
-    /// In-memory layer tags: wid → layer id (e.g. "lattices", "talkie", "hudson")
+    @Published private(set) var interactionDates: [UInt32: Date] = [:]
+    /// In-memory layer tags: wid → layer id (e.g. "lattices", "vox", "hudson")
     private(set) var windowLayerTags: [UInt32: String] = [:]
     private var timer: Timer?
+    private var lastFrontmostWid: UInt32?
 
     func start(interval: TimeInterval = 1.5) {
         guard timer == nil else { return }
@@ -24,7 +78,27 @@ final class DesktopModel: ObservableObject {
     }
 
     func allWindows() -> [WindowEntry] {
-        Array(windows.values).sorted { $0.wid < $1.wid }
+        Array(windows.values).sorted { $0.zIndex < $1.zIndex }
+    }
+
+    func lastInteractionDate(for wid: UInt32) -> Date? {
+        interactionDates[wid]
+    }
+
+    func markInteraction(wid: UInt32, at date: Date = Date()) {
+        DispatchQueue.main.async {
+            self.interactionDates[wid] = date
+        }
+    }
+
+    func markInteraction(wids: [UInt32], at date: Date = Date()) {
+        guard !wids.isEmpty else { return }
+        let unique = Set(wids)
+        DispatchQueue.main.async {
+            for wid in unique {
+                self.interactionDates[wid] = date
+            }
+        }
     }
 
     func windowForSession(_ session: String) -> WindowEntry? {
@@ -60,13 +134,31 @@ final class DesktopModel: ObservableObject {
 
     // MARK: - Polling
 
+    private var lastPollTime: Date = .distantPast
+    private static let minPollInterval: TimeInterval = 1.0
+
+    /// Poll only if stale. Call `forcePoll()` to bypass the freshness check.
     func poll() {
+        let now = Date()
+        guard now.timeIntervalSince(lastPollTime) >= Self.minPollInterval else { return }
+        lastPollTime = now
+        performPoll()
+    }
+
+    /// Force a poll regardless of freshness — use sparingly.
+    func forcePoll() {
+        lastPollTime = Date()
+        performPoll()
+    }
+
+    private func performPoll() {
         guard let list = CGWindowListCopyWindowInfo(
-            [.optionOnScreenOnly, .excludeDesktopElements],
+            [.optionAll, .excludeDesktopElements],
             kCGNullWindowID
         ) as? [[String: Any]] else { return }
 
         var fresh: [UInt32: WindowEntry] = [:]
+        var zCounter = 0
 
         for info in list {
             guard let wid = info[kCGWindowNumber as String] as? UInt32,
@@ -82,11 +174,24 @@ final class DesktopModel: ObservableObject {
 
             let title = info[kCGWindowName as String] as? String ?? ""
             let layer = info[kCGWindowLayer as String] as? Int ?? 0
-            let isOnScreen = info[kCGWindowIsOnscreen as String] as? Bool ?? true
+            let isOnScreen = info[kCGWindowIsOnscreen as String] as? Bool ?? false
 
             // Skip non-standard layers (menus, overlays)
             guard layer == 0 else { continue }
 
+            // Skip system helper processes (autofill, credential providers, etc.)
+            if Self.systemHelperProcesses.contains(ownerName) { continue }
+
+            // Skip processes whose name ends with common helper suffixes
+            // (e.g. "CursorUIViewService", "AutoFillPanelService", "SecurityAgent")
+            // but not known real apps that happen to have these words
+            let isHelperByName = Self.helperSuffixes.contains(where: { ownerName.hasSuffix($0) })
+                && !Self.knownRealApps.contains(ownerName)
+            if isHelperByName { continue }
+
+            // Skip windows with no title from processes containing "com.apple."
+            if ownerName.hasPrefix("com.apple.") && title.isEmpty { continue }
+
             let frame = WindowFrame(
                 x: Double(rect.origin.x),
                 y: Double(rect.origin.y),
@@ -103,7 +208,7 @@ final class DesktopModel: ObservableObject {
                 latticesSession = String(match.dropFirst(9).dropLast(1)) // drop "[lattices:" and "]"
             }
 
-            fresh[wid] = WindowEntry(
+            var entry = WindowEntry(
                 wid: wid,
                 app: ownerName,
                 pid: pid,
@@ -113,8 +218,14 @@ final class DesktopModel: ObservableObject {
                 isOnScreen: isOnScreen,
                 latticesSession: latticesSession
             )
+            entry.zIndex = zCounter
+            zCounter += 1
+            fresh[wid] = entry
         }
 
+        // AX reconciliation: check which CG windows actually exist in Accessibility
+        reconcileWithAX(&fresh)
+
         // Diff
         let oldKeys = Set(windows.keys)
         let newKeys = Set(fresh.keys)
@@ -122,9 +233,21 @@ final class DesktopModel: ObservableObject {
         let removed = Array(oldKeys.subtracting(newKeys))
 
         let changed = added.count > 0 || removed.count > 0 || windowsContentChanged(old: windows, new: fresh)
+        let frontmostWid = fresh.values.min(by: { $0.zIndex < $1.zIndex })?.wid
+        let markFrontmost = frontmostWid != nil && frontmostWid != lastFrontmostWid
+        let interactionTime = Date()
 
         DispatchQueue.main.async {
-            self.windows = fresh
+            var interactions = self.interactionDates.filter { fresh[$0.key] != nil }
+            if markFrontmost, let frontmostWid {
+                interactions[frontmostWid] = interactionTime
+            }
+            // Only publish if something actually changed — avoids unnecessary SwiftUI re-renders
+            if changed || markFrontmost {
+                self.windows = fresh
+                self.interactionDates = interactions
+            }
+            self.lastFrontmostWid = frontmostWid
         }
 
         if changed {
@@ -136,6 +259,66 @@ final class DesktopModel: ObservableObject {
         }
     }
 
+    private func reconcileWithAX(_ fresh: inout [UInt32: WindowEntry]) {
+        // Get currently active Space IDs — AX only returns windows on these
+        let currentSpaceIds = Set(WindowTiler.getDisplaySpaces().map(\.currentSpaceId))
+        guard !currentSpaceIds.isEmpty else { return }
+
+        // Group CG windows by PID — only titled windows on current Spaces
+        var byPid: [Int32: [UInt32]] = [:]
+        for (wid, entry) in fresh where !entry.title.isEmpty {
+            let onCurrentSpace = entry.spaceIds.contains { currentSpaceIds.contains($0) }
+            if onCurrentSpace {
+                byPid[entry.pid, default: []].append(wid)
+            }
+        }
+
+        for (pid, wids) in byPid {
+            let axApp = AXUIElementCreateApplication(pid)
+
+            // Set a timeout so unresponsive apps (video calls, etc.) don't block the poll
+            AXUIElementSetMessagingTimeout(axApp, 0.3)
+
+            var axWindowsRef: CFTypeRef?
+            guard AXUIElementCopyAttributeValue(axApp, kAXWindowsAttribute as CFString, &axWindowsRef) == .success,
+                  let axWindows = axWindowsRef as? [AXUIElement] else { continue }
+
+            // Collect AX window titles
+            var axTitles: [String] = []
+            for axWin in axWindows {
+                var titleRef: CFTypeRef?
+                AXUIElementCopyAttributeValue(axWin, kAXTitleAttribute as CFString, &titleRef)
+                if let title = titleRef as? String, !title.isEmpty {
+                    axTitles.append(title)
+                }
+            }
+
+            // Mark CG windows that have no matching AX title.
+            // AX titles often have suffixes like " - Google Chrome - Profile"
+            // so check if any AX title starts with the CG title (stripped of emoji).
+            for wid in wids {
+                guard let entry = fresh[wid], !entry.title.isEmpty else { continue }
+                let cgClean = stripForMatch(entry.title)
+                let matched = axTitles.contains { axTitle in
+                    let axClean = stripForMatch(axTitle)
+                    return axClean.hasPrefix(cgClean) || axClean.contains(cgClean) || cgClean.hasPrefix(axClean)
+                }
+                if !matched {
+                    fresh[wid]?.axVerified = false
+                }
+            }
+        }
+    }
+
+    private func stripForMatch(_ text: String) -> String {
+        // Remove emoji and non-ASCII symbols, lowercase, collapse whitespace
+        let scalar = text.unicodeScalars.filter { scalar in
+            scalar.isASCII || CharacterSet.letters.contains(scalar)
+        }
+        return String(scalar).lowercased()
+            .split(separator: " ").joined(separator: " ")
+    }
+
     private func windowsContentChanged(old: [UInt32: WindowEntry], new: [UInt32: WindowEntry]) -> Bool {
         // Quick check: if titles or frames changed for any existing window
         for (wid, newEntry) in new {

package/app/Sources/DesktopModelTypes.swift

@@ -9,6 +9,8 @@ struct WindowEntry: Codable, Identifiable {
     let spaceIds: [Int]
     let isOnScreen: Bool
     let latticesSession: String?
+    var axVerified: Bool = true
+    var zIndex: Int = 0 // 0 = frontmost, from CGWindowList order
 
     var id: UInt32 { wid }
 }