@lattices/cli 0.3.0 → 0.4.1

package/app/Sources/AgentSession.swift

@@ -0,0 +1,377 @@
+import Foundation
+
+// MARK: - Persistent Claude CLI Agent
+
+/// Manages a persistent Claude conversation via `--session-id` + `--resume`.
+/// Each query spawns a `claude -p` process that resumes the same session.
+/// Uses `--output-format stream-json` for structured response parsing.
+/// The conversation context carries over between calls via session persistence.
+
+final class AgentSession: ObservableObject {
+    let model: String
+    let label: String
+    private(set) var sessionId: UUID
+
+    @Published var isReady = false
+    @Published var lastResponse: AgentResponse?
+    @Published var sessionStats: SessionStats = .empty
+
+    struct SessionStats {
+        let inputTokens: Int
+        let outputTokens: Int
+        let cacheReadTokens: Int
+        let cacheCreationTokens: Int
+        let contextWindow: Int
+        let costUSD: Double
+        let numTurns: Int
+
+        static let empty = SessionStats(inputTokens: 0, outputTokens: 0, cacheReadTokens: 0, cacheCreationTokens: 0, contextWindow: 0, costUSD: 0, numTurns: 0)
+
+        /// How full is the context? 0.0–1.0
+        var contextUsage: Double {
+            guard contextWindow > 0 else { return 0 }
+            let totalInput = inputTokens + cacheReadTokens + cacheCreationTokens
+            return Double(totalInput) / Double(contextWindow)
+        }
+    }
+
+    private var claudePath: String?
+    private let queue = DispatchQueue(label: "agent-session", qos: .userInitiated)
+    private var callCount = 0
+    private var busy = false
+
+    /// Optional override for the system prompt. If set, used instead of the default advisor prompt.
+    var customSystemPrompt: (() -> String)?
+
+    init(model: String, label: String) {
+        self.model = model
+        self.label = label
+        self.sessionId = UUID()
+    }
+
+    // MARK: - Lifecycle
+
+    func start() {
+        guard let resolved = Preferences.resolveClaudePath() else {
+            DiagnosticLog.shared.warn("AgentSession[\(label)]: claude CLI not found")
+            return
+        }
+        claudePath = resolved
+        DiagnosticLog.shared.info("AgentSession[\(label)]: ready (model=\(model), claude=\(resolved), session=\(sessionId.uuidString.prefix(8)))")
+        DispatchQueue.main.async { self.isReady = true }
+    }
+
+    func stop() {
+        DispatchQueue.main.async {
+            self.isReady = false
+            self.callCount = 0
+        }
+    }
+
+    // MARK: - Communication
+
+    /// Send a message and get a response via callback (main thread).
+    func send(message: String, callback: @escaping (AgentResponse?) -> Void) {
+        guard isReady else {
+            callback(nil)
+            return
+        }
+        guard !busy else {
+            DiagnosticLog.shared.info("AgentSession[\(label)]: busy, skipping")
+            callback(nil)
+            return
+        }
+
+        queue.async { [weak self] in
+            guard let self = self else { return }
+            self.busy = true
+            let response = self.call(prompt: message)
+            self.busy = false
+
+            DispatchQueue.main.async {
+                self.lastResponse = response
+                callback(response)
+            }
+        }
+    }
+
+    // MARK: - Claude CLI call
+
+    private func call(prompt: String) -> AgentResponse? {
+        let timer = DiagnosticLog.shared.startTimed("AgentSession[\(label)] call")
+
+        guard let claudePath = claudePath else { return nil }
+
+        let proc = Process()
+        proc.executableURL = URL(fileURLWithPath: claudePath)
+
+        var args = [
+            "-p", prompt,
+            "--model", model,
+            "--output-format", "stream-json",
+            "--max-budget-usd", String(format: "%.2f", Preferences.shared.advisorBudgetUSD),
+            "--permission-mode", "plan",
+            "--no-chrome",
+        ]
+
+        if callCount == 0 {
+            // First call: create session with system prompt
+            args.append(contentsOf: [
+                "--session-id", sessionId.uuidString,
+                "--system-prompt", customSystemPrompt?() ?? buildSystemPrompt(),
+            ])
+        } else {
+            // Subsequent calls: resume existing session (context carries over)
+            args.append(contentsOf: ["--resume", sessionId.uuidString])
+        }
+
+        proc.arguments = args
+
+        var env = ProcessInfo.processInfo.environment
+        env.removeValue(forKey: "CLAUDECODE")
+        proc.environment = env
+
+        let outPipe = Pipe()
+        let errPipe = Pipe()
+        proc.standardOutput = outPipe
+        proc.standardError = errPipe
+
+        do {
+            try proc.run()
+        } catch {
+            DiagnosticLog.shared.warn("AgentSession[\(label)]: launch failed — \(error)")
+            DiagnosticLog.shared.finish(timer)
+            return nil
+        }
+
+        proc.waitUntilExit()
+        DiagnosticLog.shared.finish(timer)
+
+        let output = String(data: outPipe.fileHandleForReading.readDataToEndOfFile(), encoding: .utf8)?
+            .trimmingCharacters(in: .whitespacesAndNewlines) ?? ""
+        let stderr = String(data: errPipe.fileHandleForReading.readDataToEndOfFile(), encoding: .utf8)?
+            .trimmingCharacters(in: .whitespacesAndNewlines) ?? ""
+
+        if !stderr.isEmpty {
+            DiagnosticLog.shared.info("AgentSession[\(label)] stderr: \(stderr.prefix(200))")
+        }
+
+        guard !output.isEmpty else {
+            DiagnosticLog.shared.info("AgentSession[\(label)]: empty response")
+            return nil
+        }
+
+        // Parse stream-json output — extract text and stats
+        let parsed = parseStreamJSON(output)
+
+        // Update session stats
+        let stats = parsed.stats
+        DispatchQueue.main.async {
+            self.sessionStats = stats
+        }
+
+        if stats.contextWindow > 0 {
+            let pct = Int(stats.contextUsage * 100)
+            DiagnosticLog.shared.info("AgentSession[\(label)]: context \(pct)% (\(stats.inputTokens + stats.cacheReadTokens + stats.cacheCreationTokens)/\(stats.contextWindow)) cost=$\(String(format: "%.4f", stats.costUSD))")
+        }
+
+        guard let text = parsed.text, !text.isEmpty else {
+            DiagnosticLog.shared.info("AgentSession[\(label)]: no text in response")
+            return nil
+        }
+
+        // Auto-reset session if context usage > 75%
+        if stats.contextUsage > 0.75 {
+            DiagnosticLog.shared.warn("AgentSession[\(label)]: context at \(Int(stats.contextUsage * 100))%, resetting session")
+            sessionId = UUID()  // Fresh session ID
+            callCount = 0       // Next call will create a fresh session
+        } else {
+            callCount += 1
+        }
+
+        DiagnosticLog.shared.info("AgentSession[\(label)]: \(text.prefix(120))")
+        return AgentResponse.parse(text: text)
+    }
+
+    struct ParsedResponse {
+        let text: String?
+        let stats: SessionStats
+    }
+
+    /// Parse stream-json output lines, extract text and session stats from the result line.
+    private func parseStreamJSON(_ output: String) -> ParsedResponse {
+        let lines = output.components(separatedBy: "\n")
+        var resultText: String?
+        var stats = SessionStats.empty
+
+        for line in lines {
+            guard let data = line.data(using: .utf8),
+                  let json = try? JSONSerialization.jsonObject(with: data) as? [String: Any] else { continue }
+
+            let type = json["type"] as? String
+
+            if type == "result" {
+                resultText = json["result"] as? String
+                let numTurns = json["num_turns"] as? Int ?? 0
+                let costUSD = json["total_cost_usd"] as? Double ?? 0
+
+                // Usage stats
+                let usage = json["usage"] as? [String: Any] ?? [:]
+                let inputTokens = usage["input_tokens"] as? Int ?? 0
+                let outputTokens = usage["output_tokens"] as? Int ?? 0
+                let cacheRead = usage["cache_read_input_tokens"] as? Int ?? 0
+                let cacheCreation = usage["cache_creation_input_tokens"] as? Int ?? 0
+
+                // Context window from modelUsage
+                var contextWindow = 0
+                if let modelUsage = json["modelUsage"] as? [String: Any] {
+                    for (_, v) in modelUsage {
+                        if let m = v as? [String: Any], let cw = m["contextWindow"] as? Int {
+                            contextWindow = cw
+                        }
+                    }
+                }
+
+                stats = SessionStats(
+                    inputTokens: inputTokens,
+                    outputTokens: outputTokens,
+                    cacheReadTokens: cacheRead,
+                    cacheCreationTokens: cacheCreation,
+                    contextWindow: contextWindow,
+                    costUSD: costUSD,
+                    numTurns: numTurns
+                )
+            }
+
+            // Fallback: accumulate text from assistant content blocks
+            if resultText == nil, type == "assistant",
+               let message = json["message"] as? [String: Any],
+               let content = message["content"] as? [[String: Any]] {
+                var text = ""
+                for block in content {
+                    if block["type"] as? String == "text",
+                       let t = block["text"] as? String {
+                        text += t
+                    }
+                }
+                if !text.isEmpty { resultText = text }
+            }
+        }
+
+        return ParsedResponse(text: resultText, stats: stats)
+    }
+
+    // MARK: - System prompt
+
+    private func buildSystemPrompt() -> String {
+        let windowSummary = DesktopModel.shared.windows.values
+            .prefix(20)
+            .map { "\($0.app): \($0.title)" }
+            .joined(separator: "\n")
+
+        let intentList = PhraseMatcher.shared.catalog()
+        var intentSummary = ""
+        if case .array(let intents) = intentList {
+            intentSummary = intents.compactMap { intent -> String? in
+                guard let name = intent["intent"]?.stringValue else { return nil }
+                var slotNames: [String] = []
+                if case .array(let slots) = intent["slots"] {
+                    slotNames = slots.compactMap { $0["name"]?.stringValue }
+                }
+                let s = slotNames.isEmpty ? "" : "(\(slotNames.joined(separator: ", ")))"
+                return "\(name)\(s)"
+            }.joined(separator: ", ")
+        }
+
+        return """
+        You are an advisor for Lattices, a macOS workspace manager. You run alongside voice commands, providing commentary and follow-up suggestions.
+
+        Available commands: \(intentSummary)
+
+        Current windows:
+        \(windowSummary)
+
+        For each user message, you receive a voice transcript and what command was matched.
+
+        Respond with ONLY a JSON object:
+        {"commentary": "short observation or null", "suggestion": {"label": "button text", "intent": "intent_name", "slots": {"key": "value"}} or null}
+
+        Rules:
+        - commentary: 1 sentence max. null if the matched command fully covers the request.
+        - suggestion: a follow-up action. null if none needed.
+        - Never suggest what was already executed.
+        - Suggestions MUST include all required slots. e.g. search requires {"query": "..."}.
+        - Be terse and useful, not chatty.
+        """
+    }
+}
+
+// MARK: - Response types
+
+struct AgentResponse {
+    let commentary: String?
+    let suggestion: AgentSuggestion?
+    let raw: String
+
+    struct AgentSuggestion {
+        let label: String
+        let intent: String
+        let slots: [String: String]
+    }
+
+    static func parse(text: String) -> AgentResponse {
+        guard let jsonStr = extractJSON(from: text),
+              let data = jsonStr.data(using: .utf8),
+              let json = try? JSONSerialization.jsonObject(with: data) as? [String: Any] else {
+            return AgentResponse(commentary: text, suggestion: nil, raw: text)
+        }
+
+        let commentary = json["commentary"] as? String
+
+        var suggestion: AgentSuggestion?
+        if let s = json["suggestion"] as? [String: Any],
+           let label = s["label"] as? String,
+           let intent = s["intent"] as? String {
+            let slots = (s["slots"] as? [String: String]) ?? [:]
+            suggestion = AgentSuggestion(label: label, intent: intent, slots: slots)
+        }
+
+        return AgentResponse(commentary: commentary, suggestion: suggestion, raw: text)
+    }
+
+    private static func extractJSON(from text: String) -> String? {
+        let cleaned = text
+            .replacingOccurrences(of: "```json", with: "")
+            .replacingOccurrences(of: "```", with: "")
+            .trimmingCharacters(in: .whitespacesAndNewlines)
+        guard let start = cleaned.firstIndex(of: "{"),
+              let end = cleaned.lastIndex(of: "}") else { return nil }
+        return String(cleaned[start...end])
+    }
+}
+
+// MARK: - Agent Pool
+
+/// Manages the Haiku (fast advisor) and Sonnet (deep thinker) agent sessions.
+final class AgentPool {
+    static let shared = AgentPool()
+
+    let haiku = AgentSession(model: "haiku", label: "haiku")
+    let sonnet = AgentSession(model: "sonnet", label: "sonnet")
+
+    private init() {}
+
+    func start() {
+        DiagnosticLog.shared.info("AgentPool: starting haiku + sonnet sessions")
+        haiku.start()
+        // Stagger sonnet start
+        DispatchQueue.global().asyncAfter(deadline: .now() + 5) {
+            self.sonnet.start()
+        }
+    }
+
+    func stop() {
+        haiku.stop()
+        sonnet.stop()
+    }
+}

package/app/Sources/AppDelegate.swift

@@ -81,19 +81,48 @@ class AppDelegate: NSObject, NSApplicationDelegate, NSPopoverDelegate {
 
         let store = HotkeyStore.shared
         store.register(action: .palette) { CommandPaletteWindow.shared.toggle() }
-        store.register(action: .screenMap) { ScreenMapWindowController.shared.toggle() }
+        store.register(action: .unifiedWindow) { ScreenMapWindowController.shared.toggle() }
         store.register(action: .bezel) { WindowBezel.showBezelForFrontmostWindow() }
         store.register(action: .cheatSheet) { CheatSheetHUD.shared.toggle() }
-        store.register(action: .desktopInventory) { CommandModeWindow.shared.toggle() }
+        store.register(action: .voiceCommand) {
+            DiagnosticLog.shared.info("Hotkey: voiceCommand triggered")
+            VoiceCommandWindow.shared.toggle()
+        }
+        store.register(action: .handsOff) {
+            DiagnosticLog.shared.info("Hotkey: handsOff triggered")
+            HandsOffSession.shared.toggle()
+            // Show voice bar when starting, hide when stopping
+            if HandsOffSession.shared.state != .idle {
+                HUDController.shared.showVoiceBar()
+            } else {
+                HUDController.shared.hideVoiceBar()
+            }
+        }
+        store.register(action: .hud) { HUDController.shared.toggle() }
+        store.register(action: .mouseFinder) { MouseFinder.shared.find() }
+
+        // Pre-render HUD panels off-screen for instant first open
+        DispatchQueue.main.async { HUDController.shared.warmUp() }
         store.register(action: .omniSearch) { OmniSearchWindow.shared.toggle() }
 
-        // Layer-switching hotkeys
+        // Session layer cycling
+        store.register(action: .layerNext) { SessionLayerStore.shared.cycleNext() }
+        store.register(action: .layerPrev) { SessionLayerStore.shared.cyclePrev() }
+        store.register(action: .layerTag)  { SessionLayerStore.shared.tagFrontmostWindow() }
+
+        // Layer-switching hotkeys (1-9): session layers take priority
         let workspace = WorkspaceManager.shared
-        let layerCount = (workspace.config?.layers ?? []).count
-        for (i, action) in HotkeyAction.layerActions.prefix(layerCount).enumerated() {
+        let configLayerCount = (workspace.config?.layers ?? []).count
+        let maxLayers = max(configLayerCount, 9)
+        for (i, action) in HotkeyAction.layerActions.prefix(maxLayers).enumerated() {
             let index = i
             store.register(action: action) {
-                workspace.tileLayer(index: index, launch: true, force: true)
+                let session = SessionLayerStore.shared
+                if !session.layers.isEmpty && index < session.layers.count {
+                    session.switchTo(index: index)
+                } else {
+                    workspace.focusLayer(index: index)
+                }
                 EventBus.shared.post(.layerSwitched(index: index))
             }
         }
@@ -113,8 +142,10 @@ class AppDelegate: NSObject, NSApplicationDelegate, NSPopoverDelegate {
         }
         store.register(action: .tileDistribute) { WindowTiler.distributeVisible() }
 
-        // Check macOS permissions (Accessibility, Screen Recording)
-        PermissionChecker.shared.check()
+        // Onboarding on first launch; otherwise just check permissions
+        if !OnboardingWindowController.shared.showIfNeeded() {
+            PermissionChecker.shared.check()
+        }
 
         // Start daemon services
         let diag = DiagnosticLog.shared
@@ -126,6 +157,8 @@ class AppDelegate: NSObject, NSApplicationDelegate, NSPopoverDelegate {
         ProcessModel.shared.start()
         LatticesApi.setup()
         DaemonServer.shared.start()
+        AgentPool.shared.start()
+        HandsOffSession.shared.start()
         diag.finish(tBoot)
 
         // --diagnostics flag: auto-open diagnostics panel on launch
@@ -175,7 +208,7 @@ class AppDelegate: NSObject, NSApplicationDelegate, NSPopoverDelegate {
         let p = NSPopover()
         p.contentViewController = NSHostingController(rootView: MainView(scanner: ProjectScanner.shared))
         p.behavior = .transient
-        p.contentSize = NSSize(width: 380, height: 520)
+        p.contentSize = NSSize(width: 380, height: 560)
         p.appearance = NSAppearance(named: .darkAqua)
         p.delegate = self
         popover = p
@@ -196,8 +229,8 @@ class AppDelegate: NSObject, NSApplicationDelegate, NSPopoverDelegate {
 
         let actions: [(String, String, Selector)] = [
             ("Command Palette", "⌘⇧M", #selector(menuCommandPalette)),
-            ("Screen Map", "", #selector(menuScreenMap)),
-            ("Desktop Inventory", "", #selector(menuDesktopInventory)),
+            ("Unified Window", "", #selector(menuScreenMap)),
+            ("HUD", "", #selector(menuHUD)),
             ("Window Bezel", "", #selector(menuWindowBezel)),
             ("Cheat Sheet", "", #selector(menuCheatSheet)),
             ("Omni Search", "", #selector(menuOmniSearch)),
@@ -232,7 +265,7 @@ class AppDelegate: NSObject, NSApplicationDelegate, NSPopoverDelegate {
 
     @objc private func menuCommandPalette() { CommandPaletteWindow.shared.toggle() }
     @objc private func menuScreenMap() { ScreenMapWindowController.shared.toggle() }
-    @objc private func menuDesktopInventory() { CommandModeWindow.shared.toggle() }
+    @objc private func menuHUD() { HUDController.shared.toggle() }
     @objc private func menuWindowBezel() { WindowBezel.showBezelForFrontmostWindow() }
     @objc private func menuCheatSheet() { CheatSheetHUD.shared.toggle() }
     @objc private func menuOmniSearch() { OmniSearchWindow.shared.toggle() }

package/app/Sources/AppShellView.swift

@@ -3,25 +3,37 @@ import SwiftUI
 // MARK: - Navigation Pages
 
 enum AppPage: String, CaseIterable {
+    case home
     case screenMap
+    case desktopInventory
+    case pi
     case settings
     case docs
 
     var label: String {
         switch self {
-        case .screenMap: return "Screen Map"
-        case .settings:  return "Settings"
-        case .docs:      return "Docs"
+        case .home:             return "Home"
+        case .screenMap:        return "Screen Map"
+        case .desktopInventory: return "Desktop Inventory"
+        case .pi:               return "Pi"
+        case .settings:         return "Settings"
+        case .docs:             return "Docs"
         }
     }
 
     var icon: String {
         switch self {
-        case .screenMap: return "rectangle.3.group"
-        case .settings:  return "gearshape"
-        case .docs:      return "book"
+        case .home:             return "house"
+        case .screenMap:        return "rectangle.3.group"
+        case .desktopInventory: return "macwindow.on.rectangle"
+        case .pi:               return "terminal"
+        case .settings:         return "gearshape"
+        case .docs:             return "book"
         }
     }
+
+    /// Pages shown as primary tabs in the unified window
+    static var primaryTabs: [AppPage] { [.home, .screenMap, .desktopInventory, .pi] }
 }
 
 // MARK: - App Shell View
@@ -29,10 +41,61 @@ enum AppPage: String, CaseIterable {
 struct AppShellView: View {
     @ObservedObject var controller: ScreenMapController
     @ObservedObject var windowController = ScreenMapWindowController.shared
+    @StateObject private var commandState = CommandModeState()
 
     var body: some View {
-        contentArea
-            .background(Palette.bg)
+        VStack(spacing: 0) {
+            // Tab bar (only on primary pages)
+            if AppPage.primaryTabs.contains(windowController.activePage) {
+                tabBar
+                Rectangle().fill(Palette.border).frame(height: 0.5)
+            }
+
+            contentArea
+        }
+        .background(Palette.bg)
+        .onAppear {
+            commandState.onDismiss = { windowController.activePage = .home }
+        }
+    }
+
+    // MARK: - Tab Bar
+
+    private var tabBar: some View {
+        HStack(spacing: 0) {
+            ForEach(AppPage.primaryTabs, id: \.rawValue) { tab in
+                tabButton(tab)
+            }
+            Spacer()
+        }
+        .padding(.horizontal, 12)
+        .padding(.top, 8)
+        .padding(.bottom, 4)
+    }
+
+    private func tabButton(_ tab: AppPage) -> some View {
+        let isActive = windowController.activePage == tab
+
+        return Button {
+            windowController.activePage = tab
+            if tab == .screenMap { controller.enter() }
+            if tab == .desktopInventory { commandState.enter() }
+        } label: {
+            HStack(spacing: 5) {
+                Image(systemName: tab.icon)
+                    .font(.system(size: 10))
+                Text(tab.label)
+                    .font(Typo.monoBold(11))
+            }
+            .foregroundColor(isActive ? Palette.text : Palette.textMuted)
+            .padding(.horizontal, 12)
+            .padding(.vertical, 6)
+            .background(
+                RoundedRectangle(cornerRadius: 6)
+                    .fill(isActive ? Palette.surfaceHov : Color.clear)
+            )
+        }
+        .buttonStyle(.plain)
     }
 
     // MARK: - Content Area
@@ -40,10 +103,20 @@ struct AppShellView: View {
     @ViewBuilder
     private var contentArea: some View {
         switch windowController.activePage {
+        case .home:
+            HomeDashboardView(onNavigate: { page in
+                windowController.activePage = page
+                if page == .screenMap { controller.enter() }
+                if page == .desktopInventory { commandState.enter() }
+            })
         case .screenMap:
             ScreenMapView(controller: controller, onNavigate: { page in
                 windowController.activePage = page
             })
+        case .desktopInventory:
+            CommandModeView(state: commandState)
+        case .pi:
+            PiWorkspaceView()
         case .settings:
             SettingsContentView(
                 prefs: Preferences.shared,