agentix-cli 0.65.0 → 0.66.0

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

@@ -142,14 +142,35 @@ enum AgentClient {
         return try? JSONDecoder().decode(QueueState.self, from: data)
     }
 
-    /// The agent the words are addressed to ("Writer, …"), or `target`.
-    /// The daemon matches names, so the widget and config never disagree.
-    /// Never throws: no daemon means nobody else to address.
-    static func address(_ text: String, target: String) async -> String {
-        guard let (data, _) = try? await post("/voice/address", ["text": text, "target": target], timeout: 2) else { return target }
-        struct Reply: Decodable { let agentId: String? }
-        let id = (try? JSONDecoder().decode(Reply.self, from: data))?.agentId ?? ""
-        return id.isEmpty ? target : id
+    /// Who the words are for, from POST /voice/address: an agent on this
+    /// node or on a mesh peer, with how to show it. Older daemons send
+    /// only `agentId`.
+    struct Addressed: Decodable {
+        let agentID: String
+        let name: String?
+        /// "#RRGGBB"; without it the app derives the same one from the id.
+        let color: String?
+        let palette: AgentInfo.Palette?
+        /// The node it lives on: this node's id, or the peer's name.
+        let node: String?
+        /// On a mesh peer; /ask reaches it by the same id.
+        let remote: Bool?
+
+        enum CodingKeys: String, CodingKey { case agentID = "agentId", name, color, palette, node, remote }
+
+        var isRemote: Bool { remote ?? false }
+    }
+
+    /// The agent the words are addressed to ("Writer, …", or "Planner, …"
+    /// on another node), or `target`. The daemon matches names, so the
+    /// widget and config never disagree. Never throws: no daemon means
+    /// nobody else to address.
+    static func address(_ text: String, target: String) async -> Addressed {
+        let fallback = Addressed(agentID: target, name: nil, color: nil, palette: nil, node: nil, remote: nil)
+        guard let (data, _) = try? await post("/voice/address", ["text": text, "target": target], timeout: 2),
+              let reply = try? JSONDecoder().decode(Addressed.self, from: data),
+              !reply.agentID.isEmpty else { return fallback }
+        return reply
     }
 
     private static func post(_ path: String, _ body: [String: Any], timeout: TimeInterval) async throws -> (Data, URLResponse) {

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

@@ -0,0 +1,219 @@
+import AppKit
+import SwiftUI
+
+/// The row of mini orbs in the pill: one per busy agent (PillBusy.swift).
+///
+/// Each is a small glassy dot in the agent's colours with a cue for its
+/// state: a ring going round while it thinks, a steady ring while its
+/// answer waits to be spoken, a gentle pulse while it speaks, and a count
+/// when more questions wait for it. It moves only while shown on screen
+/// with something busy; Reduce Motion or "Animated orb" off gives still
+/// orbs. Clicks go through to the pill, it never takes the keyboard, and
+/// hovering an orb names the agent and its node.
+@MainActor
+final class MiniOrbsModel: ObservableObject {
+    struct Orb: Identifiable, Equatable {
+        var id: String { agentID }
+        let agentID: String
+        let activity: PillBusy.Activity
+        let queued: Int
+        let tint: NSColor
+        /// Five stops deep to light, or nil for shades of `tint`.
+        let colors: [NSColor]?
+        let tooltip: String
+    }
+
+    @Published var orbs: [Orb] = []
+    @Published var more = 0
+    @Published var onScreen = false
+    @Published var reduceMotion = NSWorkspace.shared.accessibilityDisplayShouldReduceMotion
+    @Published var animated = true
+
+    var still: Bool { reduceMotion || !animated }
+    /// Only thinking and speaking move; the timeline stops otherwise.
+    var paused: Bool {
+        still || !onScreen || !orbs.contains { $0.activity == .thinking || $0.activity == .speaking }
+    }
+}
+
+struct MiniOrbsView: View {
+    @ObservedObject var model: MiniOrbsModel
+
+    var body: some View {
+        let paused = model.paused
+        TimelineView(.animation(minimumInterval: 1.0 / 24, paused: paused)) { context in
+            let t = paused ? 0 : context.date.timeIntervalSinceReferenceDate
+            HStack(spacing: PillBusy.gap) {
+                ForEach(model.orbs) { orb in
+                    MiniOrb(orb: orb, t: t, still: model.still)
+                        .frame(width: PillBusy.diameter, height: PillBusy.diameter)
+                }
+                if model.more > 0 {
+                    Text("+\(model.more)")
+                        .font(.system(size: 10, weight: .semibold).monospacedDigit())
+                        .foregroundStyle(.secondary)
+                        .frame(width: PillBusy.overflowWidth, alignment: .leading)
+                }
+            }
+            .padding(.trailing, MiniOrbsHost.inset)
+            .frame(maxWidth: .infinity, maxHeight: .infinity, alignment: .trailing)
+        }
+        .accessibilityElement(children: .ignore)
+        .accessibilityLabel(Text(model.orbs.map(\.tooltip).joined(separator: "; ")))
+    }
+}
+
+/// One mini orb at time `t`.
+struct MiniOrb: View {
+    let orb: MiniOrbsModel.Orb
+    let t: Double
+    let still: Bool
+
+    var body: some View {
+        let pulse = orb.activity == .speaking && !still ? 0.9 + 0.1 * OrbMath.speakingEnvelope(at: t) : 1
+        ZStack {
+            Circle()
+                .fill(RadialGradient(colors: [light, deep], center: UnitPoint(x: 0.38, y: 0.32),
+                                     startRadius: 0, endRadius: PillBusy.diameter * 0.62))
+                .overlay(Circle().fill(RadialGradient(colors: [.white.opacity(0.5), .white.opacity(0)],
+                                                      center: UnitPoint(x: 0.34, y: 0.26),
+                                                      startRadius: 0, endRadius: 5)))
+                .overlay(Circle().strokeBorder(Color.white.opacity(0.35), lineWidth: 0.5))
+                .scaleEffect(orb.activity == .queued ? 0.72 : 0.78 * pulse)
+                .opacity(orb.activity == .queued ? 0.7 : 1)
+            cue
+            if orb.queued > 0 {
+                Text("\(min(orb.queued, 9))")
+                    .font(.system(size: 7.5, weight: .bold).monospacedDigit())
+                    .foregroundStyle(.white)
+                    .frame(width: 9, height: 9)
+                    .background(Circle().fill(Color(nsColor: deepest)))
+                    .overlay(Circle().strokeBorder(Color.white.opacity(0.8), lineWidth: 0.6))
+                    .offset(x: 5, y: -6)
+            }
+        }
+    }
+
+    /// The state cue drawn around the dot.
+    @ViewBuilder private var cue: some View {
+        switch orb.activity {
+        case .thinking:
+            Circle()
+                .trim(from: 0, to: 0.3)
+                .stroke(Color(nsColor: ring), style: StrokeStyle(lineWidth: 1.6, lineCap: .round))
+                .rotationEffect(.radians(still ? -.pi / 2 : t * 3.4))
+        case .answering:
+            Circle().stroke(Color(nsColor: ring).opacity(0.85), lineWidth: 1.2)
+        case .speaking:
+            Circle().stroke(Color(nsColor: ring).opacity(0.5), lineWidth: 1)
+                .scaleEffect(still ? 1 : 0.94 + 0.06 * OrbMath.speakingEnvelope(at: t + 0.4))
+        case .queued:
+            EmptyView()
+        }
+    }
+
+    private var light: Color {
+        if let c = orb.colors, c.count == 5 { return Color(nsColor: c[3]) }
+        return Color(nsColor: orb.tint.blended(withFraction: 0.35, of: .white) ?? orb.tint)
+    }
+    private var deep: Color {
+        if let c = orb.colors, c.count == 5 { return Color(nsColor: c[1]) }
+        return Color(nsColor: orb.tint)
+    }
+    private var deepest: NSColor {
+        if let c = orb.colors, c.count == 5 { return c[0] }
+        return orb.tint.blended(withFraction: 0.3, of: .black) ?? orb.tint
+    }
+    /// The ring reads on the pill in both themes: the agent's mid colour.
+    private var ring: NSColor {
+        if let c = orb.colors, c.count == 5 { return c[2] }
+        return orb.tint
+    }
+}
+
+/// The row's view in the pill. Clicks go through it, as through the main
+/// orb; hovering still shows each orb's name (tooltips are tracking
+/// rects, not clicks). It never takes the keyboard.
+@MainActor
+final class MiniOrbsHost: NSHostingView<MiniOrbsView> {
+    let model: MiniOrbsModel
+    private var motionObserver: NSObjectProtocol?
+    private var tips: [NSView.ToolTipTag] = []
+
+    init() {
+        let model = MiniOrbsModel()
+        self.model = model
+        super.init(rootView: MiniOrbsView(model: model))
+        motionObserver = NSWorkspace.shared.notificationCenter.addObserver(
+            forName: NSWorkspace.accessibilityDisplayOptionsDidChangeNotification,
+            object: nil, queue: .main) { [weak model] _ in
+            MainActor.assumeIsolated {
+                model?.reduceMotion = NSWorkspace.shared.accessibilityDisplayShouldReduceMotion
+            }
+        }
+    }
+
+    @available(*, unavailable)
+    required init(rootView: MiniOrbsView) { fatalError("use init()") }
+
+    @available(*, unavailable)
+    required init?(coder: NSCoder) { fatalError("not from a nib") }
+
+    /// Room right of the last orb for its queued badge.
+    static let inset: CGFloat = 3
+    /// The host's width for `count` busy agents.
+    static func width(_ count: Int) -> CGFloat { PillBusy.rowWidth(count) + inset * 2 }
+
+    override func hitTest(_ point: NSPoint) -> NSView? { nil }
+    override var acceptsFirstResponder: Bool { false }
+
+    /// Show these orbs, the "+n" for the rest. Cheap on every call:
+    /// SwiftUI redraws only what changed.
+    func show(_ orbs: [MiniOrbsModel.Orb], more: Int) {
+        if model.orbs != orbs { model.orbs = orbs }
+        if model.more != more { model.more = more }
+        placeTooltips()
+    }
+
+    func setOnScreen(_ on: Bool) {
+        if model.onScreen != on { model.onScreen = on }
+    }
+
+    func setAnimated(_ on: Bool) {
+        if model.animated != on { model.animated = on }
+    }
+
+    override func setFrameSize(_ newSize: NSSize) {
+        super.setFrameSize(newSize)
+        placeTooltips()
+    }
+
+    /// One tooltip rectangle per orb. SwiftUI's `.help` needs the view to
+    /// be hit, and this one lets clicks through, so AppKit's own tooltip
+    /// rectangles carry the names instead.
+    private func placeTooltips() {
+        tips.forEach(removeToolTip)
+        tips = []
+        tipRects = []
+        let count = model.orbs.count + model.more
+        let offsets = PillBusy.orbOffsets(count)
+        let width = PillBusy.rowWidth(count)
+        // The row is drawn against the right edge.
+        let left = bounds.width - Self.inset - width
+        let d = PillBusy.diameter
+        for (i, orb) in model.orbs.enumerated() where i < offsets.count {
+            let rect = NSRect(x: left + offsets[i], y: (bounds.height - d) / 2, width: d, height: d)
+            tips.append(addToolTip(rect, owner: self, userData: nil))
+            tipRects.append((rect, orb.tooltip))
+        }
+    }
+
+    private var tipRects: [(NSRect, String)] = []
+}
+
+extension MiniOrbsHost: NSViewToolTipOwner {
+    nonisolated func view(_ view: NSView, stringForToolTip tag: NSView.ToolTipTag,
+                          point: NSPoint, userData data: UnsafeMutableRawPointer?) -> String {
+        MainActor.assumeIsolated { tipRects.first { $0.0.contains(point) }?.1 ?? "" }
+    }
+}

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

@@ -21,6 +21,10 @@ final class Panel: NSPanel {
 
     private let label = NSTextField(labelWithString: "")
     let orb = PillOrb(diameter: Panel.orbDiameter, frameSize: Panel.orbFrame)
+    /// One small orb per busy agent while more than one is (MiniOrbs.swift).
+    let miniOrbs = MiniOrbsHost()
+    /// Busy agents shown in the mini row; 0 hides it.
+    private(set) var busyCount = 0
     private let closeButton = NSButton()
     /// The orb, the words and the close button: the pill itself, which
     /// stays where it is while the widget grows into an answer.
@@ -241,6 +245,8 @@ final class Panel: NSPanel {
         closeButton.action = #selector(closeClicked)
         closeButton.isHidden = true
         row.addSubview(closeButton)
+        miniOrbs.isHidden = true
+        row.addSubview(miniOrbs)
         surface.layoutContent = { [weak self] bounds in self?.layoutContent(bounds) }
         MainActor.assumeIsolated { layoutContent(surface.bounds) }
         surface.addTrackingArea(NSTrackingArea(rect: .zero,
@@ -269,7 +275,11 @@ final class Panel: NSPanel {
         let above = growth.above
         row.frame = NSRect(x: 0, y: above ? 0 : answerHeight, width: bounds.width, height: h)
         closeButton.frame.origin.x = bounds.width - 28
-        let clipWidth = bounds.width - 88
+        // The mini orbs sit between the words and the close button, and
+        // the words give up that room while they show.
+        let miniWidth = busyCount > 0 ? MiniOrbsHost.width(busyCount) : 0
+        miniOrbs.frame = NSRect(x: bounds.width - 28 - miniWidth, y: (h - 24) / 2, width: miniWidth, height: 24)
+        let clipWidth = bounds.width - 88 - (miniWidth > 0 ? miniWidth + 4 : 0)
         if let clip, clip.frame.width != clipWidth {
             clip.frame.size.width = clipWidth
             // Text that scrolled may fit now, and the other way round.
@@ -340,6 +350,7 @@ final class Panel: NSPanel {
     @MainActor
     func show() {
         orb.setOnScreen(true)
+        miniOrbs.setOnScreen(!miniOrbs.isHidden)
         if !isVisible { orderFrontRegardless() }
     }
 
@@ -347,6 +358,7 @@ final class Panel: NSPanel {
     private func hide() {
         closeButton.isHidden = true
         orb.setOnScreen(false)
+        miniOrbs.setOnScreen(false)
         if isVisible { orderOut(nil) }
     }
 
@@ -414,12 +426,29 @@ final class Panel: NSPanel {
             setText(named(state))
         }
 
-        // Grown into an answer, it stays until it collapses, idle or not.
-        if dismissed || (state.isMeta && !alwaysVisible && !expanded) { hide() } else { show() }
+        // Grown into an answer, it stays until it collapses, idle or not;
+        // so does a pill with agents still busy in its mini orbs.
+        if dismissed || (state.isMeta && !alwaysVisible && !expanded && busyCount == 0) { hide() } else { show() }
         armCollapse()
         onRender?(state)
     }
 
+    /// The mini orbs: one per busy agent, or none to hide the row. The
+    /// pill stays on screen while the row shows, even when idle.
+    @MainActor
+    func showBusy(_ orbs: [MiniOrbsModel.Orb], more: Int) {
+        let count = orbs.isEmpty ? 0 : orbs.count + more
+        miniOrbs.show(orbs, more: more)
+        miniOrbs.isHidden = count == 0
+        if count != busyCount {
+            busyCount = count
+            if let content = contentView { layoutContent(content.bounds) }
+            render(current)
+        } else {
+            miniOrbs.setOnScreen(isVisible && count > 0)
+        }
+    }
+
     /// "Nadia · Listening": who is listening or answering. Errors are the
     /// widget's own, so they carry no name.
     @MainActor

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

@@ -0,0 +1,126 @@
+import CoreGraphics
+import Foundation
+
+/// Who is busy right now, for the row of mini orbs in the pill (#266).
+///
+/// Asking two agents back to back used to look like one: the pill has one
+/// orb for one agent. While more than one agent is busy, a small orb per
+/// agent sits in the pill beside the words, in its colour, with a cue for
+/// what it is doing. The main orb keeps following whoever is listening or
+/// speaking.
+///
+/// Kept free of AppKit and SwiftUI so the tests can check it without a
+/// window.
+enum PillBusy {
+    /// What one agent is doing, most visible first.
+    enum Activity: Equatable {
+        /// Its answer is being spoken now.
+        case speaking
+        /// Its answer is back and waits in the speaking queue.
+        case answering
+        /// A question to it is in flight.
+        case thinking
+        /// Only questions waiting for it: nothing asked yet.
+        case queued
+
+        var word: String {
+            switch self {
+            case .speaking: return "speaking"
+            case .answering: return "answer waiting to be spoken"
+            case .thinking: return "thinking"
+            case .queued: return "queued"
+            }
+        }
+    }
+
+    struct Item: Equatable {
+        let agentID: String
+        let activity: Activity
+        /// Questions waiting for it behind the one in flight.
+        let queued: Int
+    }
+
+    /// What the app knows about each agent's work.
+    struct Snapshot {
+        /// Questions this widget has in flight, per agent.
+        var inFlight: [String: Int] = [:]
+        /// Questions waiting for an agent that already has one in flight.
+        var waiting: [String: Int] = [:]
+        /// The agent the daemon is speaking for now.
+        var playing: String?
+        /// Agents with answers waiting in the daemon's speaking queue.
+        var toSpeak: [String] = []
+    }
+
+    /// One item per busy agent. Agents already in `order` keep their
+    /// place, so an orb never jumps when another's state changes; new
+    /// ones join at the end.
+    static func items(_ s: Snapshot, order: [String]) -> [Item] {
+        var ids = Set(s.inFlight.filter { $0.value > 0 }.keys)
+        ids.formUnion(s.waiting.filter { $0.value > 0 }.keys)
+        if let p = s.playing, !p.isEmpty { ids.insert(p) }
+        ids.formUnion(s.toSpeak.filter { !$0.isEmpty })
+
+        let kept = order.filter(ids.contains)
+        let fresh = ids.subtracting(kept).sorted()
+        return (kept + fresh).map { id in
+            let activity: Activity
+            if s.playing == id { activity = .speaking }
+            else if s.toSpeak.contains(id) { activity = .answering }
+            else if s.inFlight[id, default: 0] > 0 { activity = .thinking }
+            else { activity = .queued }
+            // In flight beyond the first also waits (a turn plus an aside).
+            let extra = max(0, s.inFlight[id, default: 0] - 1)
+            return Item(agentID: id, activity: activity, queued: s.waiting[id, default: 0] + extra)
+        }
+    }
+
+    /// The row shows when more than one agent is busy, or when the one
+    /// busy agent still has a question out that the main orb is not
+    /// showing: the pill listens for the next while it thinks. One line
+    /// being spoken on its own is the main orb's, or a notification's.
+    static func showsRow(_ items: [Item], mainAgent: String, mainActive: Bool) -> Bool {
+        if items.count >= 2 { return true }
+        guard let only = items.first, only.activity == .thinking || only.activity == .queued else { return false }
+        return !mainActive || only.agentID != mainAgent
+    }
+
+    // MARK: Layout
+
+    /// A mini orb's diameter, the gap between two, and the most shown
+    /// before a "+n" stands for the rest.
+    static let diameter: CGFloat = 15
+    static let gap: CGFloat = 6
+    static let maxShown = 4
+    /// Width of the "+n" after the last orb shown.
+    static let overflowWidth: CGFloat = 18
+
+    /// How many orbs are drawn for `count` busy agents, and how many more
+    /// the "+n" stands for.
+    static func shown(_ count: Int) -> (orbs: Int, more: Int) {
+        count <= maxShown ? (count, 0) : (maxShown - 1, count - (maxShown - 1))
+    }
+
+    /// The row's width for `count` busy agents; 0 for none.
+    static func rowWidth(_ count: Int) -> CGFloat {
+        let (orbs, more) = shown(count)
+        guard orbs > 0 else { return 0 }
+        let base = CGFloat(orbs) * diameter + CGFloat(orbs - 1) * gap
+        return more > 0 ? base + gap + overflowWidth : base
+    }
+
+    /// Left edge of each orb, from the row's left edge.
+    static func orbOffsets(_ count: Int) -> [CGFloat] {
+        (0..<shown(count).orbs).map { CGFloat($0) * (diameter + gap) }
+    }
+
+    /// The hover text: the agent's name, its node when it is not this
+    /// Mac's, and what it is doing.
+    static func tooltip(name: String, node: String?, item: Item) -> String {
+        var s = name
+        if let node, !node.isEmpty { s += " on \(node)" }
+        s += " · \(item.activity.word)"
+        if item.queued > 0 { s += ", \(item.queued) more queued" }
+        return s
+    }
+}

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

@@ -21,14 +21,20 @@ final class StatusMenu: NSObject, NSMenuDelegate {
     /// Reopen the menu once the retry's answer is in.
     private var reopenAfterRefresh = false
     /// The daemon's speaking queue, polled while anything is in flight.
-    private var queue: AgentClient.QueueState?
+    private(set) var queue: AgentClient.QueueState?
+    /// Agents on other mesh nodes this widget has asked or been told
+    /// about by /voice/address: /agents lists only this node's.
+    private var remote: [String: AgentClient.Addressed] = [:]
+    /// Told when the thinking counts or the speaking queue change, so the
+    /// pill's mini orbs follow.
+    var onActivity: (() -> Void)?
     private var queuePoll: Timer?
     /// The last three voice exchanges, for a quick replay.
     private let recent = RecentExchanges()
 
     /// Questions this widget has in flight, per agent. Set by the app.
     var thinking: [String: Int] = [:] {
-        didSet { rebuild(); watchQueue(force: true) }
+        didSet { rebuild(); watchQueue(force: true); onActivity?() }
     }
 
     /// Set by the app.
@@ -54,17 +60,32 @@ final class StatusMenu: NSObject, NSMenuDelegate {
         rebuild()
     }
 
+    /// What /voice/address said about an agent. Only agents on other
+    /// nodes are kept; this node's come from /agents.
+    func learn(_ agent: AgentClient.Addressed) {
+        guard agent.isRemote else { return }
+        remote[agent.agentID] = agent
+    }
+
+    private func local(_ id: String) -> AgentClient.AgentInfo? {
+        guard case .loaded(let agents) = roster else { return nil }
+        return agents.first { $0.id == id }
+    }
+
+    /// The node an agent on another node lives on; nil for this node's.
+    func node(of id: String) -> String? {
+        local(id) == nil ? remote[id]?.node : nil
+    }
+
     /// 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
+        local(id)?.label ?? remote[id]?.name ?? 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 configured = local(id)?.color ?? remote[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)
@@ -73,8 +94,7 @@ final class StatusMenu: NSObject, NSMenuDelegate {
     /// The agent's orb palette, five colours deep to light, or nil when
     /// the daemon sent none.
     func palette(of id: String) -> [NSColor]? {
-        guard case .loaded(let agents) = roster,
-              let hexes = agents.first(where: { $0.id == id })?.palette?.colors, hexes.count == 5 else { return nil }
+        guard let hexes = local(id)?.palette?.colors ?? remote[id]?.palette?.colors, hexes.count == 5 else { return nil }
         let colors = hexes.compactMap(OrbMath.parseHex).map { NSColor(srgbRed: $0.r, green: $0.g, blue: $0.b, alpha: 1) }
         return colors.count == 5 ? colors : nil
     }
@@ -131,6 +151,7 @@ final class StatusMenu: NSObject, NSMenuDelegate {
                 self.queue = await AgentClient.queueState()
                 self.rebuild()
                 self.showBadge()
+                self.onActivity?()
                 self.watchQueue()
             }
         }
@@ -138,16 +159,20 @@ final class StatusMenu: NSObject, NSMenuDelegate {
 
     /// "thinking", "speaking", "queued 2", or both, for one agent's row.
     private func state(of agent: AgentClient.AgentInfo) -> String {
+        state(of: agent.id, active: agent.active ?? 0)
+    }
+
+    private func state(of id: String, active: Int) -> String {
         var parts: [String] = []
         // Speaking one answer and thinking on the next are both true at once.
-        if queue?.playing?.agentId == agent.id { parts.append("speaking") }
-        let asked = thinking[agent.id, default: 0]
+        if queue?.playing?.agentId == id { parts.append("speaking") }
+        let asked = thinking[id, default: 0]
         if asked > 0 {
             // More than one: the rest wait for the answer in flight.
             parts.append(asked > 1 ? "thinking (+\(asked - 1) asked)" : "thinking")
         }
-        if parts.isEmpty && (agent.active ?? 0) > 0 { parts.append("working") }
-        let queued = queue?.waiting.filter { $0.agentId == agent.id }.count ?? 0
+        if parts.isEmpty && active > 0 { parts.append("working") }
+        let queued = queue?.waiting.filter { $0.agentId == id }.count ?? 0
         if queued > 0 { parts.append("queued \(queued)") }
         return parts.isEmpty ? "idle" : parts.joined(separator: " · ")
     }
@@ -186,6 +211,22 @@ final class StatusMenu: NSObject, NSMenuDelegate {
                 row.isEnabled = !pinned
                 menu.addItem(row)
             }
+            // Agents on other nodes, while asked, answering or the target:
+            // "Planner (server)  · thinking". /agents lists only this node's.
+            let localIDs = Set(agents.map(\.id))
+            var others = Set(thinking.keys)
+            if let p = queue?.playing?.agentId { others.insert(p) }
+            for item in queue?.waiting ?? [] { if let id = item.agentId { others.insert(id) } }
+            if !target.isEmpty { others.insert(target) }
+            for id in others.subtracting(localIDs).filter({ remote[$0] != nil || thinking[$0] != nil }).sorted() {
+                let node = remote[id]?.node ?? "mesh"
+                let row = action("\(name(of: id)) (\(node))  · " + state(of: id, active: 0), #selector(pick(_:)),
+                                 key: "", modifiers: [])
+                row.representedObject = id
+                row.state = id == target ? .on : .off
+                row.isEnabled = !pinned
+                menu.addItem(row)
+            }
         }
         recent.addItems(to: menu, name: name(of:))