agentix-cli 0.93.0 → 0.94.1

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
@@ -29,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
@@ -43,6 +45,20 @@ final class CharacterHost {
     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),
                          styleMask: [.borderless, .nonactivatingPanel], backing: .buffered, defer: false)
@@ -55,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(
@@ -76,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 }
@@ -93,36 +126,77 @@ final class CharacterHost {
     /// Standing still, it is drawn again when something changes: its
     /// state, or its bubble showing or hiding.
     func redraw() {
-        if shown && timer == nil { tick() }
+        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 under the right end of its bubble, the bubble in the
-        // pill's own corner, and goes no further right.
-        let left = Double(visible.minX + 44)
-        let home = max(Double(visible.maxX - PillPlacement.inset - PillPlacement.bubbleReach), 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 {
@@ -130,23 +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.
-            let held = bubbleFrame?.insetBy(dx: 0, dy: -PillPlacement.tail).contains(mouse) ?? false
+            // 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, held: held,
-                                                home: home, range: range))
+                                                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: visible.minY + Self.head), visible)
+        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()
     }
 }
 
@@ -162,8 +241,15 @@ final class CharacterView: NSView {
     /// 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 }

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

@@ -101,7 +101,7 @@ 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
+        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)
@@ -111,7 +111,7 @@ struct CharacterSim {
             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)
@@ -197,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/Hotkey.swift

@@ -11,10 +11,10 @@ import Carbon.HIToolbox
 /// ⌥Space and not ⌃Space: control-space is bound to input-source switching
 /// on many Macs, and silently stealing it is a bad first impression.
 ///
-/// Each instance carries its own `id` and IGNORES events for any other.
-/// That is not decoration: every installed handler is called for EVERY
-/// registered hotkey, so a second binding without this filter makes both
-/// actions fire on either key.
+/// Each instance carries its own `id` and PASSES ON events for any other.
+/// That is not decoration: a press of any registered hotkey goes to the
+/// handler installed last, and reaches the one before it only when that
+/// handler says the event was not its own.
 final class Hotkey {
     private var ref: EventHotKeyRef?
     private var handler: EventHandlerRef?
@@ -62,7 +62,10 @@ final class Hotkey {
                 event, EventParamName(kEventParamDirectObject),
                 EventParamType(typeEventHotKeyID), nil,
                 MemoryLayout<EventHotKeyID>.size, nil, &fired)
-            if status == noErr, fired.id != me.id { return noErr }
+            // Not ours: say so. `noErr` means "handled" and ends the event
+            // there, so the key registered last answered and every key
+            // before it, the talk key first, was dead (#511).
+            if status == noErr, fired.id != me.id { return OSStatus(eventNotHandledErr) }
 
             let kind = GetEventKind(event)
             DispatchQueue.main.async {

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

@@ -80,6 +80,43 @@ enum PillPlacement {
                       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 [:] }

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

@@ -50,6 +50,10 @@ 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>?
+    /// A lesson our last turn started may still be speaking: a click then
+    /// opens the door at once, like the key, so the microphone does not
+    /// take the lesson's voice for the listener's.
+    private var lessonOn = false
     /// 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>?
@@ -150,7 +154,8 @@ final class App: NSObject, NSApplicationDelegate {
             text.flatMap(HotkeySpec.init) ?? HotkeySpec(fallback)!
         }
         let register = { (key: Hotkey, spec: HotkeySpec, what: String) in
-            if !key.register(spec) { Log.warn("shortcut \(spec.text ?? "?") for \(what) is taken by another app") }
+            if key.register(spec) { Log.info("shortcut \(spec.text ?? "?") for \(what): registered") }
+            else { Log.warn("shortcut \(spec.text ?? "?") for \(what) is taken by another app") }
         }
 
         // Hold to talk; release sends.
@@ -229,15 +234,16 @@ final class App: NSObject, NSApplicationDelegate {
         NSWorkspace.shared.open(url)
     }
 
-    /// Close, Esc or "Hide pill": the pill goes and the voice stops, the
-    /// same stop as ⌘⌥. An open microphone closes without sending. The
-    /// next talk key brings the pill back.
+    /// Close, Esc or "Hide pill": the pill goes, the character with it,
+    /// and the voice stops, the same stop as ⌘⌥. An open microphone closes
+    /// without sending. The next talk key brings them back.
     private func dismissPill() {
         Log.info("pill: dismissed")
         // Closing the pill declines a ringing call and ends one in progress.
         if ringingCall != nil { endRinging { await CallClient.decline($0) } }
         if activeCall != nil { hangUp() }
         panel.dismiss()
+        character.setHidden(true)
         if recorder.isRecording {
             stopPolling()
             _ = recorder.stop()
@@ -247,6 +253,13 @@ final class App: NSObject, NSApplicationDelegate {
         stopSpeaking()
     }
 
+    /// The talk key, a call or the menu: a hidden pill may show again,
+    /// and a hidden character is back.
+    private func summonPill() {
+        character.setHidden(false)
+        panel.summon()
+    }
+
     /// ⌘⌥V. Everything except the hotkey lives in `agentx paste`.
     private func smartPaste() {
         guard !busy else { return }
@@ -334,7 +347,13 @@ final class App: NSObject, NSApplicationDelegate {
         panel.answer.onOpenChat = { [weak self] in self?.openChat() }
         statusMenu.pillVisible = { [weak self] in self?.panel.isVisible ?? false }
         statusMenu.onHidePill = { [weak self] in self?.dismissPill() }
-        statusMenu.onResetPosition = { [weak self] in self?.panel.resetPosition() }
+        statusMenu.characterVisible = { [weak self] in self?.character.onScreen }
+        statusMenu.onShowCharacter = { [weak self] in self?.summonPill() }
+        // Each does nothing with the other's look.
+        statusMenu.onResetPosition = { [weak self] in
+            self?.panel.resetPosition()
+            self?.character.resetPosition()
+        }
         statusMenu.onAnimatedOrbChanged = { [weak self] on in
             self?.panel.orb.setAnimated(on)
             self?.panel.miniOrbs.setAnimated(on)
@@ -345,7 +364,7 @@ final class App: NSObject, NSApplicationDelegate {
             guard let self else { return }
             self.panel.alwaysVisible = on
             // Asking for the pill brings back one that was dismissed.
-            if on { self.panel.summon() }
+            if on { self.summonPill() }
             if !self.busy && !self.recorder.isRecording { self.panel.render(.idle) }
         }
         statusMenu.onTargetChanged = { [weak self] id in
@@ -366,8 +385,17 @@ final class App: NSObject, NSApplicationDelegate {
             guard let self else { return }
             if recording { self.unregisterHotkeys() } else { self.registerHotkeys() }
         }
+        // At login the app can start before the daemon answers. Keep
+        // asking: one missed read left the orb and the built-in
+        // shortcuts until the app was restarted.
         Task { @MainActor in
-            if let saved = await AgentClient.settings() { apply(saved) }
+            var failures = 0
+            while true {
+                if let saved = await AgentClient.settings() { apply(saved); break }
+                failures += 1
+                if failures == 1 { Log.warn("settings: the daemon did not answer, asking again") }
+                try? await Task.sleep(for: .seconds(VoiceSettings.retryDelay(after: failures)))
+            }
         }
 
         // Turning the hold OFF is the moment anything that piled up
@@ -445,6 +473,7 @@ final class App: NSObject, NSApplicationDelegate {
             panel.render(.error(error.localizedDescription))
             return
         }
+        if !followUp && lessonOn { talkCheck = Task { await AgentClient.hush() } }
         openedAt = Date()
         patience = followUp ? (activeCall == nil ? followUpPatience : callPatience) : clickPatience
         silentClose = followUp
@@ -476,6 +505,11 @@ final class App: NSObject, NSApplicationDelegate {
         if Date().timeIntervalSince(openedAt) >= patience {
             stopPolling()
             _ = recorder.stop()
+            // Nothing said after an early hush: let the queue play on.
+            if let door = talkCheck {
+                talkCheck = nil
+                Task { _ = await door.value; await AgentClient.resume() }
+            }
             panel.render(silentClose ? rest : .error("Didn't catch that"))
             if !silentClose { resetSoon() }
         }
@@ -516,7 +550,7 @@ final class App: NSObject, NSApplicationDelegate {
         stopPolling()
         guard !recorder.isRecording else { return }
         // A dismissed pill comes back with the talk key.
-        panel.summon()
+        summonPill()
         // Option-Space is the door to everything spoken, always: our own
         // answer or step line stops now, and the daemon hushes any talk,
         // lesson or narration, remembering which it was. Even mid-turn —
@@ -583,6 +617,7 @@ final class App: NSObject, NSApplicationDelegate {
                 return
             }
             let hushed = await door.value
+            lessonOn = hushed.kind == "lesson"
             // 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) {
@@ -761,7 +796,7 @@ final class App: NSObject, NSApplicationDelegate {
             busy = false
             // A live lesson now runs on screen and speaks for itself; an
             // open mic would hear the agent. Option-Space is the door.
-            if ["teach", "watch", "act"].contains(answer.presenceMode ?? "") { return }
+            if ["teach", "watch", "act"].contains(answer.presenceMode ?? "") { lessonOn = true; return }
             // Another agent's answer is still to come; an open mic would
             // take it for the listener's words.
             if openAsides > 0 { return }
@@ -879,7 +914,7 @@ final class App: NSObject, NSApplicationDelegate {
         case .ring(let call):
             Log.info("call: \(call.agentId) is calling: \(call.reason)")
             ringingCall = call
-            panel.summon()
+            summonPill()
             panel.showCall(.ringing)
             panel.render(.ringing(CallModel.ringingText(name: statusMenu.name(of: call.agentId), reason: call.reason)))
             ringer.start(sound: state.ringSound)