agentix-cli 0.55.0 → 0.56.0

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

@@ -167,6 +167,9 @@ enum AgentClient {
         let name: String?
         /// Tasks running now.
         let active: Int?
+        /// "#RRGGBB": presence.color, else derived from the id. Older
+        /// daemons send none, and the app derives it the same way.
+        let color: String?
         var label: String { name ?? id }
     }
 

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

@@ -28,6 +28,13 @@ enum Config {
         set { UserDefaults.standard.set(newValue, forKey: "showPill") }
     }
 
+    /// The orb overlay while listening, thinking and speaking. On by
+    /// default; off brings back the pill for those states.
+    static var showOrb: Bool {
+        get { UserDefaults.standard.object(forKey: "showOrb") as? Bool ?? true }
+        set { UserDefaults.standard.set(newValue, forKey: "showOrb") }
+    }
+
     /// The agent actually answering: `agentID`, else `chosenAgentID`, else
     /// the daemon's default (AgentClient.resolveAgent). Progress follows it.
     @MainActor static var effectiveAgentID: String = ""

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

@@ -0,0 +1,311 @@
+import AppKit
+import SwiftUI
+
+/// The Siri-style overlay: an orb in the agent's colour that listens,
+/// thinks and speaks, with a line of words under it.
+///
+/// Built from SwiftUI's own gradients, no animation library. The orb only
+/// moves while it is on screen: hidden, its timeline is paused and the
+/// microphone level is no longer read, so an idle assistant costs nothing.
+/// With Reduce Motion on it is a still picture that changes between
+/// states, never a loop.
+@MainActor
+final class OrbModel: ObservableObject {
+    enum Phase: Equatable { case hidden, listening, thinking, speaking }
+
+    @Published var phase: Phase = .hidden
+    /// 0…1: the microphone while listening.
+    @Published var level: Double = 0
+    @Published var tint = NSColor(srgbRed: 0.078, green: 0.722, blue: 0.651, alpha: 1)
+    @Published var name = ""
+    /// What was heard, or what is being said.
+    @Published var line = ""
+    /// The step the agent is on, and for how long.
+    @Published var status = ""
+    @Published var reduceMotion = NSWorkspace.shared.accessibilityDisplayShouldReduceMotion
+}
+
+struct OrbView: View {
+    @ObservedObject var model: OrbModel
+    @Environment(\.colorScheme) private var scheme
+
+    /// The agent's colour, lifted in dark mode so the name stays readable.
+    private var nameColor: Color {
+        guard scheme == .dark, let c = model.tint.usingColorSpace(.sRGB) else { return Color(nsColor: model.tint) }
+        var h: CGFloat = 0, s: CGFloat = 0, b: CGFloat = 0, a: CGFloat = 0
+        c.getHue(&h, saturation: &s, brightness: &b, alpha: &a)
+        return Color(nsColor: NSColor(hue: h, saturation: s * 0.55, brightness: min(1, b + 0.35), alpha: 1))
+    }
+
+    var body: some View {
+        VStack(spacing: 8) {
+            orb.frame(width: 96, height: 96).padding(.top, 4)
+            if !model.name.isEmpty {
+                Text(model.name.uppercased())
+                    .font(.system(size: 10.5, weight: .semibold, design: .monospaced))
+                    .tracking(0.8)
+                    .foregroundStyle(nameColor)
+            }
+            if !model.line.isEmpty {
+                Text(model.line)
+                    .font(.system(size: 13, weight: .medium))
+                    .foregroundStyle(.primary)
+                    .multilineTextAlignment(.center)
+                    .lineLimit(3)
+                    .truncationMode(.head)
+                    .fixedSize(horizontal: false, vertical: true)
+            }
+            if !model.status.isEmpty {
+                Text(model.status)
+                    .font(.system(size: 11))
+                    .foregroundStyle(.secondary)
+                    .lineLimit(1)
+                    .truncationMode(.middle)
+            }
+        }
+        .padding(.horizontal, 18)
+        .padding(.vertical, 14)
+        .frame(width: OrbOverlay.width)
+        .background(.regularMaterial, in: RoundedRectangle(cornerRadius: 22, style: .continuous))
+        .overlay(RoundedRectangle(cornerRadius: 22, style: .continuous)
+            .strokeBorder(Color.primary.opacity(0.08), lineWidth: 1))
+        .frame(maxHeight: .infinity, alignment: .top)
+    }
+
+    private var orb: some View {
+        let still = model.reduceMotion
+        let paused = still || model.phase == .hidden
+        return TimelineView(.animation(minimumInterval: 1.0 / 30, paused: paused)) { context in
+            OrbBody(t: paused ? 0 : context.date.timeIntervalSinceReferenceDate,
+                    phase: model.phase, level: model.level, tint: model.tint, still: still)
+        }
+        .accessibilityLabel(Text(accessibilityText))
+    }
+
+    private var accessibilityText: String {
+        switch model.phase {
+        case .hidden: return ""
+        case .listening: return "Listening"
+        case .thinking: return "Thinking"
+        case .speaking: return "Speaking"
+        }
+    }
+}
+
+/// One frame of the orb at time `t`.
+struct OrbBody: View {
+    let t: Double
+    let phase: OrbModel.Phase
+    let level: Double
+    let tint: NSColor
+    /// Reduce Motion: a still orb, sized and shaded by state alone.
+    let still: Bool
+
+    /// How much the orb swells and glows, 0…1.
+    private var energy: Double {
+        switch phase {
+        case .hidden: return 0
+        case .listening: return still ? 0.45 : 0.12 + 0.88 * level
+        case .thinking: return still ? 0.2 : 0.22 + 0.08 * sin(t * 2.2)
+        case .speaking: return still ? 0.7 : OrbMath.speakingEnvelope(at: t)
+        }
+    }
+
+    /// How fast the colours drift.
+    private var speed: Double {
+        switch phase {
+        case .hidden: return 0
+        case .listening: return 0.5 + level * 1.5
+        case .thinking: return 1.3
+        case .speaking: return 0.9
+        }
+    }
+
+    var body: some View {
+        let scale = 0.78 + 0.22 * energy
+        ZStack {
+            Circle()
+                .fill(Color(nsColor: tint).opacity(0.28 + 0.32 * energy))
+                .blur(radius: 10 + 12 * energy)
+                .scaleEffect(scale * 1.08)
+            fill
+                .clipShape(Circle())
+                .scaleEffect(scale)
+            // Thinking reads as a slow ring going round; the other states
+            // as a soft rim.
+            if phase == .thinking {
+                Circle()
+                    .trim(from: 0, to: 0.28)
+                    .stroke(Color.white.opacity(0.75), style: StrokeStyle(lineWidth: 2.2, lineCap: .round))
+                    .rotationEffect(.radians(still ? -.pi / 2 : t * 3.1))
+                    .scaleEffect(scale * 0.86)
+            } else {
+                Circle()
+                    .strokeBorder(Color.white.opacity(0.3 + 0.25 * energy), lineWidth: 1)
+                    .scaleEffect(scale)
+            }
+        }
+    }
+
+    @ViewBuilder private var fill: some View {
+        let shades = palette
+        if #available(macOS 15, *) {
+            MeshGradient(width: 3, height: 3, points: meshPoints, colors: [
+                shades[0], shades[1], shades[2],
+                shades[3], shades[4], shades[1],
+                shades[2], shades[3], shades[0],
+            ])
+        } else {
+            // macOS 14: two gradients stand in for the mesh.
+            ZStack {
+                AngularGradient(colors: [shades[0], shades[2], shades[3], shades[1], shades[0]],
+                                center: .center, angle: .radians(t * speed))
+                RadialGradient(colors: [shades[4], shades[4].opacity(0)],
+                               center: UnitPoint(x: 0.5 + 0.12 * cos(t * speed), y: 0.5 + 0.12 * sin(t * speed)),
+                               startRadius: 2, endRadius: 44)
+            }
+        }
+    }
+
+    /// Corners fixed, edges sway, the centre wanders further when there
+    /// is more energy. `still` keeps the resting grid.
+    private var meshPoints: [SIMD2<Float>] {
+        let s = still ? 0 : t * speed
+        let reach = Float(0.08 + 0.14 * energy)
+        func sway(_ phase: Double) -> Float { Float(sin(s + phase)) * reach * 0.6 }
+        return [
+            [0, 0], [0.5 + sway(0.3), 0], [1, 0],
+            [0, 0.5 + sway(1.1)],
+            [0.5 + Float(cos(s * 1.3)) * reach, 0.5 + Float(sin(s * 1.7)) * reach],
+            [1, 0.5 + sway(2.3)],
+            [0, 1], [0.5 + sway(3.7), 1], [1, 1],
+        ]
+    }
+
+    /// Five shades around the agent's colour: lighter, deeper and two
+    /// neighbouring hues, and a bright core that grows with the voice.
+    private var palette: [Color] {
+        let base = tint.usingColorSpace(.sRGB) ?? tint
+        var h: CGFloat = 0, s: CGFloat = 0, b: CGFloat = 0, a: CGFloat = 0
+        base.getHue(&h, saturation: &s, brightness: &b, alpha: &a)
+        // Thinking turns the hues slowly; the others hold them.
+        let drift = phase == .thinking && !still ? CGFloat(sin(t * 0.8)) * 0.04 : 0
+        func shade(_ dh: CGFloat, _ ds: CGFloat, _ db: CGFloat) -> Color {
+            var hue = (h + dh + drift).truncatingRemainder(dividingBy: 1)
+            if hue < 0 { hue += 1 }
+            return Color(nsColor: NSColor(hue: hue, saturation: min(1, max(0, s + ds)),
+                                          brightness: min(1, max(0, b + db)), alpha: 1))
+        }
+        let core = CGFloat(0.12 + 0.3 * energy)
+        return [
+            shade(0, 0, 0),
+            shade(0.07, -0.05, 0.08),
+            shade(-0.06, 0.05, -0.12),
+            shade(0.13, -0.1, 0.02),
+            shade(0.02, -0.35 * core * 2, core),
+        ]
+    }
+}
+
+/// The window the orb lives in: floating, on every Space, click-through
+/// and never key, so the app in front keeps the keyboard.
+private final class OrbPanel: NSPanel {
+    override var canBecomeKey: Bool { false }
+    override var canBecomeMain: Bool { false }
+}
+
+@MainActor
+final class OrbOverlay {
+    static let width: CGFloat = 300
+    private static let height: CGFloat = 250
+
+    let model = OrbModel()
+    private let panel: NSPanel
+    private let host: NSHostingView<OrbView>
+    private var levelTimer: Timer?
+    private var motionObserver: NSObjectProtocol?
+
+    /// The microphone's RMS level, read while listening. Set by the app.
+    var levelSource: (() -> Float)?
+
+    init() {
+        panel = OrbPanel(contentRect: NSRect(x: 0, y: 0, width: Self.width, height: Self.height),
+                         styleMask: [.borderless, .nonactivatingPanel],
+                         backing: .buffered, defer: true)
+        panel.isFloatingPanel = true
+        panel.level = .floating
+        panel.collectionBehavior = [.canJoinAllSpaces, .fullScreenAuxiliary, .stationary, .ignoresCycle]
+        panel.isOpaque = false
+        panel.backgroundColor = .clear
+        panel.hasShadow = false
+        panel.ignoresMouseEvents = true
+        panel.hidesOnDeactivate = false
+        host = NSHostingView(rootView: OrbView(model: model))
+        host.frame = NSRect(x: 0, y: 0, width: Self.width, height: Self.height)
+        panel.contentView = host
+
+        let model = self.model
+        motionObserver = NSWorkspace.shared.notificationCenter.addObserver(
+            forName: NSWorkspace.accessibilityDisplayOptionsDidChangeNotification,
+            object: nil, queue: .main) { _ in
+            MainActor.assumeIsolated {
+                model.reduceMotion = NSWorkspace.shared.accessibilityDisplayShouldReduceMotion
+            }
+        }
+    }
+
+    var isVisible: Bool { panel.isVisible }
+
+    /// Where the orb's card ends on screen, for the answer card to sit
+    /// under. Nil while hidden.
+    var contentFrame: NSRect? {
+        guard panel.isVisible else { return nil }
+        let h = min(Self.height, host.fittingSize.height)
+        return NSRect(x: panel.frame.minX, y: panel.frame.maxY - h, width: Self.width, height: h)
+    }
+
+    func show(_ phase: OrbModel.Phase, name: String, tint: NSColor, line: String, status: String) {
+        guard phase != .hidden else { hide(); return }
+        model.name = name
+        model.tint = tint
+        model.line = line
+        model.status = status
+        if model.phase != phase {
+            model.phase = phase
+            if phase != .listening { model.level = 0 }
+        }
+        watchLevel()
+        if !panel.isVisible {
+            position()
+            panel.orderFrontRegardless()
+        }
+    }
+
+    func hide() {
+        model.phase = .hidden
+        model.level = 0
+        watchLevel()
+        panel.orderOut(nil)
+    }
+
+    /// Top right, under the menu bar, where macOS puts Siri.
+    private func position() {
+        guard let screen = NSScreen.main else { return }
+        let v = screen.visibleFrame
+        panel.setFrameOrigin(NSPoint(x: v.maxX - Self.width - 16, y: v.maxY - Self.height - 10))
+    }
+
+    /// The microphone is read only while listening, on screen, with
+    /// motion allowed.
+    private func watchLevel() {
+        let wanted = model.phase == .listening && !model.reduceMotion && levelSource != nil
+        if !wanted { levelTimer?.invalidate(); levelTimer = nil; return }
+        guard levelTimer == nil else { return }
+        levelTimer = Timer.scheduledTimer(withTimeInterval: 1.0 / 20, repeats: true) { [weak self] _ in
+            MainActor.assumeIsolated {
+                guard let self, let read = self.levelSource else { return }
+                self.model.level = OrbMath.smooth(self.model.level, toward: OrbMath.level(fromRMS: read()))
+            }
+        }
+    }
+}

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

@@ -0,0 +1,57 @@
+import Foundation
+
+/// The numbers behind the orb, kept free of AppKit and SwiftUI so the
+/// tests can check them without a window.
+enum OrbMath {
+    /// The palette the daemon derives an agent's colour from when
+    /// `presence.color` is unset. Same list, same order and same hash as
+    /// `presenceLook` in src/voice/presence.ts, so the orb matches the
+    /// agent's on-screen cursor even when /agents sends no colour.
+    static let palette = ["#7C3AED", "#DB2777", "#EA580C", "#0D9488",
+                          "#2563EB", "#65A30D", "#C026D3", "#0891B2"]
+
+    /// The colour for an agent: the daemon's when it sent one, else the
+    /// hash of the id.
+    static func colorHex(agentID: String, configured: String?) -> String {
+        if let c = configured, parseHex(c) != nil { return c }
+        var h: UInt32 = 0
+        // JS iterates code points and takes charCodeAt(0) of each: the
+        // first UTF-16 unit. Identical for every ASCII id.
+        for scalar in agentID.unicodeScalars {
+            let unit = UInt32(String(scalar).utf16.first ?? 0)
+            h = h &* 31 &+ unit
+        }
+        return palette[Int(h % UInt32(palette.count))]
+    }
+
+    /// "#RRGGBB" as 0…1 components, or nil when it is not that.
+    static func parseHex(_ s: String) -> (r: Double, g: Double, b: Double)? {
+        guard s.count == 7, s.hasPrefix("#"), let v = UInt32(s.dropFirst(), radix: 16) else { return nil }
+        return (Double((v >> 16) & 0xFF) / 255, Double((v >> 8) & 0xFF) / 255, Double(v & 0xFF) / 255)
+    }
+
+    /// Microphone RMS (about 0.005 in a quiet room, 0.02 for a voice,
+    /// 0.2 when shouting) to 0…1. Square root, because loudness is heard
+    /// roughly that way: linear made normal speech barely move the orb.
+    static func level(fromRMS rms: Float) -> Double {
+        guard rms.isFinite, rms > 0.004 else { return 0 }
+        return min(1, Double((rms - 0.004).squareRoot()) * 3.2)
+    }
+
+    /// A speech-like rise and fall at time `t`, 0.15…1: syllables at about
+    /// five a second under a slower phrase swell. The daemon plays the
+    /// answer, so the app cannot meter it; this keeps the orb talking in
+    /// rhythm without pretending to be a level meter.
+    static func speakingEnvelope(at t: Double) -> Double {
+        let syllable = abs(sin(t * 15.7))
+        let phrase = 0.55 + 0.45 * sin(t * 1.9 + 0.7)
+        let jitter = 0.5 + 0.5 * sin(t * 37.3 + sin(t * 3.1))
+        return 0.15 + 0.85 * syllable * phrase * (0.7 + 0.3 * jitter)
+    }
+
+    /// Smooth toward `target`: fast attack, slower release, as the
+    /// recorder does, so the orb swells with a word and settles after it.
+    static func smooth(_ current: Double, toward target: Double) -> Double {
+        target > current ? current + (target - current) * 0.6 : current + (target - current) * 0.2
+    }
+}

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

@@ -51,6 +51,10 @@ final class Panel: NSPanel {
     /// Stay on screen when idle. Off: the pill shows only while active.
     var alwaysVisible = false
 
+    /// The orb overlay shows listening, thinking and speaking, so the
+    /// pill stays out of the way then; it still shows idle and errors.
+    var yieldsActiveStates = false
+
     /// Told of every state rendered, so the menu-bar icon can follow.
     var onRender: ((State) -> Void)?
 
@@ -107,6 +111,14 @@ final class Panel: NSPanel {
         /// Idle is an invitation and belongs in meta type; everything else
         /// is a running commentary and belongs in body type.
         var isMeta: Bool { if case .idle = self { return true }; return false }
+
+        /// Listening, thinking or speaking: what the orb shows.
+        var isActive: Bool {
+            switch self {
+            case .idle, .error: return false
+            default: return true
+            }
+        }
     }
 
     /// Called when the pill is clicked. Set by the app.
@@ -208,7 +220,8 @@ final class Panel: NSPanel {
             setText(named(state))
         }
 
-        if state.isMeta && !alwaysVisible { orderOut(nil) } else { orderFrontRegardless() }
+        let yield = yieldsActiveStates && state.isActive
+        if (state.isMeta && !alwaysVisible) || yield { orderOut(nil) } else { orderFrontRegardless() }
         onRender?(state)
     }
 

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

@@ -22,6 +22,10 @@ final class ResultCard: NSPanel {
     private let links = NSStackView()
     private let thumb = NSImageView()
 
+    /// The orb's frame on screen while it shows, for the card to slide in
+    /// under it. Nil: the card sits above the pill. Set by the app.
+    var anchor: (() -> NSRect?)?
+
     init() {
         super.init(contentRect: NSRect(x: 0, y: 0, width: 380, height: 260),
                    styleMask: [.titled, .closable, .resizable, .utilityWindow, .nonactivatingPanel],
@@ -125,8 +129,35 @@ final class ResultCard: NSPanel {
         }
 
         if let c = contentView { layout(c) }
-        positionAboveWidget()
+        if let orb = anchor?() {
+            slideIn(under: orb)
+        } else {
+            positionAboveWidget()
+            orderFrontRegardless()
+        }
+    }
+
+    /// Under the orb, right edges aligned, sliding down into place. With
+    /// Reduce Motion it simply appears there.
+    @MainActor
+    private func slideIn(under orb: NSRect) {
+        let target = NSPoint(x: orb.maxX - frame.width, y: orb.minY - frame.height - 8)
+        let wasVisible = isVisible
+        guard !wasVisible, !NSWorkspace.shared.accessibilityDisplayShouldReduceMotion else {
+            setFrameOrigin(target)
+            alphaValue = 1
+            orderFrontRegardless()
+            return
+        }
+        setFrameOrigin(NSPoint(x: target.x, y: target.y + 18))
+        alphaValue = 0
         orderFrontRegardless()
+        NSAnimationContext.runAnimationGroup { ctx in
+            ctx.duration = 0.28
+            ctx.timingFunction = Brand.ease
+            animator().setFrameOrigin(target)
+            animator().alphaValue = 1
+        }
     }
 
     @objc private func openLink(_ sender: NSButton) {
@@ -139,6 +170,7 @@ final class ResultCard: NSPanel {
         guard let screen = NSScreen.main else { return }
         let v = screen.visibleFrame
         setFrameOrigin(NSPoint(x: v.maxX - frame.width - 24, y: v.minY + 24 + 54 + 10))
+        alphaValue = 1
     }
 
     override var canBecomeKey: Bool { true }

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

@@ -34,6 +34,7 @@ final class StatusMenu: NSObject, NSMenuDelegate {
     var onHoldChanged: ((Bool) -> Void)?
     var onTargetChanged: ((String) -> Void)?
     var onPillChanged: ((Bool) -> Void)?
+    var onOrbChanged: ((Bool) -> Void)?
 
     override init() {
         super.init()
@@ -50,6 +51,16 @@ final class StatusMenu: NSObject, NSMenuDelegate {
         return agents.first { $0.id == id }?.label ?? id
     }
 
+    /// The agent's colour for the orb: what the daemon sent, else the
+    /// one derived from its id, which is the same colour.
+    func color(of id: String) -> NSColor {
+        var configured: String?
+        if case .loaded(let agents) = roster { configured = agents.first { $0.id == id }?.color }
+        let hex = OrbMath.colorHex(agentID: id, configured: configured)
+        guard let c = OrbMath.parseHex(hex) else { return Brand.accent }
+        return NSColor(srgbRed: c.r, green: c.g, blue: c.b, alpha: 1)
+    }
+
     /// Open the menu from the keyboard.
     func open() { item.button?.performClick(nil) }
 
@@ -166,6 +177,9 @@ final class StatusMenu: NSObject, NSMenuDelegate {
         let pill = action("Show floating pill", #selector(togglePill), key: "")
         pill.state = Config.showPill ? .on : .off
         menu.addItem(pill)
+        let orb = action("Show orb", #selector(toggleOrb), key: "")
+        orb.state = Config.showOrb ? .on : .off
+        menu.addItem(orb)
 
         menu.addItem(.separator())
         menu.addItem(action("Settings…", #selector(openSettings), key: ","))
@@ -215,6 +229,11 @@ final class StatusMenu: NSObject, NSMenuDelegate {
         onPillChanged?(Config.showPill)
     }
 
+    @objc private func toggleOrb() {
+        Config.showOrb.toggle()
+        onOrbChanged?(Config.showOrb)
+    }
+
     @objc private func openSettings() { openDashboard("/admin") }
     @objc private func openHistory() { openDashboard("/activity") }
 

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

@@ -19,6 +19,11 @@ final class App: NSObject, NSApplicationDelegate {
     private let panel = Panel()
     private let statusMenu = StatusMenu()
     private let card = ResultCard()
+    private let orb = OrbOverlay()
+    /// What the listener said this turn, shown under the orb.
+    private var heardLine = ""
+    /// The agent whose by-name answer is on screen now, while no turn runs.
+    private var asideSpeaker: String?
     private let recorder = Recorder()
     private var hotkey: Hotkey?
     private var pasteHotkey: Hotkey?
@@ -83,6 +88,37 @@ final class App: NSObject, NSApplicationDelegate {
         statusMenu.thinking = counts
     }
 
+    /// Who the panel and orb name: a by-name answer being spoken, else the
+    /// agent our turn is asking, else the target.
+    private var shownAgent: String {
+        if let asideSpeaker { return asideSpeaker }
+        return busy && !turnAgent.isEmpty ? turnAgent : Config.effectiveAgentID
+    }
+
+    /// The orb follows the pill's state: listening, thinking or speaking
+    /// show it; idle and errors hide it.
+    private func renderOrb(_ state: Panel.State) {
+        guard Config.showOrb else { orb.hide(); return }
+        let who = shownAgent
+        let name = who.isEmpty ? "" : statusMenu.name(of: who)
+        let tint = statusMenu.color(of: who)
+        switch state {
+        case .idle, .error:
+            orb.hide()
+        case .listening:
+            heardLine = ""
+            orb.show(.listening, name: name, tint: tint, line: "Listening…", status: "")
+        case .thinking:
+            orb.show(.thinking, name: name, tint: tint, line: heardLine, status: "Thinking…")
+        case .working(let step, let secs):
+            orb.show(.thinking, name: name, tint: tint, line: heardLine, status: "\(step) · \(secs)s")
+        case .speaking:
+            orb.show(.speaking, name: name, tint: tint, line: heardLine, status: "")
+        case .saying(let text):
+            orb.show(.speaking, name: name, tint: tint, line: text, status: "")
+        }
+    }
+
     /// ⌘⌥V. Everything except the hotkey lives in `agentx paste`.
     private func smartPaste() {
         guard !busy else { return }
@@ -129,15 +165,26 @@ final class App: NSObject, NSApplicationDelegate {
     func applicationDidFinishLaunching(_ note: Notification) {
         NSApp.setActivationPolicy(.accessory)
         retireOlderInstances()
-        panel.onRender = { [weak self] state in self?.statusMenu.show(state) }
+        panel.onRender = { [weak self] state in
+            self?.statusMenu.show(state)
+            self?.renderOrb(state)
+        }
         panel.contextMenu = { [weak self] in self?.statusMenu.menu ?? NSMenu() }
         panel.agentName = { [weak self] in
             guard let self else { return "" }
-            // A question sent by name shows who is answering it, not the target.
-            let who = self.busy && !self.turnAgent.isEmpty ? self.turnAgent : Config.effectiveAgentID
+            let who = self.shownAgent
             return who.isEmpty ? "" : self.statusMenu.name(of: who)
         }
         panel.alwaysVisible = Config.showPill
+        panel.yieldsActiveStates = Config.showOrb
+        orb.levelSource = { [weak self] in self?.recorder.level ?? 0 }
+        card.anchor = { [weak self] in self?.orb.contentFrame }
+        statusMenu.onOrbChanged = { [weak self] on in
+            guard let self else { return }
+            self.panel.yieldsActiveStates = on
+            if !on { self.orb.hide() }
+            if !self.busy && !self.recorder.isRecording { self.panel.render(.idle) }
+        }
         panel.render(.idle)
         statusMenu.onPillChanged = { [weak self] on in
             guard let self else { return }
@@ -259,6 +306,7 @@ final class App: NSObject, NSApplicationDelegate {
         openedAt = Date()
         patience = followUp ? followUpPatience : clickPatience
         silentClose = followUp
+        asideSpeaker = nil
         panel.render(.listening)
 
         listenPoll?.invalidate()
@@ -324,6 +372,7 @@ final class App: NSObject, NSApplicationDelegate {
         stopGeneration += 1
         waitingAsides.removeAll()
         publishThinking()
+        asideSpeaker = nil
         lastSpokeAt = Date()
         Task { await Speech.stopAll() }
         if !recorder.isRecording { panel.render(.idle) }
@@ -347,6 +396,7 @@ final class App: NSObject, NSApplicationDelegate {
         Log.info("door: opened\(busy ? " (a turn is running)" : "")")
         do {
             try recorder.start()
+            asideSpeaker = nil
             panel.render(.listening)
         } catch {
             panel.render(.error(error.localizedDescription))
@@ -386,6 +436,8 @@ final class App: NSObject, NSApplicationDelegate {
                 return
             }
             Log.info("heard: \(heard)")
+            heardLine = heard
+            if orb.isVisible { orb.model.line = heard }
             let hushed = await door.value
             // Always through the door, even with nothing hushed: the
             // listener's turn is over, so the daemon's queue plays on.
@@ -466,7 +518,15 @@ final class App: NSObject, NSApplicationDelegate {
                     card.show(spoken: answer.text, written: answer.written,
                               buttons: answer.buttons, imageURL: answer.imageURL)
                 }
+                // Nothing else on screen: the orb shows this answer, in
+                // this agent's colour, while it is spoken.
+                let onScreen = !busy && !recorder.isRecording
+                if onScreen { asideSpeaker = agent; panel.render(.saying(answer.text)) }
                 await Speech.say(answer.text, agentID: answer.agentID ?? agent, kind: "answer", voice: answer.voice)
+                if onScreen && asideSpeaker == agent {
+                    asideSpeaker = nil
+                    if !busy && !recorder.isRecording { panel.render(.idle) }
+                }
             case .failure(let error):
                 Log.warn("aside failed (\(agent)): \(error.localizedDescription)")
                 await Speech.say("Sorry, \(statusMenu.name(of: agent)) couldn't answer that.", agentID: nil, kind: "line", voice: nil)

package/apps/mac-voice/build.sh

@@ -18,7 +18,7 @@ rm -rf build && mkdir -p "$BIN" "$APP/Contents/Resources"
 swiftc -O \
   -o "$BIN/AgentXVoice" \
   Sources/AgentXVoice/*.swift \
-  -framework AppKit -framework AVFoundation -framework Carbon \
+  -framework AppKit -framework AVFoundation -framework Carbon -framework SwiftUI \
   -target arm64-apple-macosx14.0
 
 cp Resources/Info.plist "$APP/Contents/Info.plist"