@arach/lattices 0.1.0 → 0.2.1

package/app/Sources/CommandModeState.swift

@@ -261,7 +261,9 @@ final class CommandModeState: ObservableObject {
                             let matchesApp = win.appName?.lowercased().contains(query) ?? false
                             let matchesTitle = win.title.lowercased().contains(query)
                             let matchesLattices = win.latticesSession?.lowercased().contains(query) ?? false
-                            if !matchesApp && !matchesTitle && !matchesLattices { return false }
+                            let matchesOcr = OcrModel.shared.results[win.id]?.fullText
+                                .lowercased().contains(query) ?? false
+                            if !matchesApp && !matchesTitle && !matchesLattices && !matchesOcr { return false }
                         }
 
                         return true
@@ -305,6 +307,37 @@ final class CommandModeState: ObservableObject {
         filteredSnapshot?.allWindows ?? []
     }
 
+    var ocrMatchSnippets: [UInt32: String] {
+        guard isSearching, !searchQuery.isEmpty else { return [:] }
+        let query = searchQuery.lowercased()
+        let ocrResults = OcrModel.shared.results
+        var snippets: [UInt32: String] = [:]
+        for win in flatWindowList {
+            // Only show snippet if match came from OCR, not title/app
+            let matchesApp = win.appName?.lowercased().contains(query) ?? false
+            let matchesTitle = win.title.lowercased().contains(query)
+            let matchesLattices = win.latticesSession?.lowercased().contains(query) ?? false
+            if matchesApp || matchesTitle || matchesLattices { continue }
+            if let ocr = ocrResults[win.id],
+               let range = ocr.fullText.lowercased().range(of: query) {
+                snippets[win.id] = Self.extractSnippet(from: ocr.fullText, around: range)
+            }
+        }
+        return snippets
+    }
+
+    private static func extractSnippet(from text: String, around range: Range<String.Index>, maxLen: Int = 80) -> String {
+        let half = max(0, (maxLen - text.distance(from: range.lowerBound, to: range.upperBound)) / 2)
+        let start = text.index(range.lowerBound, offsetBy: -half, limitedBy: text.startIndex) ?? text.startIndex
+        let end = text.index(range.upperBound, offsetBy: half, limitedBy: text.endIndex) ?? text.endIndex
+        var s = String(text[start..<end])
+            .replacingOccurrences(of: "\n", with: " ")
+            .trimmingCharacters(in: .whitespaces)
+        if start > text.startIndex { s = "…" + s }
+        if end < text.endIndex { s += "…" }
+        return s
+    }
+
     func enter() {
         inventory = buildInventory()
         chords = buildChords()
@@ -404,20 +437,8 @@ final class CommandModeState: ObservableObject {
         }
 
         switch keyCode {
-        case 53: // Escape
-            if isSearching {
-                deactivateSearch()
-                return true
-            }
-            if !selectedWindowIds.isEmpty {
-                clearSelection()
-                return true
-            }
-            // No selection — back to chord view
-            desktopMode = .browsing
-            activePreset = nil
-            phase = .inventory
-            onPanelResize?(chordPanelSize.0, chordPanelSize.1)
+        case 53: // Escape — always dismiss
+            onDismiss?()
             return true
 
         case 126: // ↑
@@ -560,8 +581,8 @@ final class CommandModeState: ObservableObject {
 
     private func handleTilingKey(_ keyCode: UInt16, modifiers: NSEvent.ModifierFlags = []) -> Bool {
         switch keyCode {
-        case 53: // Escape → back to browsing
-            desktopMode = .browsing
+        case 53: // Escape — always dismiss
+            onDismiss?()
             return true
 
         case 123: tileSelectedWindow(to: .left); return true       // ←
@@ -593,8 +614,8 @@ final class CommandModeState: ObservableObject {
 
     private func handleGridPreviewKey(_ keyCode: UInt16) -> Bool {
         switch keyCode {
-        case 53: // Escape → back to browsing
-            desktopMode = .browsing
+        case 53: // Escape — always dismiss
+            onDismiss?()
             return true
 
         case 36, 1: // Enter or s → apply the layout

package/app/Sources/CommandModeView.swift

@@ -282,13 +282,15 @@ struct CommandModeView: View {
             Image(systemName: "magnifyingglass")
                 .font(.system(size: 11))
                 .foregroundColor(Palette.textDim)
-            TextField("Search windows...", text: $state.searchQuery)
+            TextField("Search windows & content…", text: $state.searchQuery)
                 .textFieldStyle(.plain)
                 .font(Typo.mono(12))
                 .foregroundColor(Palette.text)
                 .focused($isSearchFieldFocused)
             if !state.searchQuery.isEmpty {
-                Text("\(state.flatWindowList.count) matches")
+                let total = state.flatWindowList.count
+                let ocrCount = state.ocrMatchSnippets.count
+                Text(ocrCount > 0 ? "\(total) matches (\(ocrCount) by content)" : "\(total) matches")
                     .font(Typo.mono(9))
                     .foregroundColor(Palette.textMuted)
             }
@@ -442,6 +444,7 @@ struct CommandModeView: View {
         VStack(alignment: .leading, spacing: 0) {
             if appGroup.windows.count == 1, let win = appGroup.windows.first {
                 inventoryRow(window: win, appLabel: appGroup.appName)
+                ocrSnippetRow(for: win.id)
                 if state.isSelected(win.id), let path = win.inventoryPath {
                     inventoryPathLabel(path)
                 }
@@ -454,6 +457,7 @@ struct CommandModeView: View {
                     .padding(.bottom, 1)
                 ForEach(appGroup.windows) { win in
                     inventoryRow(window: win, indented: true)
+                    ocrSnippetRow(for: win.id)
                     if state.isSelected(win.id), let path = win.inventoryPath {
                         inventoryPathLabel(path)
                     }
@@ -471,6 +475,24 @@ struct CommandModeView: View {
             .padding(.vertical, 2)
     }
 
+    @ViewBuilder
+    private func ocrSnippetRow(for windowId: UInt32) -> some View {
+        if let snippet = state.ocrMatchSnippets[windowId] {
+            HStack(spacing: 4) {
+                Image(systemName: "text.magnifyingglass")
+                    .font(.system(size: 7))
+                    .foregroundColor(Palette.textMuted)
+                Text(snippet)
+                    .font(Typo.mono(9).italic())
+                    .foregroundColor(Palette.textMuted)
+                    .lineLimit(1)
+                    .truncationMode(.tail)
+            }
+            .padding(.horizontal, 28)
+            .padding(.vertical, 1)
+        }
+    }
+
     /// Unified inventory row — handles both single-app rows (with appLabel) and
     /// sub-rows under a multi-window app header (with indented).
     private func inventoryRow(
@@ -1278,6 +1300,9 @@ struct CommandModeView: View {
     private func installKeyHandler() {
         eventMonitor = NSEvent.addLocalMonitorForEvents(matching: .keyDown) { event in
             guard state.phase == .inventory || state.phase == .desktopInventory else { return event }
+            // Only handle keys when our panel is the key window
+            guard let panel = CommandModeWindow.shared.panelWindow,
+                  panel.isKeyWindow else { return event }
             let consumed = state.handleKey(event.keyCode, modifiers: event.modifierFlags)
             return consumed ? nil : event
         }

package/app/Sources/DaemonServer.swift

@@ -386,6 +386,14 @@ final class DaemonServer: ObservableObject {
                     "pids": .array(interesting.map { .int($0) })
                 ])
             )
+        case .ocrScanComplete(let windowCount, let totalBlocks):
+            daemonEvent = DaemonEvent(
+                event: "ocr.scanComplete",
+                data: .object([
+                    "windowCount": .int(windowCount),
+                    "totalBlocks": .int(totalBlocks)
+                ])
+            )
         }
         broadcast(daemonEvent)
     }

package/app/Sources/DiagnosticLog.swift

@@ -67,18 +67,27 @@ final class DiagnosticWindow {
     static let shared = DiagnosticWindow()
 
     private var window: NSWindow?
+    private var keyMonitor: Any?
     private let log = DiagnosticLog.shared
 
     var isVisible: Bool { window?.isVisible ?? false }
 
     func toggle() {
         if let w = window, w.isVisible {
-            w.orderOut(nil)
+            dismiss()
         } else {
             show()
         }
     }
 
+    func dismiss() {
+        window?.orderOut(nil)
+        if let monitor = keyMonitor {
+            NSEvent.removeMonitor(monitor)
+            keyMonitor = nil
+        }
+    }
+
     func show() {
         if let w = window {
             w.orderFrontRegardless()
@@ -119,6 +128,15 @@ final class DiagnosticWindow {
         w.orderFrontRegardless()
         window = w
 
+        // Escape key → dismiss
+        keyMonitor = NSEvent.addLocalMonitorForEvents(matching: .keyDown) { [weak self] event in
+            guard event.keyCode == 53,
+                  let win = self?.window,
+                  event.window === win || win.isKeyWindow else { return event }
+            self?.dismiss()
+            return nil
+        }
+
         // Startup log
         let diag = DiagnosticLog.shared
         diag.info("Diagnostics opened")

package/app/Sources/EventBus.swift

@@ -5,6 +5,7 @@ enum ModelEvent {
     case tmuxChanged(sessions: [TmuxSession])
     case layerSwitched(index: Int)
     case processesChanged(interesting: [Int])
+    case ocrScanComplete(windowCount: Int, totalBlocks: Int)
 }
 
 final class EventBus {

package/app/Sources/HotkeyManager.swift

@@ -1,5 +1,6 @@
 import Carbon
 import AppKit
+import Foundation
 
 /// Global callback registry keyed by hotkey ID
 private var hotkeyCallbacks: [UInt32: () -> Void] = [:]

package/app/Sources/HotkeyStore.swift

@@ -18,6 +18,8 @@ enum HotkeyAction: String, CaseIterable, Codable {
     case screenMap
     case bezel
     case cheatSheet
+    case desktopInventory
+    case omniSearch
     // Layers
     case layer1, layer2, layer3, layer4, layer5, layer6, layer7, layer8, layer9
     // Tiling
@@ -32,6 +34,8 @@ enum HotkeyAction: String, CaseIterable, Codable {
         case .screenMap:       return "Screen Map"
         case .bezel:           return "Window Bezel"
         case .cheatSheet:      return "Cheat Sheet"
+        case .desktopInventory: return "Desktop Inventory"
+        case .omniSearch:      return "Omni Search"
         case .layer1:          return "Layer 1"
         case .layer2:          return "Layer 2"
         case .layer3:          return "Layer 3"
@@ -60,7 +64,7 @@ enum HotkeyAction: String, CaseIterable, Codable {
 
     var group: HotkeyGroup {
         switch self {
-        case .palette, .screenMap, .bezel, .cheatSheet: return .app
+        case .palette, .screenMap, .bezel, .cheatSheet, .desktopInventory, .omniSearch: return .app
         case .layer1, .layer2, .layer3, .layer4, .layer5,
              .layer6, .layer7, .layer8, .layer9: return .layers
         default: return .tiling
@@ -73,6 +77,8 @@ enum HotkeyAction: String, CaseIterable, Codable {
         case .screenMap:       return 200
         case .bezel:           return 201
         case .cheatSheet:      return 202
+        case .desktopInventory: return 203
+        case .omniSearch:      return 204
         case .layer1:          return 101
         case .layer2:          return 102
         case .layer3:          return 103
@@ -192,6 +198,8 @@ class HotkeyStore: ObservableObject {
         bind(.screenMap, 18, hyper)      // Hyper+1
         bind(.bezel,     19, hyper)      // Hyper+2
         bind(.cheatSheet, 20, hyper)     // Hyper+3
+        bind(.desktopInventory, 21, hyper) // Hyper+4
+        bind(.omniSearch, 23, hyper)       // Hyper+5
 
         // Layers: Cmd+Option+1-9
         let layerKeyCodes: [UInt32] = [18, 19, 20, 21, 23, 22, 26, 28, 25]

package/app/Sources/LatticesApi.swift

@@ -244,6 +244,36 @@ final class LatticesApi {
             Field(name: "displayName", type: "string", required: true, description: "Best display name (session > tab title > tty)"),
         ]))
 
+        api.model(ApiModel(name: "OcrResult", fields: [
+            Field(name: "wid", type: "int", required: true, description: "Window ID"),
+            Field(name: "app", type: "string", required: true, description: "Application name"),
+            Field(name: "title", type: "string", required: true, description: "Window title"),
+            Field(name: "frame", type: "Frame", required: true, description: "Window frame"),
+            Field(name: "fullText", type: "string", required: true, description: "All recognized text"),
+            Field(name: "blocks", type: "[OcrBlock]", required: true, description: "Individual text blocks with position/confidence"),
+            Field(name: "timestamp", type: "double", required: true, description: "Scan timestamp (Unix)"),
+        ]))
+
+        api.model(ApiModel(name: "OcrBlock", fields: [
+            Field(name: "text", type: "string", required: true, description: "Recognized text"),
+            Field(name: "confidence", type: "double", required: true, description: "Recognition confidence 0-1"),
+            Field(name: "x", type: "double", required: true, description: "Normalized bounding box x"),
+            Field(name: "y", type: "double", required: true, description: "Normalized bounding box y"),
+            Field(name: "w", type: "double", required: true, description: "Normalized bounding box width"),
+            Field(name: "h", type: "double", required: true, description: "Normalized bounding box height"),
+        ]))
+
+        api.model(ApiModel(name: "OcrSearchResult", fields: [
+            Field(name: "id", type: "int", required: true, description: "Database row ID"),
+            Field(name: "wid", type: "int", required: true, description: "Window ID"),
+            Field(name: "app", type: "string", required: true, description: "Application name"),
+            Field(name: "title", type: "string", required: true, description: "Window title"),
+            Field(name: "frame", type: "Frame", required: true, description: "Window frame at scan time"),
+            Field(name: "fullText", type: "string", required: true, description: "Full recognized text"),
+            Field(name: "snippet", type: "string", required: true, description: "Highlighted snippet (FTS5)"),
+            Field(name: "timestamp", type: "double", required: true, description: "Scan timestamp (Unix)"),
+        ]))
+
         api.model(ApiModel(name: "DaemonStatus", fields: [
             Field(name: "uptime", type: "double", required: true, description: "Seconds since daemon started"),
             Field(name: "clientCount", type: "int", required: true, description: "Connected WebSocket clients"),
@@ -283,6 +313,63 @@ final class LatticesApi {
             }
         ))
 
+        api.register(Endpoint(
+            method: "windows.search",
+            description: "Search windows by title, app, and OCR content",
+            access: .read,
+            params: [
+                Param(name: "query", type: "string", required: true, description: "Search text"),
+                Param(name: "ocr", type: "bool", required: false, description: "Include OCR content (default true)"),
+                Param(name: "limit", type: "int", required: false, description: "Max results (default 50)"),
+            ],
+            returns: .array(model: "Window"),
+            handler: { params in
+                guard let query = params?["query"]?.stringValue?.lowercased(), !query.isEmpty else {
+                    throw RouterError.missingParam("query")
+                }
+                let includeOcr = params?["ocr"]?.boolValue ?? true
+                let limit = params?["limit"]?.intValue ?? 50
+                let ocrResults = OcrModel.shared.results
+
+                var matches: [JSON] = []
+                for entry in DesktopModel.shared.allWindows() {
+                    let matchesApp = entry.app.lowercased().contains(query)
+                    let matchesTitle = entry.title.lowercased().contains(query)
+                    let matchesSession = entry.latticesSession?.lowercased().contains(query) ?? false
+                    let ocrText = includeOcr ? ocrResults[entry.wid]?.fullText : nil
+                    let matchesOcrContent = ocrText?.lowercased().contains(query) ?? false
+
+                    if matchesApp || matchesTitle || matchesSession || matchesOcrContent {
+                        var obj = Encoders.window(entry)
+                        if matchesOcrContent, let text = ocrText,
+                           let range = text.lowercased().range(of: query) {
+                            // Extract snippet around match
+                            let half = max(0, (80 - text.distance(from: range.lowerBound, to: range.upperBound)) / 2)
+                            let start = text.index(range.lowerBound, offsetBy: -half, limitedBy: text.startIndex) ?? text.startIndex
+                            let end = text.index(range.upperBound, offsetBy: half, limitedBy: text.endIndex) ?? text.endIndex
+                            var snippet = String(text[start..<end])
+                                .replacingOccurrences(of: "\n", with: " ")
+                                .trimmingCharacters(in: .whitespaces)
+                            if start > text.startIndex { snippet = "…" + snippet }
+                            if end < text.endIndex { snippet += "…" }
+                            if case .object(var dict) = obj {
+                                dict["ocrSnippet"] = .string(snippet)
+                                dict["matchSource"] = .string("ocr")
+                                obj = .object(dict)
+                            }
+                        } else if case .object(var dict) = obj {
+                            let source = matchesTitle ? "title" : matchesApp ? "app" : "session"
+                            dict["matchSource"] = .string(source)
+                            obj = .object(dict)
+                        }
+                        matches.append(obj)
+                        if matches.count >= limit { break }
+                    }
+                }
+                return .array(matches)
+            }
+        ))
+
         api.register(Endpoint(
             method: "tmux.sessions",
             description: "List all tmux sessions with child process enrichment",
@@ -486,6 +573,85 @@ final class LatticesApi {
             }
         ))
 
+        // ── Endpoints: OCR ─────────────────────────────────────
+
+        api.register(Endpoint(
+            method: "ocr.snapshot",
+            description: "Get the latest OCR scan results for all on-screen windows",
+            access: .read,
+            params: [],
+            returns: .array(model: "OcrResult"),
+            handler: { _ in
+                let results = OcrModel.shared.results
+                return .array(results.values.map { Encoders.ocrResult($0) })
+            }
+        ))
+
+        api.register(Endpoint(
+            method: "ocr.search",
+            description: "Search OCR text across all windows (queries persistent SQLite FTS5 index by default)",
+            access: .read,
+            params: [
+                Param(name: "query", type: "string", required: true, description: "Search text (FTS5 query syntax)"),
+                Param(name: "app", type: "string", required: false, description: "Filter by app name"),
+                Param(name: "limit", type: "int", required: false, description: "Max results (default 50)"),
+                Param(name: "live", type: "bool", required: false, description: "Search in-memory snapshot instead of history (default false)"),
+            ],
+            returns: .array(model: "OcrSearchResult"),
+            handler: { params in
+                guard let query = params?["query"]?.stringValue else {
+                    throw RouterError.missingParam("query")
+                }
+                let app = params?["app"]?.stringValue
+                let limit = params?["limit"]?.intValue ?? 50
+                let live = params?["live"]?.boolValue ?? false
+
+                if live {
+                    // In-memory snapshot search (original behavior)
+                    var results = Array(OcrModel.shared.results.values)
+                    let q = query.lowercased()
+                    results = results.filter { $0.fullText.lowercased().contains(q) }
+                    if let app { results = results.filter { $0.app == app } }
+                    return .array(results.prefix(limit).map { Encoders.ocrResult($0) })
+                }
+
+                // Persistent FTS5 search
+                let results = OcrStore.shared.search(query: query, app: app, limit: limit)
+                return .array(results.map { Encoders.ocrSearchResult($0) })
+            }
+        ))
+
+        api.register(Endpoint(
+            method: "ocr.history",
+            description: "Get OCR content timeline for a specific window",
+            access: .read,
+            params: [
+                Param(name: "wid", type: "uint32", required: true, description: "Window ID"),
+                Param(name: "limit", type: "int", required: false, description: "Max results (default 50)"),
+            ],
+            returns: .array(model: "OcrSearchResult"),
+            handler: { params in
+                guard let wid = params?["wid"]?.uint32Value else {
+                    throw RouterError.missingParam("wid")
+                }
+                let limit = params?["limit"]?.intValue ?? 50
+                let results = OcrStore.shared.history(wid: wid, limit: limit)
+                return .array(results.map { Encoders.ocrSearchResult($0) })
+            }
+        ))
+
+        api.register(Endpoint(
+            method: "ocr.scan",
+            description: "Trigger an immediate OCR scan",
+            access: .mutate,
+            params: [],
+            returns: .ok,
+            handler: { _ in
+                OcrModel.shared.scan()
+                return .object(["ok": .bool(true)])
+            }
+        ))
+
         // ── Endpoints: Mutations ────────────────────────────────
 
         api.register(Endpoint(
@@ -857,6 +1023,50 @@ enum Encoders {
         return .object(obj)
     }
 
+    static func ocrResult(_ r: OcrWindowResult) -> JSON {
+        .object([
+            "wid": .int(Int(r.wid)),
+            "app": .string(r.app),
+            "title": .string(r.title),
+            "frame": .object([
+                "x": .double(r.frame.x),
+                "y": .double(r.frame.y),
+                "w": .double(r.frame.w),
+                "h": .double(r.frame.h)
+            ]),
+            "fullText": .string(r.fullText),
+            "blocks": .array(r.texts.map { block in
+                .object([
+                    "text": .string(block.text),
+                    "confidence": .double(Double(block.confidence)),
+                    "x": .double(block.boundingBox.origin.x),
+                    "y": .double(block.boundingBox.origin.y),
+                    "w": .double(block.boundingBox.size.width),
+                    "h": .double(block.boundingBox.size.height)
+                ])
+            }),
+            "timestamp": .double(r.timestamp.timeIntervalSince1970)
+        ])
+    }
+
+    static func ocrSearchResult(_ r: OcrSearchResult) -> JSON {
+        .object([
+            "id": .int(Int(r.id)),
+            "wid": .int(Int(r.wid)),
+            "app": .string(r.app),
+            "title": .string(r.title),
+            "frame": .object([
+                "x": .double(r.frame.x),
+                "y": .double(r.frame.y),
+                "w": .double(r.frame.w),
+                "h": .double(r.frame.h)
+            ]),
+            "fullText": .string(r.fullText),
+            "snippet": .string(r.snippet),
+            "timestamp": .double(r.timestamp.timeIntervalSince1970)
+        ])
+    }
+
     static func enrichedSession(_ s: TmuxSession) -> JSON {
         let pm = ProcessModel.shared
         return .object([