agentix-cli 0.56.0 → 0.58.0

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

@@ -161,6 +161,49 @@ enum AgentClient {
         return try await URLSession.shared.data(for: req)
     }
 
+    // MARK: Settings
+    //
+    // The settings window reads and saves through the daemon, which checks
+    // every value and writes agentx.json. The app keeps no copy of its own.
+    // See src/daemon/voice-settings-api.ts.
+
+    /// GET /voice/settings, or nil when the daemon cannot be reached.
+    static func settings() async -> VoiceSettings? {
+        guard let url = URL(string: "\(Config.daemonURL)/voice/settings") else { return nil }
+        var req = URLRequest(url: url)
+        // The first call lists the Mac's voices, which can take a moment.
+        req.timeoutInterval = 15
+        guard let (data, response) = try? await URLSession.shared.data(for: req),
+              (response as? HTTPURLResponse)?.statusCode == 200 else { return nil }
+        return try? JSONDecoder().decode(VoiceSettings.self, from: data)
+    }
+
+    /// Save a change. The saved settings, or the daemon's reason in words.
+    static func saveSettings(_ patch: [String: Any]) async -> Result<VoiceSettings, SettingsFailure> {
+        struct Reply: Decodable { let settings: VoiceSettings?; let error: String? }
+        do {
+            let (data, response) = try await post("/voice/settings", patch, timeout: 20)
+            let reply = try? JSONDecoder().decode(Reply.self, from: data)
+            if let s = reply?.settings, (response as? HTTPURLResponse)?.statusCode == 200 { return .success(s) }
+            return .failure(SettingsFailure(message: reply?.error ?? "The daemon did not save the settings."))
+        } catch {
+            return .failure(SettingsFailure(message: "The AgentX daemon isn't reachable: \(error.localizedDescription)"))
+        }
+    }
+
+    /// Say a sample line in an agent's voice with unsaved changes. Nil on
+    /// success, else why not.
+    static func preview(agentID: String, voice: [String: Any]) async -> String? {
+        struct Reply: Decodable { let error: String? }
+        guard let (data, response) = try? await post("/voice/preview", ["agentId": agentID, "voice": voice], timeout: 10) else {
+            return "The AgentX daemon isn't reachable."
+        }
+        if (response as? HTTPURLResponse)?.statusCode == 202 { return nil }
+        return (try? JSONDecoder().decode(Reply.self, from: data))?.error ?? "The preview didn't play."
+    }
+
+    struct SettingsFailure: Error { let message: String }
+
     /// One row of GET /agents: who can answer, and whether they are busy.
     struct AgentInfo: Decodable {
         let id: String

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

@@ -28,11 +28,25 @@ enum Config {
         set { UserDefaults.standard.set(newValue, forKey: "showPill") }
     }
 
-    /// The orb overlay while listening, thinking and speaking. On by
-    /// default; off brings back the pill for those states.
-    static var showOrb: Bool {
-        get { UserDefaults.standard.object(forKey: "showOrb") as? Bool ?? true }
-        set { UserDefaults.standard.set(newValue, forKey: "showOrb") }
+    /// The pill's orb moves with the voice. On by default; off keeps it
+    /// still in every state, as Reduce Motion does.
+    static var animatedOrb: Bool {
+        get { UserDefaults.standard.object(forKey: "animatedOrb") as? Bool ?? true }
+        set { UserDefaults.standard.set(newValue, forKey: "animatedOrb") }
+    }
+
+    /// Where the pill was last dragged to (its bottom-left corner, in
+    /// screen points). Nil: the default corner.
+    static var pillOrigin: CGPoint? {
+        get {
+            guard let xy = UserDefaults.standard.array(forKey: "pillOrigin") 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: "pillOrigin") }
+            else { UserDefaults.standard.removeObject(forKey: "pillOrigin") }
+        }
     }
 
     /// The agent actually answering: `agentID`, else `chosenAgentID`, else

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

@@ -28,7 +28,13 @@ final class Hotkey {
         self.onRelease = onRelease
     }
 
-    func register(keyCode: UInt32 = UInt32(kVK_Space), modifiers: UInt32 = UInt32(optionKey)) {
+    /// Register one shortcut; false when macOS refused it (another app
+    /// already holds it).
+    @discardableResult
+    func register(_ spec: HotkeySpec) -> Bool { register(keyCode: spec.keyCode, modifiers: spec.modifiers) }
+
+    @discardableResult
+    func register(keyCode: UInt32 = UInt32(kVK_Space), modifiers: UInt32 = UInt32(optionKey)) -> Bool {
         var spec = [
             EventTypeSpec(eventClass: OSType(kEventClassKeyboard), eventKind: UInt32(kEventHotKeyPressed)),
             EventTypeSpec(eventClass: OSType(kEventClassKeyboard), eventKind: UInt32(kEventHotKeyReleased)),
@@ -66,7 +72,7 @@ final class Hotkey {
         }, spec.count, &spec, context, &handler)
 
         let hotKeyID = EventHotKeyID(signature: OSType(0x41475856), id: id) // 'AGXV'
-        RegisterEventHotKey(keyCode, modifiers, hotKeyID, GetApplicationEventTarget(), 0, &ref)
+        return RegisterEventHotKey(keyCode, modifiers, hotKeyID, GetApplicationEventTarget(), 0, &ref) == noErr
     }
 
     deinit {

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

@@ -0,0 +1,80 @@
+import Carbon.HIToolbox
+
+/// A shortcut as agentx.json stores it: "opt+space", "cmd+opt+period",
+/// "ctrl+opt+1". The daemon checks and normalises the same form
+/// (src/voice/hotkey.ts); this turns it into what Carbon registers, and a
+/// pressed key back into it.
+struct HotkeySpec: Equatable {
+    let keyCode: UInt32
+    /// Carbon modifier flags (cmdKey, optionKey, …).
+    let modifiers: UInt32
+
+    static let keys: [String: Int] = {
+        var k: [String: Int] = [
+            "a": kVK_ANSI_A, "b": kVK_ANSI_B, "c": kVK_ANSI_C, "d": kVK_ANSI_D, "e": kVK_ANSI_E,
+            "f": kVK_ANSI_F, "g": kVK_ANSI_G, "h": kVK_ANSI_H, "i": kVK_ANSI_I, "j": kVK_ANSI_J,
+            "k": kVK_ANSI_K, "l": kVK_ANSI_L, "m": kVK_ANSI_M, "n": kVK_ANSI_N, "o": kVK_ANSI_O,
+            "p": kVK_ANSI_P, "q": kVK_ANSI_Q, "r": kVK_ANSI_R, "s": kVK_ANSI_S, "t": kVK_ANSI_T,
+            "u": kVK_ANSI_U, "v": kVK_ANSI_V, "w": kVK_ANSI_W, "x": kVK_ANSI_X, "y": kVK_ANSI_Y,
+            "z": kVK_ANSI_Z,
+            "0": kVK_ANSI_0, "1": kVK_ANSI_1, "2": kVK_ANSI_2, "3": kVK_ANSI_3, "4": kVK_ANSI_4,
+            "5": kVK_ANSI_5, "6": kVK_ANSI_6, "7": kVK_ANSI_7, "8": kVK_ANSI_8, "9": kVK_ANSI_9,
+            "space": kVK_Space, "period": kVK_ANSI_Period, "comma": kVK_ANSI_Comma,
+            "slash": kVK_ANSI_Slash, "semicolon": kVK_ANSI_Semicolon, "quote": kVK_ANSI_Quote,
+            "minus": kVK_ANSI_Minus, "equal": kVK_ANSI_Equal,
+            "leftbracket": kVK_ANSI_LeftBracket, "rightbracket": kVK_ANSI_RightBracket,
+            "backslash": kVK_ANSI_Backslash, "grave": kVK_ANSI_Grave,
+            "return": kVK_Return, "tab": kVK_Tab,
+        ]
+        let f = [kVK_F1, kVK_F2, kVK_F3, kVK_F4, kVK_F5, kVK_F6, kVK_F7, kVK_F8, kVK_F9, kVK_F10,
+                 kVK_F11, kVK_F12, kVK_F13, kVK_F14, kVK_F15, kVK_F16, kVK_F17, kVK_F18, kVK_F19, kVK_F20]
+        for (i, code) in f.enumerated() { k["f\(i + 1)"] = code }
+        return k
+    }()
+
+    private static let modifierFlags: [(String, UInt32)] = [
+        ("ctrl", UInt32(controlKey)), ("opt", UInt32(optionKey)),
+        ("shift", UInt32(shiftKey)), ("cmd", UInt32(cmdKey)),
+    ]
+    private static let aliases = ["control": "ctrl", "option": "opt", "alt": "opt", "command": "cmd"]
+
+    /// Nil for anything the daemon would refuse.
+    init?(_ text: String) {
+        let parts = text.lowercased().split(separator: "+", omittingEmptySubsequences: false)
+            .map { $0.trimmingCharacters(in: .whitespaces) }
+        guard let key = parts.last, let code = Self.keys[key] else { return nil }
+        var mods: UInt32 = 0
+        for p in parts.dropLast() {
+            let name = Self.aliases[p] ?? p
+            guard let flag = Self.modifierFlags.first(where: { $0.0 == name })?.1, mods & flag == 0 else { return nil }
+            mods |= flag
+        }
+        let isF = key.hasPrefix("f") && key.count > 1
+        guard isF || mods & UInt32(controlKey | optionKey | cmdKey) != 0 else { return nil }
+        keyCode = UInt32(code)
+        modifiers = mods
+    }
+
+    init(keyCode: UInt32, modifiers: UInt32) {
+        self.keyCode = keyCode
+        self.modifiers = modifiers
+    }
+
+    /// The stored form, modifiers in the Mac's order.
+    var text: String? {
+        guard let key = Self.keys.first(where: { UInt32($0.value) == keyCode })?.key else { return nil }
+        let mods = Self.modifierFlags.filter { modifiers & $0.1 != 0 }.map(\.0)
+        return (mods + [key]).joined(separator: "+")
+    }
+
+    /// "⌃⌥1", as menus show shortcuts.
+    static func display(_ text: String) -> String {
+        let symbols = ["ctrl": "⌃", "opt": "⌥", "shift": "⇧", "cmd": "⌘"]
+        let names = ["space": "Space", "period": ".", "comma": ",", "slash": "/", "semicolon": ";",
+                     "quote": "'", "minus": "-", "equal": "=", "leftbracket": "[", "rightbracket": "]",
+                     "backslash": "\\", "grave": "`", "return": "Return", "tab": "Tab"]
+        var parts = text.lowercased().split(separator: "+").map(String.init)
+        guard let key = parts.popLast() else { return text }
+        return parts.map { symbols[Self.aliases[$0] ?? $0] ?? $0 }.joined() + (names[key] ?? key.uppercased())
+    }
+}

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

@@ -1,90 +1,61 @@
 import AppKit
 import SwiftUI
 
-/// The Siri-style overlay: an orb in the agent's colour that listens,
-/// thinks and speaks, with a line of words under it.
+/// The Siri-style orb at the head of the pill: the agent's colour, and it
+/// listens, thinks and speaks.
 ///
-/// Built from SwiftUI's own gradients, no animation library. The orb only
-/// moves while it is on screen: hidden, its timeline is paused and the
-/// microphone level is no longer read, so an idle assistant costs nothing.
-/// With Reduce Motion on it is a still picture that changes between
-/// states, never a loop.
+/// 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
+/// timeline is paused and the microphone level is no longer read, so an
+/// idle assistant costs nothing. With Reduce Motion on, or "Animated orb"
+/// off in the menu, it is a still picture that changes between states,
+/// never a loop.
 @MainActor
 final class OrbModel: ObservableObject {
-    enum Phase: Equatable { case hidden, listening, thinking, speaking }
+    enum Phase: Equatable { case idle, listening, thinking, speaking }
 
-    @Published var phase: Phase = .hidden
+    @Published var phase: Phase = .idle
     /// 0…1: the microphone while listening.
     @Published var level: Double = 0
     @Published var tint = NSColor(srgbRed: 0.078, green: 0.722, blue: 0.651, alpha: 1)
-    @Published var name = ""
-    /// What was heard, or what is being said.
-    @Published var line = ""
-    /// The step the agent is on, and for how long.
-    @Published var status = ""
+    /// The pill is on screen. Off, nothing moves.
+    @Published var onScreen = false
     @Published var reduceMotion = NSWorkspace.shared.accessibilityDisplayShouldReduceMotion
+    /// "Animated orb" in the menu. Off: a still orb, as with Reduce Motion.
+    @Published var animated = true
+
+    var still: Bool { reduceMotion || !animated }
+    /// The timeline runs only while there is motion to draw.
+    var paused: Bool { still || phase == .idle || !onScreen }
 }
 
-struct OrbView: View {
+/// The orb as the pill draws it: `OrbBody` at its design size, scaled down
+/// to `diameter`, in a frame with room around it for the glow.
+struct PillOrbView: View {
     @ObservedObject var model: OrbModel
-    @Environment(\.colorScheme) private var scheme
+    let diameter: CGFloat
+    let frameSize: CGFloat
 
-    /// The agent's colour, lifted in dark mode so the name stays readable.
-    private var nameColor: Color {
-        guard scheme == .dark, let c = model.tint.usingColorSpace(.sRGB) else { return Color(nsColor: model.tint) }
-        var h: CGFloat = 0, s: CGFloat = 0, b: CGFloat = 0, a: CGFloat = 0
-        c.getHue(&h, saturation: &s, brightness: &b, alpha: &a)
-        return Color(nsColor: NSColor(hue: h, saturation: s * 0.55, brightness: min(1, b + 0.35), alpha: 1))
-    }
+    /// The size OrbBody's blur, ring and gradients were drawn for.
+    private static let designSize: CGFloat = 96
 
     var body: some View {
-        VStack(spacing: 8) {
-            orb.frame(width: 96, height: 96).padding(.top, 4)
-            if !model.name.isEmpty {
-                Text(model.name.uppercased())
-                    .font(.system(size: 10.5, weight: .semibold, design: .monospaced))
-                    .tracking(0.8)
-                    .foregroundStyle(nameColor)
-            }
-            if !model.line.isEmpty {
-                Text(model.line)
-                    .font(.system(size: 13, weight: .medium))
-                    .foregroundStyle(.primary)
-                    .multilineTextAlignment(.center)
-                    .lineLimit(3)
-                    .truncationMode(.head)
-                    .fixedSize(horizontal: false, vertical: true)
-            }
-            if !model.status.isEmpty {
-                Text(model.status)
-                    .font(.system(size: 11))
-                    .foregroundStyle(.secondary)
-                    .lineLimit(1)
-                    .truncationMode(.middle)
-            }
-        }
-        .padding(.horizontal, 18)
-        .padding(.vertical, 14)
-        .frame(width: OrbOverlay.width)
-        .background(.regularMaterial, in: RoundedRectangle(cornerRadius: 22, style: .continuous))
-        .overlay(RoundedRectangle(cornerRadius: 22, style: .continuous)
-            .strokeBorder(Color.primary.opacity(0.08), lineWidth: 1))
-        .frame(maxHeight: .infinity, alignment: .top)
-    }
-
-    private var orb: some View {
-        let still = model.reduceMotion
-        let paused = still || model.phase == .hidden
-        return TimelineView(.animation(minimumInterval: 1.0 / 30, paused: paused)) { context in
+        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: still)
+                    phase: model.phase, level: model.level, tint: model.tint, still: model.still,
+                    ringWidth: 5)
+                .frame(width: Self.designSize, height: Self.designSize)
+                .scaleEffect(diameter / Self.designSize)
         }
+        .frame(width: frameSize, height: frameSize)
+        .accessibilityElement()
         .accessibilityLabel(Text(accessibilityText))
     }
 
     private var accessibilityText: String {
         switch model.phase {
-        case .hidden: return ""
+        case .idle: return "Idle"
         case .listening: return "Listening"
         case .thinking: return "Thinking"
         case .speaking: return "Speaking"
@@ -92,6 +63,97 @@ struct OrbView: View {
     }
 }
 
+/// The orb's view in the pill. Clicks go through it to the pill, so
+/// pressing on the orb drags the pill like anywhere else on it.
+@MainActor
+final class PillOrb: NSHostingView<PillOrbView> {
+    private let driver: OrbDriver
+    var model: OrbModel { driver.model }
+
+    /// The microphone's RMS level, read while listening. Set by the app.
+    var levelSource: (() -> Float)? {
+        get { driver.levelSource }
+        set { driver.levelSource = newValue; driver.watchLevel() }
+    }
+
+    init(diameter: CGFloat, frameSize: CGFloat) {
+        driver = OrbDriver()
+        super.init(rootView: PillOrbView(model: driver.model, diameter: diameter, frameSize: frameSize))
+    }
+
+    @available(*, unavailable)
+    required init(rootView: PillOrbView) { fatalError("use init(diameter:frameSize:)") }
+
+    @available(*, unavailable)
+    required init?(coder: NSCoder) { fatalError("not from a nib") }
+
+    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) {
+        let model = driver.model
+        if model.tint != tint { model.tint = tint }
+        if model.phase != phase {
+            model.phase = phase
+            if phase != .listening { model.level = 0 }
+        }
+        driver.watchLevel()
+    }
+
+    /// The pill came on screen or went off it.
+    func setOnScreen(_ on: Bool) {
+        let model = driver.model
+        guard model.onScreen != on else { return }
+        model.onScreen = on
+        if !on { model.level = 0 }
+        driver.watchLevel()
+    }
+
+    /// "Animated orb" in the menu.
+    func setAnimated(_ on: Bool) {
+        guard driver.model.animated != on else { return }
+        driver.model.animated = on
+        driver.watchLevel()
+    }
+}
+
+/// Reads the microphone into the model while listening, and follows the
+/// Reduce Motion setting.
+@MainActor
+private final class OrbDriver {
+    let model = OrbModel()
+    var levelSource: (() -> Float)?
+    private var levelTimer: Timer?
+    private var motionObserver: NSObjectProtocol?
+
+    init() {
+        motionObserver = NSWorkspace.shared.notificationCenter.addObserver(
+            forName: NSWorkspace.accessibilityDisplayOptionsDidChangeNotification,
+            object: nil, queue: .main) { [weak self] _ in
+            MainActor.assumeIsolated {
+                guard let self else { return }
+                self.model.reduceMotion = NSWorkspace.shared.accessibilityDisplayShouldReduceMotion
+                self.watchLevel()
+            }
+        }
+    }
+
+    /// The microphone is read only while listening, on screen, with
+    /// motion allowed.
+    func watchLevel() {
+        let wanted = model.phase == .listening && model.onScreen && !model.still && levelSource != nil
+        if !wanted { levelTimer?.invalidate(); levelTimer = nil; return }
+        guard levelTimer == nil else { return }
+        levelTimer = Timer.scheduledTimer(withTimeInterval: 1.0 / 20, repeats: true) { [weak self] _ in
+            MainActor.assumeIsolated {
+                guard let self, let read = self.levelSource else { return }
+                self.model.level = OrbMath.smooth(self.model.level, toward: OrbMath.level(fromRMS: read()))
+            }
+        }
+    }
+}
+
 /// One frame of the orb at time `t`.
 struct OrbBody: View {
     let t: Double
@@ -100,11 +162,14 @@ struct OrbBody: View {
     let tint: NSColor
     /// 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
+    /// draws the orb small, so it passes a thicker one that still reads.
+    var ringWidth: CGFloat = 2.2
 
     /// How much the orb swells and glows, 0…1.
     private var energy: Double {
         switch phase {
-        case .hidden: return 0
+        case .idle: return 0
         case .listening: return still ? 0.45 : 0.12 + 0.88 * level
         case .thinking: return still ? 0.2 : 0.22 + 0.08 * sin(t * 2.2)
         case .speaking: return still ? 0.7 : OrbMath.speakingEnvelope(at: t)
@@ -114,7 +179,7 @@ struct OrbBody: View {
     /// How fast the colours drift.
     private var speed: Double {
         switch phase {
-        case .hidden: return 0
+        case .idle: return 0
         case .listening: return 0.5 + level * 1.5
         case .thinking: return 1.3
         case .speaking: return 0.9
@@ -136,7 +201,7 @@ struct OrbBody: View {
             if phase == .thinking {
                 Circle()
                     .trim(from: 0, to: 0.28)
-                    .stroke(Color.white.opacity(0.75), style: StrokeStyle(lineWidth: 2.2, lineCap: .round))
+                    .stroke(Color.white.opacity(0.75), style: StrokeStyle(lineWidth: ringWidth, lineCap: .round))
                     .rotationEffect(.radians(still ? -.pi / 2 : t * 3.1))
                     .scaleEffect(scale * 0.86)
             } else {
@@ -206,106 +271,3 @@ struct OrbBody: View {
         ]
     }
 }
-
-/// The window the orb lives in: floating, on every Space, click-through
-/// and never key, so the app in front keeps the keyboard.
-private final class OrbPanel: NSPanel {
-    override var canBecomeKey: Bool { false }
-    override var canBecomeMain: Bool { false }
-}
-
-@MainActor
-final class OrbOverlay {
-    static let width: CGFloat = 300
-    private static let height: CGFloat = 250
-
-    let model = OrbModel()
-    private let panel: NSPanel
-    private let host: NSHostingView<OrbView>
-    private var levelTimer: Timer?
-    private var motionObserver: NSObjectProtocol?
-
-    /// The microphone's RMS level, read while listening. Set by the app.
-    var levelSource: (() -> Float)?
-
-    init() {
-        panel = OrbPanel(contentRect: NSRect(x: 0, y: 0, width: Self.width, height: Self.height),
-                         styleMask: [.borderless, .nonactivatingPanel],
-                         backing: .buffered, defer: true)
-        panel.isFloatingPanel = true
-        panel.level = .floating
-        panel.collectionBehavior = [.canJoinAllSpaces, .fullScreenAuxiliary, .stationary, .ignoresCycle]
-        panel.isOpaque = false
-        panel.backgroundColor = .clear
-        panel.hasShadow = false
-        panel.ignoresMouseEvents = true
-        panel.hidesOnDeactivate = false
-        host = NSHostingView(rootView: OrbView(model: model))
-        host.frame = NSRect(x: 0, y: 0, width: Self.width, height: Self.height)
-        panel.contentView = host
-
-        let model = self.model
-        motionObserver = NSWorkspace.shared.notificationCenter.addObserver(
-            forName: NSWorkspace.accessibilityDisplayOptionsDidChangeNotification,
-            object: nil, queue: .main) { _ in
-            MainActor.assumeIsolated {
-                model.reduceMotion = NSWorkspace.shared.accessibilityDisplayShouldReduceMotion
-            }
-        }
-    }
-
-    var isVisible: Bool { panel.isVisible }
-
-    /// Where the orb's card ends on screen, for the answer card to sit
-    /// under. Nil while hidden.
-    var contentFrame: NSRect? {
-        guard panel.isVisible else { return nil }
-        let h = min(Self.height, host.fittingSize.height)
-        return NSRect(x: panel.frame.minX, y: panel.frame.maxY - h, width: Self.width, height: h)
-    }
-
-    func show(_ phase: OrbModel.Phase, name: String, tint: NSColor, line: String, status: String) {
-        guard phase != .hidden else { hide(); return }
-        model.name = name
-        model.tint = tint
-        model.line = line
-        model.status = status
-        if model.phase != phase {
-            model.phase = phase
-            if phase != .listening { model.level = 0 }
-        }
-        watchLevel()
-        if !panel.isVisible {
-            position()
-            panel.orderFrontRegardless()
-        }
-    }
-
-    func hide() {
-        model.phase = .hidden
-        model.level = 0
-        watchLevel()
-        panel.orderOut(nil)
-    }
-
-    /// Top right, under the menu bar, where macOS puts Siri.
-    private func position() {
-        guard let screen = NSScreen.main else { return }
-        let v = screen.visibleFrame
-        panel.setFrameOrigin(NSPoint(x: v.maxX - Self.width - 16, y: v.maxY - Self.height - 10))
-    }
-
-    /// The microphone is read only while listening, on screen, with
-    /// motion allowed.
-    private func watchLevel() {
-        let wanted = model.phase == .listening && !model.reduceMotion && levelSource != nil
-        if !wanted { levelTimer?.invalidate(); levelTimer = nil; return }
-        guard levelTimer == nil else { return }
-        levelTimer = Timer.scheduledTimer(withTimeInterval: 1.0 / 20, repeats: true) { [weak self] _ in
-            MainActor.assumeIsolated {
-                guard let self, let read = self.levelSource else { return }
-                self.model.level = OrbMath.smooth(self.model.level, toward: OrbMath.level(fromRMS: read()))
-            }
-        }
-    }
-}