agentix-cli 0.59.0 → 0.60.0

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

@@ -213,7 +213,11 @@ enum AgentClient {
         /// "#RRGGBB": presence.color, else derived from the id. Older
         /// daemons send none, and the app derives it the same way.
         let color: String?
+        /// The orb's nature palette. Older daemons send none, and the orb
+        /// uses shades of `color`.
+        let palette: Palette?
         var label: String { name ?? id }
+        struct Palette: Decodable { let id: String; let colors: [String] }
     }
 
     /// The daemon's agents, or nil when the daemon cannot be reached.

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

@@ -0,0 +1,228 @@
+import AppKit
+import WebKit
+
+/// What the agent said, in a form you can read, select and copy, inside
+/// the pill.
+///
+/// Speech is lossy in one specific way that matters: a URL cannot be
+/// spoken usefully, an image cannot be spoken at all, and a name you have
+/// not seen written is a name you cannot act on. The spoken answer is
+/// deliberately short and stripped of exactly those things, so without a
+/// visual surface everything worth keeping from a turn is the part that
+/// gets thrown away.
+///
+/// Rich content arrives through the same `agentx:ui` directive Telegram
+/// and WhatsApp already use, parsed server-side, so an agent has one way to
+/// attach a link or a picture regardless of where it is speaking.
+final class AnswerView: NSView {
+    // A web view, because agents write markdown: headings, bullets, fenced
+    // code, tables. An NSTextView shows that as a mess of asterisks and
+    // hashes, which defeats the answer's only purpose: being MORE readable
+    // than the spoken answer, not less. Text in it is selectable, and it
+    // scrolls once the answer is taller than the pill lets it grow.
+    private let web = WKWebView()
+    private let links = NSStackView()
+    private let thumb = NSImageView()
+    private let actions = NSStackView()
+    private var source = ""
+
+    /// The answer's natural height, measured after it renders. The pill
+    /// grows to it, up to its maximum.
+    var onHeight: ((CGFloat) -> Void)?
+    /// "Open in chat". Set by the app.
+    var onOpenChat: (() -> Void)?
+
+    private static let linkRow: CGFloat = 34
+    private static let imageHeight: CGFloat = 120
+
+    override init(frame: NSRect) {
+        super.init(frame: frame)
+        web.setValue(false, forKey: "drawsBackground")
+        web.navigationDelegate = self
+        addSubview(web)
+
+        thumb.imageScaling = .scaleProportionallyUpOrDown
+        thumb.isHidden = true
+        addSubview(thumb)
+
+        links.orientation = .horizontal
+        links.spacing = 8
+        links.edgeInsets = NSEdgeInsets(top: 4, left: 12, bottom: 8, right: 12)
+        addSubview(links)
+
+        // Copy and Open in chat, shown while the pointer is over the answer.
+        actions.orientation = .horizontal
+        actions.spacing = 2
+        actions.addArrangedSubview(actionButton("doc.on.doc", "Copy the answer", #selector(copyAnswer)))
+        actions.addArrangedSubview(actionButton("bubble.left.and.bubble.right", "Open in chat", #selector(openChat)))
+        actions.isHidden = true
+        actions.edgeInsets = NSEdgeInsets(top: 1, left: 3, bottom: 1, right: 3)
+        // A backing of its own, so the buttons read over the text below.
+        actions.wantsLayer = true
+        actions.layer?.cornerRadius = 7
+        actions.layer?.cornerCurve = .continuous
+        addSubview(actions)
+
+        addTrackingArea(NSTrackingArea(rect: .zero, options: [.mouseEnteredAndExited, .activeAlways, .inVisibleRect],
+                                       owner: self, userInfo: nil))
+    }
+
+    @available(*, unavailable)
+    required init?(coder: NSCoder) { fatalError("not from a nib") }
+
+    private func actionButton(_ symbol: String, _ label: String, _ action: Selector) -> NSButton {
+        let b = NSButton()
+        b.isBordered = false
+        b.bezelStyle = .regularSquare
+        b.imagePosition = .imageOnly
+        b.image = NSImage(systemSymbolName: symbol, accessibilityDescription: label)
+        b.contentTintColor = .secondaryLabelColor
+        b.toolTip = label
+        b.setAccessibilityLabel(label)
+        b.target = self
+        b.action = action
+        b.widthAnchor.constraint(equalToConstant: 24).isActive = true
+        b.heightAnchor.constraint(equalToConstant: 22).isActive = true
+        return b
+    }
+
+    override func resizeSubviews(withOldSize oldSize: NSSize) {
+        let w = bounds.width, h = bounds.height
+        let linkH: CGFloat = links.arrangedSubviews.isEmpty ? 0 : Self.linkRow
+        let imgH: CGFloat = thumb.isHidden ? 0 : Self.imageHeight
+        thumb.frame = NSRect(x: 12, y: h - imgH - 10, width: w - 24, height: imgH)
+        web.frame = NSRect(x: 0, y: linkH, width: w, height: max(0, h - linkH - imgH - (imgH > 0 ? 16 : 0)))
+        links.frame = NSRect(x: 0, y: 0, width: w, height: linkH)
+        actions.frame = NSRect(x: w - 64, y: h - 32, width: 56, height: 26)
+    }
+
+    /// Does this turn have anything the spoken answer did not already
+    /// deliver?
+    ///
+    /// Opening on every turn, including "Ok.", shows one word you have
+    /// already heard. A surface that adds nothing trains you to ignore it,
+    /// so the turn where it DOES carry a link gets ignored too.
+    ///
+    /// Worth showing when there is rich content, a URL you could click, or
+    /// materially more written than was spoken. Otherwise the speech was
+    /// the whole answer.
+    static func isWorthShowing(spoken: String, written: String?, buttons: [(String, String)], imageURL: String?) -> Bool {
+        if !buttons.isEmpty || imageURL != nil { return true }
+        let text = (written?.isEmpty == false ? written! : spoken)
+        if text.range(of: #"https?://"#, options: .regularExpression) != nil { return true }
+        // Speech drops formatting, so written is often a little longer for
+        // the same content. Only a real difference counts.
+        let spokenLen = spoken.trimmingCharacters(in: .whitespacesAndNewlines).count
+        let writtenLen = text.trimmingCharacters(in: .whitespacesAndNewlines).count
+        if writtenLen > spokenLen + 80 { return true }
+        // Long enough that re-reading it beats re-hearing it.
+        return writtenLen > 280
+    }
+
+    /// `spoken` is what was said; `written` is the fuller answer with the
+    /// URLs and formatting the spoken form had to drop. `onHeight` follows
+    /// once it has rendered.
+    @MainActor
+    func show(spoken: String, written: String?, buttons: [(String, String)], imageURL: String?) {
+        source = (written?.isEmpty == false ? written! : spoken)
+        web.loadHTMLString(Markdown.page(Markdown.toHTML(source), css: Brand.cardCSS), baseURL: nil)
+
+        links.arrangedSubviews.forEach { links.removeArrangedSubview($0); $0.removeFromSuperview() }
+        for (label, url) in buttons.prefix(4) {
+            let b = NSButton(title: label, target: self, action: #selector(openLink(_:)))
+            b.bezelStyle = .push
+            b.controlSize = .small
+            b.toolTip = url
+            b.identifier = NSUserInterfaceItemIdentifier(url)
+            links.addArrangedSubview(b)
+        }
+
+        thumb.isHidden = true
+        thumb.image = nil
+        if let s = imageURL, let u = URL(string: s) {
+            // Off the main thread: a slow image must never stall the UI,
+            // and the answer is useful without it.
+            URLSession.shared.dataTask(with: u) { [weak self] data, _, _ in
+                guard let data, let img = NSImage(data: data) else { return }
+                Task { @MainActor in
+                    guard let self, self.source.isEmpty == false else { return }
+                    self.thumb.image = img
+                    self.thumb.isHidden = false
+                    self.measure()
+                }
+            }.resume()
+        }
+        resizeSubviews(withOldSize: bounds.size)
+    }
+
+    /// Empty again, once the pill has collapsed.
+    @MainActor
+    func clear() {
+        source = ""
+        web.loadHTMLString("", baseURL: nil)
+        thumb.isHidden = true
+        links.arrangedSubviews.forEach { links.removeArrangedSubview($0); $0.removeFromSuperview() }
+    }
+
+    /// The rendered text's height plus the image and links around it.
+    @MainActor
+    private func measure() {
+        let js = "(() => { const b = document.body, s = getComputedStyle(b);"
+            + " return b.scrollHeight + parseFloat(s.marginTop) + parseFloat(s.marginBottom) })()"
+        web.evaluateJavaScript(js) { [weak self] value, _ in
+            MainActor.assumeIsolated {
+                guard let self, !self.source.isEmpty else { return }
+                let text = CGFloat((value as? NSNumber)?.doubleValue ?? 120)
+                let extra = (self.links.arrangedSubviews.isEmpty ? 0 : Self.linkRow)
+                    + (self.thumb.isHidden ? 0 : Self.imageHeight + 16)
+                self.resizeSubviews(withOldSize: self.bounds.size)
+                self.onHeight?(ceil(text + extra))
+            }
+        }
+    }
+
+    override func mouseEntered(with event: NSEvent) {
+        effectiveAppearance.performAsCurrentDrawingAppearance {
+            actions.layer?.backgroundColor = NSColor.windowBackgroundColor.cgColor
+            actions.layer?.borderColor = NSColor.separatorColor.cgColor
+            actions.layer?.borderWidth = 1 / (window?.backingScaleFactor ?? 2)
+        }
+        actions.isHidden = source.isEmpty
+    }
+    override func mouseExited(with event: NSEvent) { actions.isHidden = true }
+
+    @objc private func copyAnswer() {
+        NSPasteboard.general.clearContents()
+        NSPasteboard.general.setString(source, forType: .string)
+    }
+
+    @objc private func openChat() { onOpenChat?() }
+
+    /// Select-and-⌘C: the pill has no Edit menu to route the shortcut.
+    func copySelection() { NSApp.sendAction(#selector(NSText.copy(_:)), to: web, from: nil) }
+
+    @objc private func openLink(_ sender: NSButton) {
+        guard let s = sender.identifier?.rawValue, let u = URL(string: s) else { return }
+        NSWorkspace.shared.open(u)
+    }
+}
+
+extension AnswerView: WKNavigationDelegate {
+    func webView(_ webView: WKWebView, didFinish navigation: WKNavigation!) {
+        MainActor.assumeIsolated { if !source.isEmpty { measure() } }
+    }
+
+    /// Links open in the real browser. A pill is not a place to read a web
+    /// page, and navigating away would replace the answer it exists to hold.
+    func webView(_ webView: WKWebView,
+                 decidePolicyFor navigationAction: WKNavigationAction,
+                 decisionHandler: @escaping (WKNavigationActionPolicy) -> Void) {
+        if navigationAction.navigationType == .linkActivated,
+           let url = navigationAction.request.url {
+            NSWorkspace.shared.open(url)
+            decisionHandler(.cancel)
+            return
+        }
+        decisionHandler(.allow)
+    }
+}

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

@@ -1,8 +1,8 @@
 import AppKit
 import SwiftUI
 
-/// The Siri-style orb at the head of the pill: the agent's colour, and it
-/// listens, thinks and speaks.
+/// The Siri-style orb at the head of the pill: the agent's nature palette
+/// (lagoon, forest, dusk…), and it listens, thinks and speaks.
 ///
 /// Built from SwiftUI's own gradients, no animation library. It only moves
 /// while it has something to show and is on screen: idle or hidden, its
@@ -18,6 +18,9 @@ final class OrbModel: ObservableObject {
     /// 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)
+    /// The agent's palette, five stops deep to light, from the daemon.
+    /// Nil: shades of `tint` (an error, held notifications, an older daemon).
+    @Published var colors: [NSColor]?
     /// The pill is on screen. Off, nothing moves.
     @Published var onScreen = false
     @Published var reduceMotion = NSWorkspace.shared.accessibilityDisplayShouldReduceMotion
@@ -43,8 +46,8 @@ struct PillOrbView: View {
         let paused = model.paused
         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: model.still,
-                    ringWidth: 5)
+                    phase: model.phase, level: model.level, tint: model.tint, colors: model.colors,
+                    still: model.still, ringWidth: 5)
                 .frame(width: Self.designSize, height: Self.designSize)
                 .scaleEffect(diameter / Self.designSize)
         }
@@ -89,11 +92,12 @@ final class PillOrb: NSHostingView<PillOrbView> {
 
     override func hitTest(_ point: NSPoint) -> NSView? { nil }
 
-    /// Show `phase` in `tint`. Cheap to call on every render: SwiftUI only
-    /// redraws what changed.
-    func show(_ phase: OrbModel.Phase, tint: NSColor) {
+    /// Show `phase` in `colors`, or in shades of `tint` without them.
+    /// Cheap to call on every render: SwiftUI only redraws what changed.
+    func show(_ phase: OrbModel.Phase, tint: NSColor, colors: [NSColor]?) {
         let model = driver.model
         if model.tint != tint { model.tint = tint }
+        if model.colors != colors { model.colors = colors }
         if model.phase != phase {
             model.phase = phase
             if phase != .listening { model.level = 0 }
@@ -160,6 +164,8 @@ struct OrbBody: View {
     let phase: OrbModel.Phase
     let level: Double
     let tint: NSColor
+    /// The agent's palette, deep to light; nil for shades of `tint`.
+    var colors: [NSColor]? = nil
     /// Reduce Motion: a still orb, sized and shaded by state alone.
     let still: Bool
     /// The thinking ring's stroke at the 96-point design size. The pill
@@ -190,12 +196,17 @@ struct OrbBody: View {
         let scale = 0.78 + 0.22 * energy
         ZStack {
             Circle()
-                .fill(Color(nsColor: tint).opacity(0.28 + 0.32 * energy))
+                .fill(glow.opacity(0.28 + 0.32 * energy))
                 .blur(radius: 10 + 12 * energy)
                 .scaleEffect(scale * 1.08)
             fill
                 .clipShape(Circle())
                 .scaleEffect(scale)
+            // Glass: a soft light from the top left, as on a marble.
+            Circle()
+                .fill(RadialGradient(colors: [.white.opacity(0.42), .white.opacity(0)],
+                                     center: UnitPoint(x: 0.34, y: 0.26), startRadius: 0, endRadius: 34))
+                .scaleEffect(scale)
             // Thinking reads as a slow ring going round; the other states
             // as a soft rim.
             if phase == .thinking {
@@ -247,9 +258,25 @@ struct OrbBody: View {
         ]
     }
 
+    /// The halo's colour: the palette's middle stop, or the tint.
+    private var glow: Color {
+        if let colors, colors.count == 5 { return Color(nsColor: colors[2]) }
+        return Color(nsColor: tint)
+    }
+
+    /// Five colours for the mesh: the agent's palette when it has one,
+    /// with its light stop brightening into a core as the voice grows.
+    private var palette: [Color] {
+        guard let colors, colors.count == 5 else { return shades }
+        let core = CGFloat(0.1 + 0.35 * energy)
+        let light = colors[4].blended(withFraction: core, of: .white) ?? colors[4]
+        // Spread so neighbouring mesh points differ: deep beside light.
+        return [colors[1], colors[3], colors[0], colors[2], light].map { Color(nsColor: $0) }
+    }
+
     /// 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] {
+    private var shades: [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)

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

@@ -8,8 +8,10 @@ import AppKit
 /// normal windows, joins every Space, and is deliberately small.
 ///
 /// It is the one floating widget: a small live orb at its head (Orb.swift)
-/// in the answering agent's colour, the state or the words beside it, and
-/// a close button that shows on hover. Drag it anywhere; the place is
+/// in the answering agent's palette, the state or the words beside it, and
+/// a close button that shows on hover. When an answer has more to read
+/// than was spoken, the pill grows into it (PanelAnswer.swift) and
+/// collapses again after a while. Drag it anywhere; the place is
 /// remembered across launches.
 final class Panel: NSPanel {
     static let size = NSSize(width: 284, height: 54)
@@ -20,10 +22,35 @@ final class Panel: NSPanel {
     private let label = NSTextField(labelWithString: "")
     let orb = PillOrb(diameter: Panel.orbDiameter, frameSize: Panel.orbFrame)
     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.
+    let row = RowView(frame: NSRect(origin: .zero, size: Panel.size))
+    /// The answer, below or above the row once the pill has grown.
+    let answer = AnswerView(frame: .zero)
+    let separator = NSBox()
     /// Hidden by close, Esc or the menu until the next talk key.
-    private(set) var dismissed = false
-    /// Set while the app moves the pill, so only a drag is remembered.
-    private var placing = false
+    var dismissed = false
+    /// Above zero while the app moves or resizes the pill, so only a drag
+    /// is remembered.
+    var placing = 0
+
+    // MARK: The answer (PanelAnswer.swift)
+
+    /// Width of the pill grown into an answer.
+    static let expandedWidth: CGFloat = 360
+    /// Tallest the answer grows, in points, before it scrolls. From
+    /// voice.card.maxHeight.
+    var cardMaxHeight: CGFloat = 320
+    /// Seconds the answer stays open once spoken; 0 until closed. From
+    /// voice.card.timeout.
+    var cardTimeout: TimeInterval = 30
+    /// Grown into an answer.
+    var expanded = false
+    /// Which way it grew, so it collapses back to the same place.
+    var growth = (above: true, alignRight: true)
+    var collapseTimer: Timer?
+    /// The pointer is over the widget: the answer stays open.
+    var hovering = false
 
     /// Scrolls text too long for the pill instead of truncating it.
     ///
@@ -66,6 +93,9 @@ final class Panel: NSPanel {
     /// The colour of the agent shown, for the orb.
     var agentTint: () -> NSColor = { Brand.accent }
 
+    /// The palette of the agent shown, for the orb; nil for shades of its tint.
+    var agentPalette: () -> [NSColor]? = { nil }
+
     /// Stay on screen when idle. Off: the pill shows only while active.
     var alwaysVisible = false
 
@@ -75,18 +105,18 @@ final class Panel: NSPanel {
     /// Close button or Esc. The app stops speech and calls `dismiss()`.
     var onDismiss: (() -> Void)?
 
-    /// The pill moved, by a drag or a reset. The answer card follows.
-    var onMove: (() -> Void)?
-
     /// The last state rendered, to draw again after a dismiss or a move.
-    private var current = State.idle
+    var current = State.idle
 
+    /// A click on the pill's row talks. A click in the answer does not:
+    /// that is for reading and selecting.
     override func mouseUp(with event: NSEvent) {
         defer { pressedAt = nil }
         if let start = pressedAt {
             let now = NSEvent.mouseLocation
             let moved = hypot(now.x - start.x, now.y - start.y)
-            if moved < 4 { onClick?() }
+            let onRow = convertToScreen(row.convert(row.bounds, to: nil)).contains(start)
+            if moved < 4 && onRow { onClick?() }
         }
         super.mouseUp(with: event)
     }
@@ -168,40 +198,21 @@ final class Panel: NSPanel {
         isMovableByWindowBackground = true
         hidesOnDeactivate = false
 
-        let blur = NSVisualEffectView(frame: NSRect(origin: .zero, size: Self.size))
-        blur.material = .hudWindow
-        blur.blendingMode = .behindWindow
-        blur.state = .active
-        blur.wantsLayer = true
-        blur.layer?.cornerRadius = Brand.Radius.lg
-        blur.layer?.masksToBounds = true
-        blur.autoresizingMask = [.width, .height]
-        contentView = blur
-
-        // An opaque tint over the blur, and it is not a style preference.
-        //
-        // `blendingMode = .behindWindow` composites whatever is behind the
-        // pill, so the editor's own panel dividers were coming through it
-        // as a faint rectangle around the widget — it read as a border the
-        // widget was drawing, when it was the window behind. Translucency
-        // is pleasant over wallpaper and actively confusing over ruled UI.
-        //
-        // This keeps enough blur to feel native while making the pill read
-        // as one solid object wherever it is parked.
-        let tint = NSView(frame: blur.bounds)
-        tint.wantsLayer = true
-        tint.layer?.backgroundColor = NSColor.windowBackgroundColor
-            .withAlphaComponent(0.72).cgColor
-        tint.layer?.cornerRadius = Brand.Radius.lg
-        tint.autoresizingMask = [.width, .height]
-        blur.addSubview(tint)
+        let surface = Surface(frame: NSRect(origin: .zero, size: Self.size))
+        contentView = surface
+        surface.addSubview(row)
+        separator.boxType = .separator
+        separator.isHidden = true
+        surface.addSubview(separator)
+        surface.addSubview(answer)
+        answer.onHeight = { [weak self] height in self?.grow(answerHeight: height) }
 
         // The orb, centred 28 points from the left edge; its square is
         // larger than the orb so the glow is not cut off.
         let h = Self.size.height
         orb.frame = NSRect(x: 28 - Self.orbFrame / 2, y: (h - Self.orbFrame) / 2,
                            width: Self.orbFrame, height: Self.orbFrame)
-        blur.addSubview(orb)
+        row.addSubview(orb)
 
         // A clipping window the label slides behind. Clicks pass through
         // it, so pressing on the words drags the pill too.
@@ -213,7 +224,7 @@ final class Panel: NSPanel {
         label.lineBreakMode = .byClipping
         label.wantsLayer = true
         clipView.addSubview(label)
-        blur.addSubview(clipView)
+        row.addSubview(clipView)
         clip = clipView
 
         // Close, shown while the pointer is over the pill. Its space is
@@ -229,8 +240,10 @@ final class Panel: NSPanel {
         closeButton.target = self
         closeButton.action = #selector(closeClicked)
         closeButton.isHidden = true
-        blur.addSubview(closeButton)
-        blur.addTrackingArea(NSTrackingArea(rect: .zero,
+        row.addSubview(closeButton)
+        surface.layoutContent = { [weak self] bounds in self?.layoutContent(bounds) }
+        MainActor.assumeIsolated { layoutContent(surface.bounds) }
+        surface.addTrackingArea(NSTrackingArea(rect: .zero,
                                             options: [.mouseEnteredAndExited, .activeAlways, .inVisibleRect],
                                             owner: self, userInfo: nil))
 
@@ -246,10 +259,32 @@ final class Panel: NSPanel {
 
     // MARK: Place
 
+    /// The row on the edge it grew from, full width; the answer in the
+    /// rest. The answer is always laid out at its full width, so its text
+    /// does not reflow while the pill grows around it.
+    @MainActor
+    func layoutContent(_ bounds: NSRect) {
+        let h = Self.size.height
+        let answerHeight = max(0, bounds.height - h)
+        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
+        if let clip, clip.frame.width != clipWidth {
+            clip.frame.size.width = clipWidth
+            // Text that scrolled may fit now, and the other way round.
+            marqueeText = ""
+            if !current.isMeta { setText(label.stringValue) }
+        }
+        answer.frame = NSRect(x: 0, y: above ? h : 0, width: Self.expandedWidth, height: answerHeight)
+        separator.frame = NSRect(x: 0, y: above ? h - 1 : answerHeight, width: bounds.width, height: 1)
+    }
+
     /// Where it was left, kept on a screen that still exists; the
     /// bottom-right corner the first time.
     @MainActor
     func restorePosition() {
+        collapse(animated: false)
         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))
@@ -264,19 +299,18 @@ final class Panel: NSPanel {
 
     @MainActor
     private func place(_ origin: NSPoint) {
-        placing = true
+        placing += 1
         setFrameOrigin(origin)
-        placing = false
-        onMove?()
+        placing -= 1
     }
 
     /// Remember a drag. Moves the app makes itself are not saved, so a
-    /// reset or a clamp never overwrites where the user put it.
+    /// reset or a clamp never overwrites where the user put it. Dragged
+    /// while grown, the pill is remembered where it will collapse to.
     @objc private func moved() {
         MainActor.assumeIsolated {
-            guard !placing else { return }
-            Config.pillOrigin = frame.origin
-            onMove?()
+            guard placing == 0 else { return }
+            Config.pillOrigin = expanded ? collapsedFrame().origin : frame.origin
         }
     }
 
@@ -291,6 +325,7 @@ final class Panel: NSPanel {
     @MainActor
     func dismiss() {
         dismissed = true
+        collapse(animated: false)
         hide()
     }
 
@@ -303,7 +338,7 @@ final class Panel: NSPanel {
     }
 
     @MainActor
-    private func show() {
+    func show() {
         orb.setOnScreen(true)
         if !isVisible { orderFrontRegardless() }
     }
@@ -317,8 +352,16 @@ final class Panel: NSPanel {
 
     @objc private func closeClicked() { onDismiss?() }
 
-    override func mouseEntered(with event: NSEvent) { closeButton.isHidden = false }
-    override func mouseExited(with event: NSEvent) { closeButton.isHidden = true }
+    override func mouseEntered(with event: NSEvent) {
+        closeButton.isHidden = false
+        hovering = true
+        MainActor.assumeIsolated { armCollapse() }
+    }
+    override func mouseExited(with event: NSEvent) {
+        closeButton.isHidden = true
+        hovering = false
+        MainActor.assumeIsolated { armCollapse() }
+    }
 
     /// Esc, once the pill has been clicked and so holds the keyboard.
     override func cancelOperation(_ sender: Any?) { onDismiss?() }
@@ -327,6 +370,17 @@ final class Panel: NSPanel {
         if event.keyCode == 53 { onDismiss?() } else { super.keyDown(with: event) }
     }
 
+    /// ⌘C copies what is selected in the answer. The app has no Edit menu
+    /// to route the shortcut there.
+    override func performKeyEquivalent(with event: NSEvent) -> Bool {
+        if expanded, event.modifierFlags.intersection(.deviceIndependentFlagsMask) == .command,
+           event.charactersIgnoringModifiers == "c" {
+            answer.copySelection()
+            return true
+        }
+        return super.performKeyEquivalent(with: event)
+    }
+
     /// AppKit is not thread-safe. Marking this explicitly means a stray
     /// call from a delegate queue is a compile error rather than heap
     /// corruption that traps somewhere unrelated an hour later.
@@ -341,7 +395,13 @@ final class Panel: NSPanel {
         case .idle where Hold.isOn: tint = Brand.warn
         default: tint = agentTint()
         }
-        orb.show(state.orbPhase, tint: tint)
+        let colors: [NSColor]?
+        switch state {
+        case .error: colors = nil
+        case .idle where Hold.isOn: colors = nil
+        default: colors = agentPalette()
+        }
+        orb.show(state.orbPhase, tint: tint, colors: colors)
 
         if state.isMeta {
             stopMarquee()
@@ -354,7 +414,9 @@ final class Panel: NSPanel {
             setText(named(state))
         }
 
-        if dismissed || (state.isMeta && !alwaysVisible) { hide() } else { show() }
+        // Grown into an answer, it stays until it collapses, idle or not.
+        if dismissed || (state.isMeta && !alwaysVisible && !expanded) { hide() } else { show() }
+        armCollapse()
         onRender?(state)
     }
 
@@ -371,7 +433,7 @@ final class Panel: NSPanel {
     /// Fits, or scrolls. Identical text is left alone so a per-second tick
     /// cannot restart the animation and make it stutter in place.
     @MainActor
-    private func setText(_ text: String) {
+    func setText(_ text: String) {
         guard let clipView = clip else { label.stringValue = text; return }
         let font = label.font ?? NSFont.systemFont(ofSize: 12)
         let width = (text as NSString).size(withAttributes: [.font: font]).width
@@ -411,7 +473,7 @@ final class Panel: NSPanel {
     }
 
     @MainActor
-    private func stopMarquee() {
+    func stopMarquee() {
         label.layer?.removeAnimation(forKey: "marquee")
         marqueeText = ""
     }
@@ -426,3 +488,12 @@ final class Panel: NSPanel {
 private final class PassThroughView: NSView {
     override func hitTest(_ point: NSPoint) -> NSView? { nil }
 }
+
+/// The pill's row: its background passes clicks through, so pressing
+/// anywhere on it drags the pill, while its close button still clicks.
+final class RowView: NSView {
+    override func hitTest(_ point: NSPoint) -> NSView? {
+        let hit = super.hitTest(point)
+        return hit === self ? nil : hit
+    }
+}