@arach/lattices 0.1.0 → 0.2.1

package/app/Sources/OmniSearchView.swift

@@ -0,0 +1,288 @@
+import SwiftUI
+
+struct OmniSearchView: View {
+    @ObservedObject var state: OmniSearchState
+    var onDismiss: () -> Void
+
+    @FocusState private var searchFocused: Bool
+
+    var body: some View {
+        VStack(spacing: 0) {
+            // Search field
+            HStack(spacing: 8) {
+                Image(systemName: "magnifyingglass")
+                    .foregroundColor(Palette.textMuted)
+                    .font(.system(size: 13))
+
+                TextField("Search windows, projects, sessions...", text: $state.query)
+                    .textFieldStyle(.plain)
+                    .font(Typo.mono(14))
+                    .foregroundColor(Palette.text)
+                    .focused($searchFocused)
+
+                if !state.query.isEmpty {
+                    Button { state.query = "" } label: {
+                        Image(systemName: "xmark.circle.fill")
+                            .foregroundColor(Palette.textMuted)
+                            .font(.system(size: 12))
+                    }
+                    .buttonStyle(.plain)
+                }
+            }
+            .padding(.horizontal, 14)
+            .padding(.vertical, 12)
+            .background(Palette.surface)
+
+            Rectangle()
+                .fill(Palette.border)
+                .frame(height: 0.5)
+
+            // Content
+            if state.query.isEmpty {
+                summaryView
+            } else if state.results.isEmpty {
+                emptyResults
+            } else {
+                resultsView
+            }
+        }
+        .frame(minWidth: 520, idealWidth: 520, maxWidth: 700, minHeight: 360, idealHeight: 480, maxHeight: 600)
+        .background(PanelBackground())
+        .preferredColorScheme(.dark)
+        .onAppear {
+            searchFocused = true
+            state.refreshSummary()
+        }
+    }
+
+    // MARK: - Results
+
+    private var resultsView: some View {
+        ScrollViewReader { proxy in
+            ScrollView {
+                LazyVStack(alignment: .leading, spacing: 2) {
+                    var flatIndex = 0
+                    ForEach(state.groupedResults, id: \.0) { group, items in
+                        // Group header
+                        Text(group.uppercased())
+                            .font(Typo.caption(9))
+                            .foregroundColor(Palette.textMuted)
+                            .padding(.horizontal, 14)
+                            .padding(.top, 8)
+                            .padding(.bottom, 2)
+
+                        ForEach(items) { item in
+                            let idx = flatIndex
+                            let _ = { flatIndex += 1 }()
+                            resultRow(item, index: idx)
+                                .id(item.id)
+                        }
+                    }
+                }
+                .padding(.vertical, 4)
+            }
+            .onChange(of: state.selectedIndex) { newVal in
+                if newVal < state.results.count {
+                    let item = state.results[newVal]
+                    withAnimation(.easeOut(duration: 0.1)) {
+                        proxy.scrollTo(item.id, anchor: .center)
+                    }
+                }
+            }
+        }
+    }
+
+    private func resultRow(_ item: OmniResult, index: Int) -> some View {
+        let isSelected = index == state.selectedIndex
+        return Button {
+            item.action()
+            onDismiss()
+        } label: {
+            HStack(spacing: 10) {
+                Image(systemName: item.icon)
+                    .font(.system(size: 11, weight: .medium))
+                    .foregroundColor(isSelected ? Palette.text : Palette.textDim)
+                    .frame(width: 16)
+
+                VStack(alignment: .leading, spacing: 1) {
+                    Text(item.title)
+                        .font(Typo.mono(12))
+                        .foregroundColor(isSelected ? Palette.text : Palette.textDim)
+                        .lineLimit(1)
+
+                    Text(item.subtitle)
+                        .font(Typo.mono(10))
+                        .foregroundColor(Palette.textMuted)
+                        .lineLimit(1)
+                }
+
+                Spacer()
+
+                Text(item.kind.rawValue)
+                    .font(Typo.mono(9))
+                    .foregroundColor(Palette.textMuted)
+                    .padding(.horizontal, 5)
+                    .padding(.vertical, 2)
+                    .background(
+                        RoundedRectangle(cornerRadius: 3)
+                            .fill(Palette.surface)
+                    )
+            }
+            .padding(.horizontal, 14)
+            .padding(.vertical, 6)
+            .background(
+                RoundedRectangle(cornerRadius: 5)
+                    .fill(isSelected ? Palette.surfaceHov : Color.clear)
+            )
+            .contentShape(Rectangle())
+        }
+        .buttonStyle(.plain)
+    }
+
+    // MARK: - Empty Results
+
+    private var emptyResults: some View {
+        VStack(spacing: 12) {
+            Spacer()
+            Image(systemName: "magnifyingglass")
+                .font(.system(size: 24, weight: .light))
+                .foregroundColor(Palette.textMuted)
+            Text("No results for \"\(state.query)\"")
+                .font(Typo.mono(12))
+                .foregroundColor(Palette.textDim)
+            Spacer()
+        }
+    }
+
+    // MARK: - Activity Summary
+
+    private var summaryView: some View {
+        ScrollView {
+            VStack(alignment: .leading, spacing: 14) {
+                if let summary = state.activitySummary {
+                    // Windows by app
+                    summarySection("WINDOWS", icon: "macwindow", count: summary.totalWindows) {
+                        ForEach(summary.windowsByApp) { app in
+                            HStack {
+                                Text(app.appName)
+                                    .font(Typo.mono(11))
+                                    .foregroundColor(Palette.textDim)
+                                    .lineLimit(1)
+                                Spacer()
+                                Text("\(app.count)")
+                                    .font(Typo.monoBold(11))
+                                    .foregroundColor(Palette.text)
+                            }
+                        }
+                    }
+
+                    // Sessions
+                    if !summary.sessions.isEmpty {
+                        summarySection("TMUX SESSIONS", icon: "terminal", count: summary.sessions.count) {
+                            ForEach(summary.sessions) { session in
+                                HStack {
+                                    Circle()
+                                        .fill(session.attached ? Palette.running : Palette.textMuted)
+                                        .frame(width: 6, height: 6)
+                                    Text(session.name)
+                                        .font(Typo.mono(11))
+                                        .foregroundColor(Palette.textDim)
+                                    Spacer()
+                                    Text("\(session.paneCount) panes")
+                                        .font(Typo.mono(10))
+                                        .foregroundColor(Palette.textMuted)
+                                }
+                            }
+                        }
+                    }
+
+                    // Processes
+                    if !summary.interestingProcesses.isEmpty {
+                        summarySection("PROCESSES", icon: "gearshape", count: summary.interestingProcesses.count) {
+                            ForEach(Array(summary.interestingProcesses.prefix(10).enumerated()), id: \.offset) { _, proc in
+                                HStack {
+                                    Text(proc.comm)
+                                        .font(Typo.monoBold(11))
+                                        .foregroundColor(Palette.textDim)
+                                    if let cwd = proc.cwd {
+                                        Text(cwd.replacingOccurrences(of: NSHomeDirectory(), with: "~"))
+                                            .font(Typo.mono(10))
+                                            .foregroundColor(Palette.textMuted)
+                                            .lineLimit(1)
+                                    }
+                                    Spacer()
+                                }
+                            }
+                        }
+                    }
+
+                    // OCR info
+                    if summary.ocrWindowCount > 0 {
+                        HStack(spacing: 6) {
+                            Image(systemName: "doc.text.magnifyingglass")
+                                .font(.system(size: 10))
+                                .foregroundColor(Palette.textMuted)
+                            Text("OCR: \(summary.ocrWindowCount) windows scanned")
+                                .font(Typo.mono(10))
+                                .foregroundColor(Palette.textMuted)
+                            if let t = summary.lastOcrScan {
+                                Spacer()
+                                Text(relativeTime(t))
+                                    .font(Typo.mono(9))
+                                    .foregroundColor(Palette.textMuted)
+                            }
+                        }
+                        .padding(.horizontal, 14)
+                    }
+                } else {
+                    Text("Loading...")
+                        .font(Typo.mono(11))
+                        .foregroundColor(Palette.textMuted)
+                        .padding(14)
+                }
+            }
+            .padding(.vertical, 10)
+        }
+    }
+
+    private func summarySection<Content: View>(
+        _ title: String,
+        icon: String,
+        count: Int,
+        @ViewBuilder content: () -> Content
+    ) -> some View {
+        VStack(alignment: .leading, spacing: 6) {
+            HStack(spacing: 6) {
+                Image(systemName: icon)
+                    .font(.system(size: 10, weight: .medium))
+                    .foregroundColor(Palette.textMuted)
+                Text(title)
+                    .font(Typo.caption(9))
+                    .foregroundColor(Palette.textMuted)
+                Text("\(count)")
+                    .font(Typo.monoBold(9))
+                    .foregroundColor(Palette.running)
+                    .padding(.horizontal, 4)
+                    .padding(.vertical, 1)
+                    .background(
+                        RoundedRectangle(cornerRadius: 3)
+                            .fill(Palette.running.opacity(0.12))
+                    )
+                Spacer()
+            }
+            .padding(.horizontal, 14)
+
+            VStack(spacing: 3) {
+                content()
+            }
+            .padding(.horizontal, 14)
+        }
+    }
+
+    private func relativeTime(_ date: Date) -> String {
+        let seconds = Int(Date().timeIntervalSince(date))
+        if seconds < 60 { return "\(seconds)s ago" }
+        if seconds < 3600 { return "\(seconds / 60)m ago" }
+        return "\(seconds / 3600)h ago"
+    }
+}

package/app/Sources/OmniSearchWindow.swift

@@ -0,0 +1,105 @@
+import AppKit
+import SwiftUI
+
+final class OmniSearchWindow {
+    static let shared = OmniSearchWindow()
+
+    private var panel: NSPanel?
+    private var keyMonitor: Any?
+    private var state: OmniSearchState?
+
+    var isVisible: Bool { panel?.isVisible ?? false }
+
+    func toggle() {
+        if isVisible {
+            dismiss()
+        } else {
+            show()
+        }
+    }
+
+    func show() {
+        if let p = panel, p.isVisible {
+            p.makeKeyAndOrderFront(nil)
+            NSApp.activate(ignoringOtherApps: true)
+            return
+        }
+
+        // Fresh state each time
+        let searchState = OmniSearchState()
+        state = searchState
+
+        let view = OmniSearchView(state: searchState) { [weak self] in
+            self?.dismiss()
+        }
+        .preferredColorScheme(.dark)
+
+        let hosting = NSHostingController(rootView: view)
+        hosting.preferredContentSize = NSSize(width: 520, height: 480)
+
+        let p = NSPanel(
+            contentRect: NSRect(x: 0, y: 0, width: 520, height: 480),
+            styleMask: [.titled, .closable, .resizable, .utilityWindow, .nonactivatingPanel],
+            backing: .buffered,
+            defer: false
+        )
+        p.contentViewController = hosting
+        p.title = "Omni Search"
+        p.titlebarAppearsTransparent = true
+        p.titleVisibility = .hidden
+        p.isMovableByWindowBackground = true
+        p.level = .floating
+        p.isOpaque = false
+        p.backgroundColor = NSColor(red: 0.11, green: 0.11, blue: 0.12, alpha: 1.0)
+        p.hasShadow = true
+        p.appearance = NSAppearance(named: .darkAqua)
+        p.collectionBehavior = [.canJoinAllSpaces, .fullScreenAuxiliary]
+        p.minSize = NSSize(width: 400, height: 300)
+        p.maxSize = NSSize(width: 700, height: 700)
+
+        // Center on screen
+        if let screen = NSScreen.main {
+            let visibleFrame = screen.visibleFrame
+            let x = visibleFrame.midX - 260
+            let y = visibleFrame.midY + 60  // slightly above center
+            p.setFrameOrigin(NSPoint(x: x, y: y))
+        }
+
+        p.makeKeyAndOrderFront(nil)
+        NSApp.activate(ignoringOtherApps: true)
+        panel = p
+
+        // Key monitor: Escape → dismiss, arrow keys → navigate, Enter → activate
+        keyMonitor = NSEvent.addLocalMonitorForEvents(matching: .keyDown) { [weak self] event in
+            guard self?.panel?.isKeyWindow == true else { return event }
+
+            switch event.keyCode {
+            case 53: // Escape
+                self?.dismiss()
+                return nil
+            case 125: // ↓
+                self?.state?.moveSelection(1)
+                return nil
+            case 126: // ↑
+                self?.state?.moveSelection(-1)
+                return nil
+            case 36: // Enter
+                self?.state?.activateSelected()
+                self?.dismiss()
+                return nil
+            default:
+                return event
+            }
+        }
+    }
+
+    func dismiss() {
+        panel?.orderOut(nil)
+        panel = nil
+        state = nil
+        if let monitor = keyMonitor {
+            NSEvent.removeMonitor(monitor)
+            keyMonitor = nil
+        }
+    }
+}

package/app/Sources/PaletteCommand.swift

@@ -364,9 +364,19 @@ enum CommandBuilder {
             }
         ))
 
+        commands.append(PaletteCommand(
+            id: "app-windows-list",
+            title: "Windows List",
+            subtitle: "Browse all windows across displays",
+            icon: "rectangle.split.2x1",
+            category: .app,
+            badge: nil,
+            action: { CommandModeWindow.shared.show() }
+        ))
+
         commands.append(PaletteCommand(
             id: "app-screen-map",
-            title: "Screen Map",
+            title: "Window Map",
             subtitle: "Visual window editor",
             icon: "rectangle.3.group",
             category: .app,

package/app/Sources/PermissionChecker.swift

@@ -13,14 +13,14 @@ final class PermissionChecker: ObservableObject {
 
     var allGranted: Bool { accessibility && screenRecording }
 
-    /// Check current permission state without prompting.
+    /// Check current permission state, prompting on first launch if not granted.
     func check() {
         let diag = DiagnosticLog.shared
 
         let ax = AXIsProcessTrusted()
         let sr = CGPreflightScreenCaptureAccess()
 
-        // First check: log detailed identity info to help debug TCC issues
+        // First check: log identity info and prompt if needed
         if !hasLoggedInitial {
             hasLoggedInitial = true
             let bundleId = Bundle.main.bundleIdentifier ?? "<no bundle id>"
@@ -30,6 +30,16 @@ final class PermissionChecker: ObservableObject {
             diag.info("PermissionChecker: exec=\(execPath)")
             diag.info("AXIsProcessTrusted() → \(ax)")
             diag.info("CGPreflightScreenCaptureAccess() → \(sr)")
+
+            // Prompt for missing permissions on first check
+            if !ax {
+                requestAccessibility()
+                return
+            }
+            if !sr {
+                requestScreenRecording()
+                return
+            }
         }
 
         // Log on state changes

package/app/Sources/Preferences.swift

@@ -20,6 +20,32 @@ class Preferences: ObservableObject {
         didSet { UserDefaults.standard.set(mode.rawValue, forKey: "mode") }
     }
 
+    // MARK: - Search & OCR
+
+    @Published var ocrEnabled: Bool {
+        didSet { UserDefaults.standard.set(!ocrEnabled, forKey: "ocr.disabled") }
+    }
+
+    @Published var ocrQuickInterval: Double {
+        didSet { UserDefaults.standard.set(ocrQuickInterval, forKey: "ocr.interval") }
+    }
+
+    @Published var ocrDeepInterval: Double {
+        didSet { UserDefaults.standard.set(ocrDeepInterval, forKey: "ocr.deepInterval") }
+    }
+
+    @Published var ocrQuickLimit: Int {
+        didSet { UserDefaults.standard.set(ocrQuickLimit, forKey: "ocr.quickLimit") }
+    }
+
+    @Published var ocrDeepLimit: Int {
+        didSet { UserDefaults.standard.set(ocrDeepLimit, forKey: "ocr.deepLimit") }
+    }
+
+    @Published var ocrAccuracy: String {
+        didSet { UserDefaults.standard.set(ocrAccuracy, forKey: "ocr.accuracy") }
+    }
+
     init() {
         if let saved = UserDefaults.standard.string(forKey: "terminal"),
            let t = Terminal(rawValue: saved), t.isInstalled {
@@ -44,5 +70,23 @@ class Preferences: ObservableObject {
         } else {
             self.mode = .learning
         }
+
+        // Search & OCR
+        self.ocrEnabled = !UserDefaults.standard.bool(forKey: "ocr.disabled")
+
+        let savedInterval = UserDefaults.standard.double(forKey: "ocr.interval")
+        self.ocrQuickInterval = savedInterval > 0 ? savedInterval : 60
+
+        let savedDeep = UserDefaults.standard.double(forKey: "ocr.deepInterval")
+        self.ocrDeepInterval = savedDeep > 0 ? savedDeep : 7200
+
+        let savedQL = UserDefaults.standard.integer(forKey: "ocr.quickLimit")
+        self.ocrQuickLimit = savedQL > 0 ? savedQL : 5
+
+        let savedDL = UserDefaults.standard.integer(forKey: "ocr.deepLimit")
+        self.ocrDeepLimit = savedDL > 0 ? savedDL : 15
+
+        let savedAcc = UserDefaults.standard.string(forKey: "ocr.accuracy") ?? "accurate"
+        self.ocrAccuracy = savedAcc
     }
 }

package/app/Sources/ScreenMapState.swift

@@ -1438,9 +1438,8 @@ final class ScreenMapController: ObservableObject {
         // Tiling mode intercepts keys before anything else
         if editor?.isTilingMode == true {
             switch keyCode {
-            case 53: // Escape → cancel tiling mode
-                exitTilingMode()
-                flash("Tiling cancelled")
+            case 53: // Escape — always dismiss
+                onDismiss?()
                 return true
             case 123: // ← → left
                 tileSelectedWindowInEditor(to: .left)
@@ -1516,8 +1515,8 @@ final class ScreenMapController: ObservableObject {
         // Search mode intercepts keys before normal handling
         if isSearchActive {
             switch keyCode {
-            case 53: // Escape → close search
-                closeSearch()
+            case 53: // Escape — always dismiss
+                onDismiss?()
                 return true
             case 36: // Enter → select or focus
                 if modifiers.contains(.command) {
@@ -1539,18 +1538,9 @@ final class ScreenMapController: ObservableObject {
         }
 
         switch keyCode {
-        case 53: // Escape
-            if editor?.isPreviewing == true {
-                endPreview()
-            }
-            if let ed = editor, ed.pendingEditCount > 0 {
-                ed.discardEdits()
-                diag.info("[ScreenMap] discarded edits")
-                flash("Edits discarded")
-            } else {
-                diag.info("[ScreenMap] exit")
-                onDismiss?()
-            }
+        case 53: // Escape — always dismiss
+            diag.info("[ScreenMap] exit")
+            onDismiss?()
             return true
 
         case 36: // Enter

package/app/Sources/ScreenMapView.swift

@@ -1972,6 +1972,9 @@ struct ScreenMapView: View {
 
     private func installKeyHandler() {
         eventMonitor = NSEvent.addLocalMonitorForEvents(matching: [.keyDown, .keyUp]) { event in
+            // Only handle keys when our window is the key window
+            guard let win = ScreenMapWindowController.shared.nsWindow,
+                  win.isKeyWindow else { return event }
             // Track space key for canvas drag-to-pan
             if event.keyCode == 49 && !controller.isSearchActive {
                 if event.type == .keyDown && !event.isARepeat {