agentix-cli 0.50.1 → 0.51.0

package/apps/mac-voice/Sources/AgentXVoice/AgentClient.swift

@@ -63,7 +63,7 @@ enum AgentClient {
 
     /// What was speaking when the door opened.
     struct Hushed {
-        /// "talk", "lesson" or "narration"; nil when nothing was.
+        /// "talk", "lesson", "narration" or "queue"; nil when nothing was.
         let kind: String?
         let agentID: String?
         static let nothing = Hushed(kind: nil, agentID: nil)
@@ -84,6 +84,39 @@ enum AgentClient {
         _ = try? await post("/voice/stop", [:], timeout: 2)
     }
 
+    /// The listener said nothing after the hush, so no door follows: the
+    /// daemon's speaking queue plays on.
+    static func resume() async {
+        _ = try? await post("/voice/queue/resume", [:], timeout: 2)
+    }
+
+    // MARK: The speaking queue
+    //
+    // Everything spoken on this Mac waits in one queue on the daemon, so
+    // an answer never plays over another agent, a talk or narration. See
+    // src/daemon/voice-queue-api.ts.
+
+    /// Queue a line in the agent's voice and wait until it has been
+    /// spoken, skipped or stopped. False only when the daemon could not
+    /// take it, so the caller speaks it here instead. A cancelled wait
+    /// (the door opened) is true: the line stays queued and plays after
+    /// the listener's turn.
+    static func queue(_ text: String, agentID: String, kind: String) async -> Bool {
+        do {
+            // A line may wait behind others, and a held queue for a minute.
+            let (_, response) = try await post("/voice/queue",
+                ["text": text, "agentId": agentID, "kind": kind, "wait": true], timeout: 900)
+            guard let http = response as? HTTPURLResponse else { return false }
+            return (200..<300).contains(http.statusCode)
+        } catch let e as URLError where [.cannotConnectToHost, .cannotFindHost, .notConnectedToInternet, .networkConnectionLost].contains(e.code) {
+            return false
+        } catch {
+            // Cancelled or timed out after the daemon took the line:
+            // playing it here too would talk over it.
+            return true
+        }
+    }
+
     /// Hand the listener's words through the door. True when an activity
     /// took them (a talk or lesson answers; "stop" ends it); false means
     /// nothing did, and they are an ordinary question.
@@ -102,20 +135,40 @@ enum AgentClient {
         return try await URLSession.shared.data(for: req)
     }
 
-    /// The agent that answers: the configured one, or the daemon's
-    /// `node.defaultAgent` from /health. "" when neither is known.
+    /// One row of GET /agents: who can answer, and whether they are busy.
+    struct AgentInfo: Decodable {
+        let id: String
+        let name: String?
+        /// Tasks running now.
+        let active: Int?
+        var label: String { name ?? id }
+    }
+
+    /// The daemon's agents, or nil when the daemon cannot be reached.
+    static func agents() async -> [AgentInfo]? {
+        guard let url = URL(string: "\(Config.daemonURL)/agents") else { return nil }
+        var req = URLRequest(url: url)
+        req.timeoutInterval = 3
+        guard let (data, response) = try? await URLSession.shared.data(for: req),
+              (response as? HTTPURLResponse)?.statusCode == 200 else { return nil }
+        return try? JSONDecoder().decode([AgentInfo].self, from: data)
+    }
+
+    /// The agent that answers: the pinned one, the one picked in the menu,
+    /// the daemon's `node.defaultAgent` from /health, or its first agent —
+    /// /ask refuses a request with no agent when there is no default.
+    /// "" when none is known.
     static func resolveAgent() async -> String {
-        if let agent = Config.agentID { return agent }
-        guard let url = URL(string: "\(Config.daemonURL)/health"),
-              let (data, _) = try? await URLSession.shared.data(from: url),
-              let obj = try? JSONSerialization.jsonObject(with: data) as? [String: Any],
-              let node = obj["node"] as? [String: Any],
-              let agent = node["defaultAgent"] as? String
-        else { return "" }
-        return agent
+        if let agent = Config.agentID ?? Config.chosenAgentID { return agent }
+        if let url = URL(string: "\(Config.daemonURL)/health"),
+           let (data, _) = try? await URLSession.shared.data(from: url),
+           let obj = try? JSONSerialization.jsonObject(with: data) as? [String: Any],
+           let node = obj["node"] as? [String: Any],
+           let agent = node["defaultAgent"] as? String, !agent.isEmpty { return agent }
+        return await agents()?.first?.id ?? ""
     }
 
-    static func ask(_ message: String) async throws -> Answer {
+    static func ask(_ message: String, agent: String) async throws -> Answer {
         var req = URLRequest(url: URL(string: "\(Config.daemonURL)/ask")!)
         req.httpMethod = "POST"
         // An agent turn routinely takes minutes. The default 60s would cut
@@ -123,8 +176,8 @@ enum AgentClient {
         req.timeoutInterval = 600
         req.setValue("application/json", forHTTPHeaderField: "Content-Type")
         var payload: [String: Any] = ["message": message, "session": Config.voiceSession]
-        // No agent configured: the daemon answers with its default agent.
-        if let agent = Config.agentID { payload["agent"] = agent }
+        // No agent known: the daemon answers with its default agent.
+        if !agent.isEmpty { payload["agent"] = agent }
         req.httpBody = try JSONSerialization.data(withJSONObject: payload)
 
         let (data, response) = try await URLSession.shared.data(for: req)

package/apps/mac-voice/Sources/AgentXVoice/Config.swift

@@ -8,11 +8,28 @@ import Foundation
 /// from a terminal and mysteriously fails when you double-click it.
 enum Config {
     static let daemonURL = env("AGENTX_DAEMON_URL") ?? "http://127.0.0.1:18800"
-    /// The agent that answers. Unset: the daemon's `node.defaultAgent`.
+    /// The dashboard, for the menu's Settings… and History….
+    static let dashboardURL = env("AGENTX_DASHBOARD_URL") ?? "http://127.0.0.1:4202"
+    /// An agent pinned by the environment. Wins over the menu's choice.
     static let agentID = env("AGENTX_VOICE_AGENT")
 
-    /// The agent actually answering: `agentID`, or the daemon's default,
-    /// read once at launch (AgentClient.resolveAgent). Progress follows it.
+    /// The agent picked in the menu, remembered across launches. A UI
+    /// choice, so UserDefaults rather than agentx.json.
+    static var chosenAgentID: String? {
+        get { UserDefaults.standard.string(forKey: "targetAgent") }
+        set { UserDefaults.standard.set(newValue, forKey: "targetAgent") }
+    }
+
+    /// The floating pill stays on screen when idle. Off by default: the
+    /// menu-bar icon shows the state, and the pill appears only while
+    /// listening or answering.
+    static var showPill: Bool {
+        get { UserDefaults.standard.bool(forKey: "showPill") }
+        set { UserDefaults.standard.set(newValue, forKey: "showPill") }
+    }
+
+    /// The agent actually answering: `agentID`, else `chosenAgentID`, else
+    /// the daemon's default (AgentClient.resolveAgent). Progress follows it.
     @MainActor static var effectiveAgentID: String = ""
 
     /// Who speaks before the daemon has said which voice an agent uses:

package/apps/mac-voice/Sources/AgentXVoice/Panel.swift

@@ -36,43 +36,23 @@ final class Panel: NSPanel {
         super.mouseDown(with: event)
     }
 
-    /// Right-click opens the only menu the widget has.
-    ///
-    /// A hold has to be reversible in one gesture from wherever you are,
-    /// and it has to SHOW — a switch that silences your notifications
-    /// without saying so is how people miss things for a day and blame the
-    /// software.
+    /// Right-click opens the same menu as the menu-bar icon.
     override func rightMouseDown(with event: NSEvent) {
-        let menu = NSMenu()
-        let holding = Hold.isOn
-        let item = NSMenuItem(
-            title: holding ? "Delivering notifications" : "Hold notifications",
-            action: #selector(toggleHold), keyEquivalent: "")
-        item.target = self
-        item.state = holding ? .on : .off
-        menu.addItem(item)
-        let stop = NSMenuItem(title: "Stop speaking  ⌘⌥.", action: #selector(stopSpeaking), keyEquivalent: "")
-        stop.target = self
-        menu.addItem(stop)
-        menu.addItem(.separator())
-        let quit = NSMenuItem(title: "Quit AgentX Voice",
-                              action: #selector(NSApplication.terminate(_:)), keyEquivalent: "q")
-        menu.addItem(quit)
+        guard let menu = contextMenu?() else { return }
         NSMenu.popUpContextMenu(menu, with: event, for: contentView ?? NSView())
     }
 
-    @objc private func toggleHold() {
-        let nowOn = Hold.toggle()
-        onHoldChanged?(nowOn)
-    }
+    /// The menu to show on right-click. Set by the app.
+    var contextMenu: (() -> NSMenu)?
 
-    /// Told when the hold flips, so the app can redraw and flush.
-    var onHoldChanged: ((Bool) -> Void)?
+    /// The target agent's name, shown while listening or answering.
+    var agentName: () -> String = { "" }
 
-    @objc private func stopSpeaking() { onStop?() }
+    /// Stay on screen when idle. Off: the pill shows only while active.
+    var alwaysVisible = false
 
-    /// "Stop speaking" was chosen. Set by the app.
-    var onStop: (() -> Void)?
+    /// Told of every state rendered, so the menu-bar icon can follow.
+    var onRender: ((State) -> Void)?
 
     override func mouseUp(with event: NSEvent) {
         defer { pressedAt = nil }
@@ -225,8 +205,21 @@ final class Panel: NSPanel {
             label.frame.origin.x = 0
         } else {
             label.textColor = state.color
-            setText(state.text)
+            setText(named(state))
         }
+
+        if state.isMeta && !alwaysVisible { orderOut(nil) } else { orderFrontRegardless() }
+        onRender?(state)
+    }
+
+    /// "Nadia · Listening": who is listening or answering. Errors are the
+    /// widget's own, so they carry no name.
+    @MainActor
+    private func named(_ state: State) -> String {
+        let name = agentName()
+        if name.isEmpty { return state.text }
+        if case .error = state { return state.text }
+        return "\(name) · \(state.text)"
     }
 
     /// Fits, or scrolls. Identical text is left alone so a per-second tick

package/apps/mac-voice/Sources/AgentXVoice/Speech.swift

@@ -112,8 +112,22 @@ enum Speech {
         await AgentClient.stopVoice()
     }
 
-    /// `voice` is the answering agent's, as the daemon resolved it; nil
-    /// (no answer yet) means the provider this app is configured with.
+    /// Say a line through the daemon's speaking queue, in the agent's
+    /// voice, after whatever is already speaking. Played here only when
+    /// the daemon cannot be reached. `kind` is "answer", "narration" or
+    /// "line".
+    @MainActor
+    static func say(_ text: String, agentID: String?, kind: String, voice: VoiceChoice?) async {
+        guard !text.isEmpty else { return }
+        let agent = agentID ?? Config.effectiveAgentID
+        if !agent.isEmpty, await AgentClient.queue(text, agentID: agent, kind: kind) { return }
+        if Task.isCancelled { return }
+        await speak(text, voice: voice)
+    }
+
+    /// Speak here, now. `voice` is the answering agent's, as the daemon
+    /// resolved it; nil (no answer yet) means the provider this app is
+    /// configured with.
     static func speak(_ text: String, voice: VoiceChoice? = nil) async {
         guard !text.isEmpty else { return }
         if (voice?.provider ?? Config.voiceProvider) == "elevenlabs" {

package/apps/mac-voice/Sources/AgentXVoice/StatusMenu.swift

@@ -0,0 +1,173 @@
+import AppKit
+
+/// The menu-bar icon: what the assistant is doing, and who it talks to.
+///
+/// One menu serves the icon and the pill's right-click, so there is one
+/// place that says which agent answers and one way to change it.
+@MainActor
+final class StatusMenu: NSObject, NSMenuDelegate {
+    let menu = NSMenu()
+    private let item = NSStatusBar.system.statusItem(withLength: NSStatusItem.squareLength)
+
+    private enum Roster {
+        case loading
+        /// The daemon did not answer. Said so, with a retry, rather than
+        /// an empty list that looks like "you have no agents".
+        case down
+        case loaded([AgentClient.AgentInfo])
+    }
+    private var roster = Roster.loading
+    /// Reopen the menu once the retry's answer is in.
+    private var reopenAfterRefresh = false
+
+    /// Set by the app.
+    var onStop: (() -> Void)?
+    var onHoldChanged: ((Bool) -> Void)?
+    var onTargetChanged: ((String) -> Void)?
+    var onPillChanged: ((Bool) -> Void)?
+
+    override init() {
+        super.init()
+        menu.delegate = self
+        menu.autoenablesItems = false
+        item.menu = menu
+        show(.idle)
+        rebuild()
+    }
+
+    /// The agent's display name, or its id until /agents has answered.
+    func name(of id: String) -> String {
+        guard case .loaded(let agents) = roster else { return id }
+        return agents.first { $0.id == id }?.label ?? id
+    }
+
+    /// Open the menu from the keyboard.
+    func open() { item.button?.performClick(nil) }
+
+    func refresh() {
+        Task {
+            let agents = await AgentClient.agents()
+            roster = agents.map { .loaded($0) } ?? .down
+            rebuild()
+            if reopenAfterRefresh { reopenAfterRefresh = false; open() }
+        }
+    }
+
+    /// The icon follows the pill's state.
+    func show(_ state: Panel.State) {
+        let (symbol, label): (String, String) = switch state {
+        case .idle: Hold.isOn ? ("bell.slash", "Notifications held") : ("waveform", "Idle")
+        case .listening: ("mic.fill", "Listening")
+        case .thinking, .working: ("ellipsis.circle", "Thinking")
+        case .speaking, .saying: ("speaker.wave.2.fill", "Speaking")
+        case .error: ("exclamationmark.triangle", "Error")
+        }
+        guard item.button?.toolTip != "AgentX Voice — \(label)" else { return }
+        let image = NSImage(systemSymbolName: symbol, accessibilityDescription: "AgentX Voice: \(label)")
+        image?.isTemplate = true
+        item.button?.image = image
+        item.button?.toolTip = "AgentX Voice — \(label)"
+    }
+
+    // MARK: NSMenuDelegate
+
+    /// Show what is known now and refresh underneath; the open menu
+    /// updates in place when the answer arrives.
+    func menuWillOpen(_ menu: NSMenu) {
+        rebuild()
+        refresh()
+    }
+
+    // MARK: Building
+
+    private func rebuild() {
+        menu.removeAllItems()
+        let target = Config.effectiveAgentID
+        let pinned = Config.agentID != nil
+
+        switch roster {
+        case .loading:
+            menu.addItem(disabled("Loading agents…"))
+        case .down:
+            menu.addItem(disabled("AgentX daemon isn't reachable"))
+            menu.addItem(action("Retry", #selector(retry), key: "r", modifiers: []))
+        case .loaded(let agents):
+            menu.addItem(NSMenuItem.sectionHeader(title: pinned ? "Agent (set by AGENTX_VOICE_AGENT)" : "Talk to"))
+            if agents.isEmpty { menu.addItem(disabled("No agents configured")) }
+            for (i, agent) in agents.enumerated() {
+                let busy = (agent.active ?? 0) > 0
+                // Digits pick an agent while the menu is open.
+                let row = action(agent.label + (busy ? "  · working" : "  · idle"), #selector(pick(_:)),
+                                 key: i < 9 ? "\(i + 1)" : "", modifiers: [])
+                row.representedObject = agent.id
+                row.state = agent.id == target ? .on : .off
+                row.isEnabled = !pinned
+                menu.addItem(row)
+            }
+        }
+
+        menu.addItem(.separator())
+        menu.addItem(action("Stop speaking", #selector(stop), key: ".", modifiers: [.command, .option]))
+        let hold = action("Hold notifications", #selector(toggleHold), key: "")
+        hold.state = Hold.isOn ? .on : .off
+        menu.addItem(hold)
+        let pill = action("Show floating pill", #selector(togglePill), key: "")
+        pill.state = Config.showPill ? .on : .off
+        menu.addItem(pill)
+
+        menu.addItem(.separator())
+        menu.addItem(action("Settings…", #selector(openSettings), key: ","))
+        menu.addItem(action("History…", #selector(openHistory), key: "y"))
+        menu.addItem(.separator())
+        menu.addItem(NSMenuItem(title: "Quit AgentX Voice",
+                                action: #selector(NSApplication.terminate(_:)), keyEquivalent: "q"))
+    }
+
+    private func disabled(_ title: String) -> NSMenuItem {
+        let row = NSMenuItem(title: title, action: nil, keyEquivalent: "")
+        row.isEnabled = false
+        return row
+    }
+
+    private func action(_ title: String, _ selector: Selector, key: String,
+                        modifiers: NSEvent.ModifierFlags = [.command]) -> NSMenuItem {
+        let row = NSMenuItem(title: title, action: selector, keyEquivalent: key)
+        row.keyEquivalentModifierMask = modifiers
+        row.target = self
+        return row
+    }
+
+    // MARK: Actions
+
+    @objc private func pick(_ sender: NSMenuItem) {
+        guard let id = sender.representedObject as? String else { return }
+        Config.chosenAgentID = id
+        onTargetChanged?(id)
+        rebuild()
+    }
+
+    @objc private func retry() {
+        reopenAfterRefresh = true
+        roster = .loading
+        refresh()
+    }
+
+    @objc private func stop() { onStop?() }
+
+    @objc private func toggleHold() {
+        onHoldChanged?(Hold.toggle())
+    }
+
+    @objc private func togglePill() {
+        Config.showPill.toggle()
+        onPillChanged?(Config.showPill)
+    }
+
+    @objc private func openSettings() { openDashboard("/admin") }
+    @objc private func openHistory() { openDashboard("/activity") }
+
+    private func openDashboard(_ path: String) {
+        guard let url = URL(string: Config.dashboardURL + path) else { return }
+        NSWorkspace.shared.open(url)
+    }
+}

package/apps/mac-voice/Sources/AgentXVoice/main.swift

@@ -17,11 +17,13 @@ import Carbon.HIToolbox
 @MainActor
 final class App: NSObject, NSApplicationDelegate {
     private let panel = Panel()
+    private let statusMenu = StatusMenu()
     private let card = ResultCard()
     private let recorder = Recorder()
     private var hotkey: Hotkey?
     private var pasteHotkey: Hotkey?
     private var stopHotkey: Hotkey?
+    private var menuHotkey: Hotkey?
     /// Set by a stop: the answer being spoken ends without reopening the mic.
     private var silenced = false
     private var busy = false
@@ -37,6 +39,9 @@ final class App: NSObject, NSApplicationDelegate {
     /// Set when the door opens: what was speaking (and is now hushed), so
     /// the words spoken go to that activity rather than to /ask.
     private var talkCheck: Task<AgentClient.Hushed, Never>?
+    /// Waiting for our answer to be spoken by the daemon's queue. The door
+    /// lets go of it: the answer stays queued and plays after the turn.
+    private var speaking: Task<Void, Never>?
     /// Words said while our own turn was still running: they go next, and
     /// the stale answer is not spoken.
     private var followUp: String?
@@ -89,7 +94,25 @@ final class App: NSObject, NSApplicationDelegate {
     func applicationDidFinishLaunching(_ note: Notification) {
         NSApp.setActivationPolicy(.accessory)
         retireOlderInstances()
-        panel.orderFrontRegardless()
+        panel.onRender = { [weak self] state in self?.statusMenu.show(state) }
+        panel.contextMenu = { [weak self] in self?.statusMenu.menu ?? NSMenu() }
+        panel.agentName = { [weak self] in
+            Config.effectiveAgentID.isEmpty ? "" : self?.statusMenu.name(of: Config.effectiveAgentID) ?? ""
+        }
+        panel.alwaysVisible = Config.showPill
+        panel.render(.idle)
+        statusMenu.onPillChanged = { [weak self] on in
+            guard let self else { return }
+            self.panel.alwaysVisible = on
+            if !self.busy && !self.recorder.isRecording { self.panel.render(.idle) }
+        }
+        statusMenu.onTargetChanged = { [weak self] id in
+            Config.effectiveAgentID = id
+            // The last answer's voice belongs to the previous agent.
+            self?.voice = nil
+            Log.info("target agent: \(id)")
+        }
+        statusMenu.refresh()
 
         hotkey = Hotkey(
             id: 1,
@@ -102,7 +125,7 @@ final class App: NSObject, NSApplicationDelegate {
         // becomes welcome. Without this the queue is a hole rather than a
         // delay — the daemon's watcher only notices SYSTEM Focus ending,
         // and this switch is not that.
-        panel.onHoldChanged = { [weak self] nowOn in
+        statusMenu.onHoldChanged = { [weak self] nowOn in
             guard let self else { return }
             self.panel.render(.idle)
             if !nowOn { Hold.flushHeld() }
@@ -120,7 +143,7 @@ final class App: NSObject, NSApplicationDelegate {
         pasteHotkey?.register(keyCode: UInt32(kVK_ANSI_V),
                               modifiers: UInt32(cmdKey | optionKey))
 
-        // ⌘⌥. (and the pill's menu): stop every voice now. ⌘. is the Mac's
+        // ⌘⌥. (and the menu): stop every voice now. ⌘. is the Mac's
         // own "cancel"; Option keeps it from reaching the app in front.
         stopHotkey = Hotkey(
             id: 3,
@@ -128,16 +151,28 @@ final class App: NSObject, NSApplicationDelegate {
             onRelease: { [weak self] in self?.stopSpeaking() })
         stopHotkey?.register(keyCode: UInt32(kVK_ANSI_Period),
                              modifiers: UInt32(cmdKey | optionKey))
-        panel.onStop = { [weak self] in self?.stopSpeaking() }
+        statusMenu.onStop = { [weak self] in self?.stopSpeaking() }
+
+        // ⌘⌥A: open the menu-bar menu without the mouse; arrows, digits
+        // and Return work from there.
+        menuHotkey = Hotkey(
+            id: 4,
+            onPress: {},
+            onRelease: { [weak self] in self?.statusMenu.open() })
+        menuHotkey?.register(keyCode: UInt32(kVK_ANSI_A),
+                             modifiers: UInt32(cmdKey | optionKey))
 
+        // The target does not wait for the microphone: the menu shows it
+        // either way.
+        Task { @MainActor in
+            Config.effectiveAgentID = await AgentClient.resolveAgent()
+            Log.info("agent: \(Config.effectiveAgentID.isEmpty ? "the daemon's default" : Config.effectiveAgentID)")
+        }
         recorder.requestPermission { [weak self] granted in
             Task { @MainActor in
                 guard let self else { return }
                 if !granted { self.panel.render(.error("Microphone denied")) }
-                else {
-                    Config.effectiveAgentID = await AgentClient.resolveAgent()
-                    Log.info("ready — hold ⌥Space to talk (agent: \(Config.effectiveAgentID.isEmpty ? "the daemon's default" : Config.effectiveAgentID))")
-                }
+                else { Log.info("ready — hold ⌥Space to talk") }
             }
         }
     }
@@ -264,6 +299,8 @@ final class App: NSObject, NSApplicationDelegate {
         // ignoring the key while busy is how Anis spoke to a lesson and
         // nothing listened.
         Speech.stop()
+        speaking?.cancel()
+        speaking = nil
         lastSpokeAt = Date()
         talkCheck = Task { await AgentClient.hush() }
         Log.info("door: opened\(busy ? " (a turn is running)" : "")")
@@ -282,6 +319,8 @@ final class App: NSObject, NSApplicationDelegate {
         let door = talkCheck ?? Task { await AgentClient.hush() }
         talkCheck = nil
         guard let wav = recorder.stop() else {
+            // Nothing said, so no door follows the hush: let the queue play on.
+            Task { _ = await door.value; await AgentClient.resume() }
             panel.render(.error("Too short — hold while speaking"))
             resetSoon()
             return
@@ -295,19 +334,23 @@ final class App: NSObject, NSApplicationDelegate {
             do { heard = try await Speech.transcribe(wav: wav) }
             catch { Log.warn("transcription failed: \(error.localizedDescription)") }
             guard !heard.isEmpty else {
+                _ = await door.value
+                await AgentClient.resume()
                 if !midTurn {
                     panel.render(.error("Didn't catch that"))
                     // Say it aloud: someone not looking would think it was sent.
-                    await Speech.speak("Sorry, I didn't hear that. Please say it again.", voice: voice)
+                    await Speech.say("Sorry, I didn't hear that. Please say it again.", agentID: nil, kind: "line", voice: voice)
                     busy = false; resetSoon()
                 }
                 return
             }
             Log.info("heard: \(heard)")
             let hushed = await door.value
-            if hushed.kind != nil, await AgentClient.door(heard) {
+            // Always through the door, even with nothing hushed: the
+            // listener's turn is over, so the daemon's queue plays on.
+            if await AgentClient.door(heard) {
                 // The talk or lesson answers out loud through the daemon.
-                Log.info("door: \"\(heard)\" → \(hushed.kind!)\(hushed.agentID.map { " (\($0))" } ?? "")")
+                Log.info("door: \"\(heard)\" → \(hushed.kind ?? "?")\(hushed.agentID.map { " (\($0))" } ?? "")")
                 if !midTurn { panel.render(.idle); busy = false }
                 return
             }
@@ -336,7 +379,7 @@ final class App: NSObject, NSApplicationDelegate {
         do {
             beginNarration()
 
-            let answer = try await AgentClient.ask(heard)
+            let answer = try await AgentClient.ask(heard, agent: Config.effectiveAgentID)
             endNarration()
             if abandoned {
                 abandoned = false
@@ -367,7 +410,11 @@ final class App: NSObject, NSApplicationDelegate {
             // Scroll the sentence being spoken, so it can be read as
             // well as heard — and re-read after, which speech cannot do.
             panel.render(.saying(answer.text))
-            await Speech.speak(answer.text, voice: voice)
+            // Queued on the daemon behind whatever is already speaking.
+            let line = Task { await Speech.say(answer.text, agentID: answer.agentID, kind: "answer", voice: voice) }
+            speaking = line
+            await line.value
+            if speaking == line { speaking = nil }
             // Cut off by the door: the new words are being recorded.
             if recorder.isRecording { busy = false; return }
             // Stopped: no follow-up window, the listener asked for quiet.
@@ -390,7 +437,7 @@ final class App: NSObject, NSApplicationDelegate {
             panel.render(.error(short(error.localizedDescription)))
             // Say it aloud too — a voice assistant that fails only in
             // a 230px label has failed silently for anyone not looking.
-            await Speech.speak("Sorry, that didn't work.", voice: voice)
+            await Speech.say("Sorry, that didn't work.", agentID: nil, kind: "line", voice: voice)
             resetSoon()
         }
         busy = false
@@ -465,7 +512,7 @@ final class App: NSObject, NSApplicationDelegate {
                 tool: tool, detail: detail, elapsed: Int(elapsed)) else { return }
             guard !self.spokenSteps.contains(phrase) else { return }
             self.spokenSteps.insert(phrase)
-            await Speech.speak(phrase.prefix(1).capitalized + phrase.dropFirst() + ".", voice: self.voice)
+            await Speech.say(phrase.prefix(1).capitalized + phrase.dropFirst() + ".", agentID: nil, kind: "narration", voice: self.voice)
         }
     }