agentix-cli 0.92.4 → 0.94.0

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

@@ -2,14 +2,14 @@ import AppKit
 
 /// The character (#458): the orb grown into a small creature, in the
 /// agent's palette, with two eyes, no mouth and no legs. It hovers above
-/// the bottom edge of the screen, shows what the assistant is doing, and
-/// gets out of the pointer's way. Chosen with `voice.look`; the orb stays
-/// the default.
+/// the bottom edge of the screen, or where it was dragged to (#502),
+/// shows what the assistant is doing, and gets out of the pointer's way.
+/// Chosen with `voice.look`; the orb stays the default.
 ///
-/// It reacts and never interrupts: its window takes no clicks and no
-/// keys, and never comes forward by itself. With Reduce Motion on, or
-/// "Animated orb" off in the menu, it is a still picture that changes
-/// between states and stays where it rests.
+/// It reacts and never interrupts: its window takes no keys, no clicks
+/// but a drag of its body with ⌘ held, and never comes forward by itself.
+/// With Reduce Motion on, or "Animated orb" off in the menu, it is a
+/// still picture that changes between states and stays where it rests.
 @MainActor
 final class CharacterHost {
     /// The body's width in points, and the room around it for its marks
@@ -18,6 +18,9 @@ final class CharacterHost {
     private static let size = NSSize(width: 440, height: 150)
     /// The edge it hovers above, from the bottom of its window.
     private static let ground: CGFloat = 8
+    /// Above the edge, clear of its body at the top of a hop: where its
+    /// speech bubble's tail ends.
+    private static let head: CGFloat = 78
 
     private let window: NSPanel
     private let view = CharacterView(frame: NSRect(origin: .zero, size: CharacterHost.size))
@@ -26,6 +29,8 @@ final class CharacterHost {
     private var motionObserver: NSObjectProtocol?
 
     private var shown = false
+    /// Hidden with its bubble, until the talk key or the menu (#502).
+    private var hidden = false
     private var animated = true
     private var reduceMotion = NSWorkspace.shared.accessibilityDisplayShouldReduceMotion
     private var activity = CharacterMath.Activity.idle
@@ -34,6 +39,25 @@ final class CharacterHost {
     var levelSource: (() -> Float)?
     /// Where the pointer is, in screen coordinates.
     var pointerSource: () -> NSPoint = { NSEvent.mouseLocation }
+    /// Its speech bubble (#491), the pill: told every frame where the
+    /// character's head is and on which screen, it answers with where the
+    /// bubble is, or nil while it is hidden. Set by the app.
+    var bubble: ((NSPoint, NSRect) -> NSRect?)?
+    private var bubbleFrame: NSRect?
+
+    /// Where it was dragged to: the point under it. Nil: its corner.
+    private var place = Config.characterPlace
+    /// Where it rests now, `place` made safe for the screens there are.
+    private var rest = CGPoint.zero
+    /// Its body on screen: where it can be taken hold of.
+    private var body = NSRect.zero
+    /// Carried by the pointer: where the pointer took hold, and where it
+    /// stood then, which is not where it rests once it has stepped aside.
+    private var carried: (from: NSPoint, rest: CGPoint)?
+    /// A still picture: Reduce Motion, or "Animated orb" off.
+    private var still: Bool { !animated || reduceMotion }
+    /// The look is the character: whether it is on screen. Nil with the orb.
+    var onScreen: Bool? { shown ? !hidden : nil }
 
     init() {
         window = NSPanel(contentRect: NSRect(origin: .zero, size: Self.size),
@@ -47,6 +71,7 @@ final class CharacterHost {
         window.hidesOnDeactivate = false
         window.ignoresMouseEvents = true
         window.contentView = view
+        view.onDrag = { [weak self] phase in self?.drag(phase) }
         view.unit = Self.diameter / 100
         view.edge = CGPoint(x: Self.size.width / 2, y: Self.size.height - Self.ground)
         motionObserver = NSWorkspace.shared.notificationCenter.addObserver(
@@ -68,6 +93,22 @@ final class CharacterHost {
         run()
     }
 
+    /// Hide it, as its bubble is hidden: gone until it is asked back.
+    func setHidden(_ on: Bool) {
+        guard hidden != on else { return }
+        hidden = on
+        run()
+    }
+
+    /// "Reset position" in the menu: back to its corner, forgetting where
+    /// it was dragged. Not with the orb look, whose place is the pill's.
+    func resetPosition() {
+        guard shown else { return }
+        place = nil
+        Config.characterPlace = nil
+        redraw()
+    }
+
     /// "Animated orb" in the menu.
     func setAnimated(_ on: Bool) {
         guard animated != on else { return }
@@ -79,36 +120,83 @@ final class CharacterHost {
     func show(_ activity: CharacterMath.Activity, tint: NSColor, colors: [NSColor]?) {
         self.activity = activity
         view.stops = CharacterDraw.stops(tint: tint, colors: colors)
-        if shown && timer == nil { tick() }
+        redraw()
+    }
+
+    /// Standing still, it is drawn again when something changes: its
+    /// state, or its bubble showing or hiding.
+    func redraw() {
+        if shown && !hidden && still { tick() }
     }
 
     /// The frames run only while it is on screen and may move.
     private func run() {
         timer?.invalidate()
         timer = nil
-        guard shown else { window.orderOut(nil); return }
+        guard shown, !hidden else { carried = nil; window.orderOut(nil); return }
         tick()
         window.orderFrontRegardless()
-        guard animated, !reduceMotion else { return }
-        timer = Timer.scheduledTimer(withTimeInterval: 1.0 / 30, repeats: true) { [weak self] _ in
-            MainActor.assumeIsolated { self?.tick() }
+        // Still, it only watches for the hand that moves it.
+        let still = still
+        let timer = Timer.scheduledTimer(withTimeInterval: still ? 0.1 : 1.0 / 30, repeats: true) { [weak self] _ in
+            MainActor.assumeIsolated { if still { self?.aim() } else { self?.tick() } }
         }
         // Keeps moving while a menu is open or the pill is dragged.
-        if let timer { RunLoop.main.add(timer, forMode: .common) }
+        RunLoop.main.add(timer, forMode: .common)
+        self.timer = timer
+    }
+
+    /// It takes the pointer only to be moved: on its body, with ⌘ held.
+    /// Any other click goes through it to the window behind.
+    private func aim() {
+        // The button came up where no event told of it.
+        if carried != nil && NSEvent.pressedMouseButtons & 1 == 0 { drop() }
+        let take = carried != nil || (NSEvent.modifierFlags.contains(.command) && body.contains(pointerSource()))
+        if window.ignoresMouseEvents == take { window.ignoresMouseEvents = !take }
+    }
+
+    private func drag(_ phase: CharacterView.Drag) {
+        switch phase {
+        case .began:
+            let mouse = pointerSource()
+            if body.contains(mouse) { carried = (mouse, CGPoint(x: body.midX, y: rest.y)) }
+        case .moved:
+            if carried != nil { tick() }
+        case .ended:
+            if carried != nil { tick() }
+            drop()
+        }
+    }
+
+    /// Let go: where it was carried to is kept. A click alone moves nothing.
+    private func drop() {
+        guard let was = carried else { return }
+        carried = nil
+        guard pointerSource() != was.from else { return }
+        place = rest
+        Config.characterPlace = rest
     }
 
     private func tick() {
-        // The screen with the menu bar, less the menu bar and the Dock.
-        guard let screen = NSScreen.screens.first else { return }
-        let visible = screen.visibleFrame
-        // It rests beside the pill's own corner, so they read as one, and
-        // goes no further right: stepping aside never puts it on the pill.
-        let left = Double(visible.minX + 44)
-        let home = max(Double(visible.maxX - PillPlacement.inset - Panel.size.width - 52), left)
-        let range = left...home
+        // Where nobody put it: the screen with the menu bar, less the
+        // menu bar and the Dock; under the right end of its bubble, the
+        // bubble in the pill's own corner. It goes no further right.
+        let screens = NSScreen.screens
+        guard let first = screens.first else { return }
+        let mouse = pointerSource()
+        var wanted = place
+        if let carried {
+            wanted = CGPoint(x: carried.rest.x + mouse.x - carried.from.x, y: carried.rest.y + mouse.y - carried.from.y)
+        }
+        let spot = PillPlacement.character(saved: wanted, room: Self.head + PillPlacement.tail + Panel.size.height,
+                                           screens: screens.map(\.visibleFrame), fallback: first.visibleFrame)
+        let visible = spot.visible
+        rest = spot.place
+        let home = Double(rest.x)
+        if carried != nil { sim.carry(to: home) }
 
         let frame: CharacterSim.Frame
-        if timer == nil {
+        if still {
             frame = CharacterSim.still(activity, home: home)
         } else {
             if activity == .listening, let read = levelSource {
@@ -116,16 +204,28 @@ final class CharacterHost {
             } else {
                 level = 0
             }
-            let mouse = pointerSource()
-            let pointer = screen.frame.contains(mouse) ? (x: Double(mouse.x), y: Double(mouse.y - visible.minY)) : nil
+            let near = screens.first { $0.visibleFrame == visible }?.frame.contains(mouse) ?? false
+            let pointer = near ? (x: Double(mouse.x), y: Double(mouse.y - rest.y)) : nil
+            // The gap its tail fills counts as the bubble, so a pointer a
+            // little under a button does not send both away. With ⌘ held
+            // it waits too, to be taken hold of.
+            let held = carried != nil
+                || (bubbleFrame?.insetBy(dx: 0, dy: -PillPlacement.tail).contains(mouse) ?? false)
+                || (NSEvent.modifierFlags.contains(.command) && window.frame.contains(mouse))
             frame = sim.step(to: ProcessInfo.processInfo.systemUptime,
-                             CharacterSim.Input(activity: activity, level: level, pointer: pointer, home: home, range: range))
+                             CharacterSim.Input(activity: activity, level: level, pointer: pointer, held: held,
+                                                home: home, range: Double(spot.ends.lowerBound)...Double(spot.ends.upperBound)))
         }
-        let origin = NSPoint(x: (CGFloat(frame.x) - Self.size.width / 2).rounded(), y: visible.minY - Self.ground)
+        let origin = NSPoint(x: (CGFloat(frame.x) - Self.size.width / 2).rounded(), y: (rest.y - Self.ground).rounded())
         if window.frame.origin != origin { window.setFrameOrigin(origin) }
+        body = NSRect(x: CGFloat(frame.x) - Self.diameter / 2, y: rest.y, width: Self.diameter, height: Self.head)
+        // The bubble goes with the window, so the two move as one.
+        bubbleFrame = bubble?(NSPoint(x: origin.x + Self.size.width / 2, y: origin.y + Self.ground + Self.head), visible)
+        view.bubble = bubbleFrame?.offsetBy(dx: -origin.x, dy: -origin.y)
         view.origin = origin.x
         view.shown = frame
         view.needsDisplay = true
+        aim()
     }
 }
 
@@ -138,9 +238,18 @@ final class CharacterView: NSView {
     /// Under the character, in this view; and the view's left edge on screen.
     var edge = CGPoint.zero
     var origin: CGFloat = 0
+    /// Its speech bubble in this window, origin bottom-left; nil while hidden.
+    var bubble: NSRect?
+
+    /// A drag of its body. Its window takes the mouse for nothing else.
+    enum Drag { case began, moved, ended }
+    var onDrag: ((Drag) -> Void)?
 
     override var isFlipped: Bool { true }
-    override func hitTest(_ point: NSPoint) -> NSView? { nil }
+    override func acceptsFirstMouse(for event: NSEvent?) -> Bool { true }
+    override func mouseDown(with event: NSEvent) { onDrag?(.began) }
+    override func mouseDragged(with event: NSEvent) { onDrag?(.moved) }
+    override func mouseUp(with event: NSEvent) { onDrag?(.ended) }
 
     override func draw(_ dirtyRect: NSRect) {
         guard let ctx = NSGraphicsContext.current?.cgContext else { return }
@@ -148,5 +257,30 @@ final class CharacterView: NSView {
         // to the nearest point; the rest of the way is drawn here.
         let at = CGPoint(x: CGFloat(shown.x) - origin, y: edge.y)
         CharacterDraw.draw(shown, in: ctx, edge: at, origin: origin, unit: unit, stops: stops)
+        if let bubble { drawTail(in: ctx, from: bubble) }
+    }
+
+    /// The bubble's tail: a small point from its bottom edge down to the
+    /// character, in the bubble's own colours.
+    private func drawTail(in ctx: CGContext, from bubble: NSRect) {
+        let half: CGFloat = 7, corner = Brand.Radius.lg + half
+        let x = min(max(bounds.midX, bubble.minX + corner), bubble.maxX - corner)
+        // One point up into the bubble, so no gap shows between the two.
+        let top = bounds.height - bubble.minY - 1
+        let tip = CGPoint(x: x, y: top + 1 + PillPlacement.tail)
+        effectiveAppearance.performAsCurrentDrawingAppearance {
+            ctx.move(to: CGPoint(x: x - half, y: top))
+            ctx.addLine(to: tip)
+            ctx.addLine(to: CGPoint(x: x + half, y: top))
+            ctx.closePath()
+            ctx.setFillColor(NSColor.windowBackgroundColor.withAlphaComponent(0.92).cgColor)
+            ctx.fillPath()
+            ctx.move(to: CGPoint(x: x - half, y: top + 1))
+            ctx.addLine(to: tip)
+            ctx.addLine(to: CGPoint(x: x + half, y: top + 1))
+            ctx.setStrokeColor(NSColor.separatorColor.cgColor)
+            ctx.setLineWidth(1)
+            ctx.strokePath()
+        }
     }
 }

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

@@ -17,6 +17,9 @@ struct CharacterSim {
         /// The pointer: along the edge, and its height above it. Nil when
         /// it is on another screen.
         var pointer: (x: Double, y: Double)?
+        /// The pointer is on its speech bubble: it stays where it is, so
+        /// the bubble is not pulled from under the pointer.
+        var held = false
         /// Where it rests, and how far it may go.
         var home = 0.0
         var range: ClosedRange<Double> = 0...0
@@ -98,14 +101,17 @@ struct CharacterSim {
 
         // The pointer comes close: out of its way. Left alone: back home,
         // unless the pointer is resting there.
-        let near = input.pointer.map { abs($0.x - x) < reach && $0.y < tall } ?? false
-        if near {
+        let near = input.pointer.map { abs($0.x - x) < reach && abs($0.y) < tall } ?? false
+        if input.held {
+            target = x
+            awayUntil = max(awayUntil, now + Self.awayFor)
+        } else if near {
             target = M.aside(x: x, pointer: input.pointer!.x, clear: Self.clear, range: input.range)
             awayUntil = now + Self.awayFor
             restSince = now
             steppedAside = true
         } else if now >= awayUntil {
-            let taken = input.pointer.map { abs($0.x - input.home) < Self.clear && $0.y < tall } ?? false
+            let taken = input.pointer.map { abs($0.x - input.home) < Self.clear && abs($0.y) < tall } ?? false
             if !taken {
                 if target != input.home { steppedAside = false }
                 target = min(max(input.home, input.range.lowerBound), input.range.upperBound)
@@ -191,6 +197,11 @@ struct CharacterSim {
                      dots: dots.compactMap { dot(at: now, $0) }, stars: bursts.flatMap { stars(at: now, $0) })
     }
 
+    /// Carried by the pointer (#502): it is where it is put, at once.
+    mutating func carry(to place: Double) {
+        x = place; target = place; speed = 0
+    }
+
     /// The state alone, where it rests: for Reduce Motion, which shows a
     /// still picture that changes between states and never a loop.
     static func still(_ activity: M.Activity, home: Double) -> Frame {

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

@@ -49,6 +49,21 @@ enum Config {
         }
     }
 
+    /// Where the character was last dragged to (the point under it, in
+    /// screen points). Its own key, so the pill's place is kept for the
+    /// orb look. Nil: under its bubble's default corner.
+    static var characterPlace: CGPoint? {
+        get {
+            guard let xy = UserDefaults.standard.array(forKey: "characterPlace") as? [Double], xy.count == 2
+            else { return nil }
+            return CGPoint(x: xy[0], y: xy[1])
+        }
+        set {
+            if let p = newValue { UserDefaults.standard.set([Double(p.x), Double(p.y)], forKey: "characterPlace") }
+            else { UserDefaults.standard.removeObject(forKey: "characterPlace") }
+        }
+    }
+
     /// 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/Panel.swift

@@ -107,11 +107,18 @@ final class Panel: NSPanel {
 
     /// Told what the orb is shown, so the character can show the same.
     var onLook: ((State, NSColor, [NSColor]?) -> Void)?
+    /// Told when it comes on screen or leaves it, so a still character
+    /// draws its bubble's tail again.
+    var onShown: (() -> Void)?
 
     /// Off while the character stands in for the orb (Character.swift):
     /// the words start where the orb was.
     private(set) var showsOrb = true
 
+    /// Set while the pill is the character's speech bubble: where the
+    /// character's head is, and the screen it is on.
+    private(set) var bubble: (head: NSPoint, visible: NSRect)?
+
     /// Told of every state rendered, so the menu-bar icon can follow.
     var onRender: ((State) -> Void)?
 
@@ -332,18 +339,50 @@ final class Panel: NSPanel {
     @MainActor
     func restorePosition() {
         collapse(animated: false)
+        if let bubble {
+            place(PillPlacement.bubble(size: frame.size, head: bubble.head, visible: bubble.visible))
+            return
+        }
         let screens = NSScreen.screens.map(\.visibleFrame)
         let fallback = (NSScreen.main ?? NSScreen.screens.first)?.visibleFrame ?? .zero
         place(PillPlacement.clamp(saved: Config.pillOrigin, size: frame.size, screens: screens, fallback: fallback))
     }
 
     /// Back to the bottom-right corner, forgetting where it was dragged.
+    /// Not while it is the character's bubble: nothing would move, and
+    /// the place kept for the orb look would be lost.
     @MainActor
     func resetPosition() {
+        guard bubble == nil else { return }
         Config.pillOrigin = nil
         restorePosition()
     }
 
+    /// The character's speech bubble (#491): the pill sits above `head`,
+    /// the top of the character, and goes where it goes, grown or not. It
+    /// is not dragged by itself, and the place it was dragged to as a
+    /// pill is kept for the orb look.
+    @MainActor
+    func attach(head: NSPoint, visible: NSRect) {
+        bubble = (head, visible)
+        isMovableByWindowBackground = false
+        // Growing or collapsing: it catches up on the next frame.
+        guard placing == 0 else { return }
+        let to = PillPlacement.bubble(size: Self.size, head: head, visible: visible)
+        let from = collapsedFrame().origin
+        let moved = PillPlacement.inside(frame.offsetBy(dx: to.x - from.x, dy: to.y - from.y), visible)
+        if moved.origin != frame.origin { place(moved.origin) }
+    }
+
+    /// The orb look again: a pill of its own, back where it was left.
+    @MainActor
+    func detach() {
+        guard bubble != nil else { return }
+        bubble = nil
+        isMovableByWindowBackground = true
+        restorePosition()
+    }
+
     @MainActor
     private func place(_ origin: NSPoint) {
         placing += 1
@@ -398,7 +437,7 @@ final class Panel: NSPanel {
     func show() {
         orb.setOnScreen(showsOrb)
         miniOrbs.setOnScreen(!miniOrbs.isHidden)
-        if !isVisible { orderFrontRegardless() }
+        if !isVisible { orderFrontRegardless(); onShown?() }
     }
 
     @MainActor
@@ -406,7 +445,7 @@ final class Panel: NSPanel {
         closeButton.isHidden = true
         orb.setOnScreen(false)
         miniOrbs.setOnScreen(false)
-        if isVisible { orderOut(nil) }
+        if isVisible { orderOut(nil); onShown?() }
     }
 
     @objc private func closeClicked() { onDismiss?() }
@@ -461,7 +500,6 @@ final class Panel: NSPanel {
         default: colors = agentPalette()
         }
         orb.show(state.orbPhase, tint: tint, colors: colors)
-        onLook?(state, tint, colors)
 
         if state.isMeta {
             stopMarquee()
@@ -477,6 +515,9 @@ final class Panel: NSPanel {
         // 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() }
+        // After showing or hiding: a still character draws its bubble's
+        // tail only while the bubble is on screen.
+        onLook?(state, tint, colors)
         armCollapse()
         onRender?(state)
     }

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

@@ -68,6 +68,55 @@ enum PillPlacement {
                width: size.width, height: size.height)
     }
 
+    /// How far the bubble reaches to the right of the character's middle,
+    /// and the gap above its head that the bubble's tail fills.
+    static let bubbleReach: CGFloat = 64
+    static let tail: CGFloat = 10
+
+    /// The pill as the character's speech bubble (#491): above `head`,
+    /// the top of the character, most of it to the left, kept on screen.
+    static func bubble(size: CGSize, head: CGPoint, visible: CGRect) -> CGPoint {
+        inside(CGRect(x: head.x + bubbleReach - size.width, y: head.y + tail,
+                      width: size.width, height: size.height), visible).origin
+    }
+
+    /// How close the middle of the character comes to the left edge of
+    /// its screen.
+    static let characterInset: CGFloat = 44
+
+    /// Where the character rests: the point under it, the screen it is
+    /// on, and the ends it may step aside to.
+    struct Spot: Equatable {
+        let place: CGPoint
+        let visible: CGRect
+        let ends: ClosedRange<CGFloat>
+    }
+
+    /// A place the character was dragged to (#502) made safe: on the
+    /// screen nearest to it, between the ends it may step aside to, with
+    /// `room` above it for its body and its bubble. Further than `room`
+    /// from every screen (its monitor was unplugged, or the saved value
+    /// is nonsense) or nil: under the right end of its bubble, the bubble
+    /// in the pill's default corner of `fallback`.
+    static func character(saved: CGPoint?, room: CGFloat, screens: [CGRect], fallback: CGRect) -> Spot {
+        var visible = fallback
+        var p = CGPoint(x: fallback.maxX, y: fallback.minY)
+        if let saved, saved.x.isFinite, saved.y.isFinite {
+            func far(_ r: CGRect) -> CGFloat {
+                hypot(max(r.minX - saved.x, 0, saved.x - r.maxX), max(r.minY - saved.y, 0, saved.y - r.maxY))
+            }
+            if let near = screens.min(by: { far($0) < far($1) }), far(near) <= room {
+                visible = near
+                p = saved
+            }
+        }
+        let left = visible.minX + characterInset
+        let right = max(visible.maxX - inset - bubbleReach, left)
+        return Spot(place: CGPoint(x: min(max(p.x, left), right),
+                                   y: min(max(p.y, visible.minY), max(visible.maxY - room, visible.minY))),
+                    visible: visible, ends: left...right)
+    }
+
     /// `frame` moved the least distance that puts it inside `bounds`. A
     /// frame larger than `bounds` keeps its top-left corner in view.
     static func inside(_ frame: CGRect, _ bounds: CGRect) -> CGRect {

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

@@ -49,6 +49,11 @@ final class StatusMenu: NSObject, NSMenuDelegate {
     var onResetPosition: (() -> Void)?
     /// Whether the pill is on screen, for "Hide pill" and "Show floating pill".
     var pillVisible: () -> Bool = { false }
+    /// The character look: whether the character is on screen. Nil with
+    /// the orb look.
+    var characterVisible: () -> Bool? = { nil }
+    /// Bring a hidden character back, and let its bubble show again.
+    var onShowCharacter: (() -> Void)?
     var onSettings: (() -> Void)?
 
     override init() {
@@ -243,9 +248,15 @@ final class StatusMenu: NSObject, NSMenuDelegate {
         let orb = action("Animated orb", #selector(toggleOrb), key: "")
         orb.state = Config.animatedOrb ? .on : .off
         menu.addItem(orb)
-        let hide = action("Hide pill", #selector(hidePill), key: "")
-        hide.isEnabled = pillVisible()
-        menu.addItem(hide)
+        // The character hides with its bubble, and has no bubble at rest.
+        switch characterVisible() {
+        case true?: menu.addItem(action("Hide character", #selector(hidePill), key: ""))
+        case false?: menu.addItem(action("Show character", #selector(showCharacter), key: ""))
+        case nil:
+            let hide = action("Hide pill", #selector(hidePill), key: "")
+            hide.isEnabled = pillVisible()
+            menu.addItem(hide)
+        }
         menu.addItem(action("Reset position", #selector(resetPosition), key: ""))
 
         menu.addItem(.separator())
@@ -303,6 +314,7 @@ final class StatusMenu: NSObject, NSMenuDelegate {
     }
 
     @objc private func hidePill() { onHidePill?() }
+    @objc private func showCharacter() { onShowCharacter?() }
     @objc private func resetPosition() { onResetPosition?() }
 
     @objc private func openSettings() { onSettings?() }

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

@@ -145,6 +145,12 @@ struct VoiceSettings: Codable, Equatable {
         return out
     }
 
+    /// Seconds to wait before asking the daemon again after a read at
+    /// start that failed: 2, 4, 8, 16, then every 30.
+    static func retryDelay(after failures: Int) -> Double {
+        min(30, pow(2, Double(max(1, failures))))
+    }
+
     /// The fields a preview speaks with: the draft's voice for one agent.
     func previewVoice(for id: String) -> [String: Any] {
         guard let v = agents.first(where: { $0.id == id })?.voice else { return [:] }