agentix-cli 0.58.0 → 0.60.0

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

@@ -0,0 +1,264 @@
+import CoreML
+import Foundation
+
+/// NVIDIA Parakeet TDT 0.6B v3 on Core ML: on-device speech to text with
+/// no Python, from the model files ModelStore.parakeet fetches.
+///
+/// Four Core ML models, run in turn: the preprocessor turns 15 s of audio
+/// into a mel spectrogram, the encoder turns that into one vector per
+/// 80 ms, and the decoder (an LSTM over the words so far) and the joint
+/// network walk those vectors greedily. The joint picks a token and how
+/// many frames to skip (the "TDT" part), which is why it is fast.
+///
+/// v3 covers 25 European languages and detects which one on its own. It
+/// has NO Arabic; see the benchmark in docs/dashboard/voice.md.
+final class Parakeet: @unchecked Sendable {
+    enum ParakeetError: LocalizedError {
+        case notInstalled
+        case badOutput(String)
+        var errorDescription: String? {
+            switch self {
+            case .notInstalled: return "the Parakeet model is not downloaded yet"
+            case .badOutput(let what): return "Parakeet returned no \(what)"
+            }
+        }
+    }
+
+    static let sampleRate = 16_000
+    /// The Core ML export takes exactly 15 s.
+    static let window = 240_000
+    /// One encoder frame covers 80 ms.
+    static let samplesPerFrame = 1_280
+    static let blank = 8_192
+    static let durations = [0, 1, 2, 3, 4]
+    static let maxSymbolsPerFrame = 10
+
+    private let preprocessor: MLModel
+    private let encoder: MLModel
+    private let decoder: MLModel
+    private let joint: MLModel
+    private let vocabulary: [Int: String]
+
+    private static let lock = NSLock()
+    nonisolated(unsafe) private static var shared: Parakeet?
+
+    /// The loaded engine, kept for the life of the app: loading costs
+    /// seconds (Core ML prepares the encoder for the Neural Engine), a
+    /// transcription well under one.
+    static func loaded() throws -> Parakeet {
+        lock.lock(); defer { lock.unlock() }
+        if let shared { return shared }
+        let p = try Parakeet()
+        shared = p
+        return p
+    }
+
+    init() throws {
+        let store = ModelStore.parakeet
+        guard store.isInstalled else { throw ParakeetError.notInstalled }
+        func load(_ name: String, _ units: MLComputeUnits) throws -> MLModel {
+            let config = MLModelConfiguration()
+            config.computeUnits = units
+            return try MLModel(contentsOf: store.url(name), configuration: config)
+        }
+        // The same placement FluidAudio uses: the mel front end on the CPU,
+        // the rest wherever Core ML runs it best (the Neural Engine).
+        preprocessor = try load("Preprocessor.mlmodelc", .cpuOnly)
+        encoder = try load("Encoder.mlmodelc", .cpuAndNeuralEngine)
+        decoder = try load("Decoder.mlmodelc", .cpuAndNeuralEngine)
+        joint = try load("JointDecisionv3.mlmodelc", .cpuAndNeuralEngine)
+
+        let data = try Data(contentsOf: store.url("parakeet_vocab.json"))
+        let raw = try JSONSerialization.jsonObject(with: data) as? [String: String] ?? [:]
+        var vocab: [Int: String] = [:]
+        for (k, v) in raw { if let id = Int(k) { vocab[id] = v } }
+        vocabulary = vocab
+    }
+
+    /// A 16 kHz mono 16-bit WAV, as Recorder makes.
+    func transcribe(wav: Data) throws -> String {
+        try transcribe(samples: Self.samples(wav: wav))
+    }
+
+    func transcribe(samples: [Float]) throws -> String {
+        var tokens: [Int] = []
+        var state = try DecoderState(decoder: decoder)
+        for range in Self.windows(samples) {
+            tokens += try decode(Array(samples[range]), state: &state)
+        }
+        return Self.text(tokens, vocabulary: vocabulary)
+    }
+
+    // MARK: Pure helpers (tested)
+
+    /// Samples of a 16-bit PCM WAV as -1…1, found by its "data" chunk.
+    static func samples(wav: Data) -> [Float] {
+        let bytes = [UInt8](wav)
+        var offset = 12
+        while offset + 8 <= bytes.count {
+            let id = String(decoding: bytes[offset..<offset + 4], as: UTF8.self)
+            let size = Int(UInt32(bytes[offset + 4]) | UInt32(bytes[offset + 5]) << 8
+                | UInt32(bytes[offset + 6]) << 16 | UInt32(bytes[offset + 7]) << 24)
+            let body = offset + 8
+            if id == "data" {
+                let end = min(bytes.count, body + size)
+                var out = [Float]()
+                out.reserveCapacity((end - body) / 2)
+                var i = body
+                while i + 1 < end {
+                    out.append(Float(Int16(bitPattern: UInt16(bytes[i]) | UInt16(bytes[i + 1]) << 8)) / 32768)
+                    i += 2
+                }
+                return out
+            }
+            offset = body + size + (size & 1)
+        }
+        return []
+    }
+
+    /// Splits audio longer than the 15 s window, each cut at the quietest
+    /// 20 ms of the window's last 3 s, so a cut rarely lands in a word.
+    static func windows(_ samples: [Float], window: Int = Parakeet.window) -> [Range<Int>] {
+        var out: [Range<Int>] = []
+        var start = 0
+        let step = sampleRate / 50
+        while samples.count - start > window {
+            let searchFrom = start + window - 3 * sampleRate
+            var best = start + window, bestEnergy = Float.greatestFiniteMagnitude
+            var at = searchFrom
+            while at + step <= start + window {
+                var e: Float = 0
+                for i in at..<at + step { e += samples[i] * samples[i] }
+                if e < bestEnergy { bestEnergy = e; best = at + step / 2 }
+                at += step
+            }
+            out.append(start..<best)
+            start = best
+        }
+        if start < samples.count { out.append(start..<samples.count) }
+        return out
+    }
+
+    /// SentencePiece pieces to text: "▁" marks the start of a word.
+    static func text(_ tokens: [Int], vocabulary: [Int: String]) -> String {
+        var s = ""
+        for t in tokens {
+            guard let piece = vocabulary[t], !(piece.hasPrefix("<") && piece.hasSuffix(">")) else { continue }
+            s += piece.replacingOccurrences(of: "\u{2581}", with: " ")
+        }
+        return s.trimmingCharacters(in: .whitespacesAndNewlines)
+    }
+
+    // MARK: Inference
+
+    private struct DecoderState {
+        var hidden: MLMultiArray
+        var cell: MLMultiArray
+        /// The decoder's output for the last token emitted (blank at first).
+        var output: MLMultiArray?
+        let target: MLMultiArray
+        let targetLength: MLMultiArray
+
+        init(decoder: MLModel) throws {
+            hidden = try MLMultiArray(shape: [2, 1, 640], dataType: .float32)
+            cell = try MLMultiArray(shape: [2, 1, 640], dataType: .float32)
+            for i in 0..<hidden.count { hidden[i] = 0; cell[i] = 0 }
+            target = try MLMultiArray(shape: [1, 1], dataType: .int32)
+            targetLength = try MLMultiArray(shape: [1], dataType: .int32)
+            targetLength[0] = 1
+        }
+    }
+
+    private func step(_ token: Int, _ state: inout DecoderState) throws {
+        state.target[0] = NSNumber(value: token)
+        let out = try decoder.prediction(from: MLDictionaryFeatureProvider(dictionary: [
+            "targets": MLFeatureValue(multiArray: state.target),
+            "target_length": MLFeatureValue(multiArray: state.targetLength),
+            "h_in": MLFeatureValue(multiArray: state.hidden),
+            "c_in": MLFeatureValue(multiArray: state.cell),
+        ]))
+        guard let d = out.featureValue(for: "decoder")?.multiArrayValue,
+              let h = out.featureValue(for: "h_out")?.multiArrayValue,
+              let c = out.featureValue(for: "c_out")?.multiArrayValue else { throw ParakeetError.badOutput("decoder state") }
+        state.output = d; state.hidden = h; state.cell = c
+    }
+
+    /// One window: preprocessor, encoder, then greedy TDT decoding.
+    private func decode(_ chunk: [Float], state: inout DecoderState) throws -> [Int] {
+        guard chunk.count >= Self.samplesPerFrame else { return [] }
+        let audio = try MLMultiArray(shape: [1, NSNumber(value: Self.window)], dataType: .float32)
+        let ptr = audio.dataPointer.bindMemory(to: Float.self, capacity: Self.window)
+        ptr.initialize(repeating: 0, count: Self.window)
+        chunk.withUnsafeBufferPointer { src in ptr.update(from: src.baseAddress!, count: min(chunk.count, Self.window)) }
+        let length = try MLMultiArray(shape: [1], dataType: .int32)
+        length[0] = NSNumber(value: chunk.count)
+
+        let mel = try preprocessor.prediction(from: MLDictionaryFeatureProvider(dictionary: [
+            "audio_signal": MLFeatureValue(multiArray: audio),
+            "audio_length": MLFeatureValue(multiArray: length),
+        ]))
+        guard let melArray = mel.featureValue(for: "mel")?.multiArrayValue,
+              let melLength = mel.featureValue(for: "mel_length")?.multiArrayValue else { throw ParakeetError.badOutput("mel") }
+        let enc = try encoder.prediction(from: MLDictionaryFeatureProvider(dictionary: [
+            "mel": MLFeatureValue(multiArray: melArray),
+            "mel_length": MLFeatureValue(multiArray: melLength),
+        ]))
+        guard let frames = enc.featureValue(for: "encoder")?.multiArrayValue,
+              let encLength = enc.featureValue(for: "encoder_length")?.multiArrayValue else { throw ParakeetError.badOutput("encoder output") }
+
+        let hiddenSize = frames.shape[1].intValue
+        let available = frames.shape[2].intValue
+        let actual = (chunk.count + Self.samplesPerFrame - 1) / Self.samplesPerFrame
+        let count = min(encLength[0].intValue, available, actual)
+        let hStride = frames.strides[1].intValue, tStride = frames.strides[2].intValue
+
+        let encStep = try MLMultiArray(shape: [1, NSNumber(value: hiddenSize), 1], dataType: .float32)
+        let encStride = encStep.strides[1].intValue
+        let encDest = encStep.dataPointer.bindMemory(to: Float.self, capacity: encStep.count)
+        func load(frame t: Int) {
+            switch frames.dataType {
+            case .float16:
+                let src = frames.dataPointer.bindMemory(to: Float16.self, capacity: frames.count)
+                for h in 0..<hiddenSize { encDest[h * encStride] = Float(src[h * hStride + t * tStride]) }
+            default:
+                let src = frames.dataPointer.bindMemory(to: Float.self, capacity: frames.count)
+                for h in 0..<hiddenSize { encDest[h * encStride] = src[h * hStride + t * tStride] }
+            }
+        }
+
+        if state.output == nil { try step(Self.blank, &state) }
+        var tokens: [Int] = []
+        var t = 0
+        var symbolsHere = 0
+        var loaded = -1
+        while t < count {
+            if loaded != t { load(frame: t); loaded = t }
+            guard let decoderOut = state.output else { throw ParakeetError.badOutput("decoder output") }
+            let out = try joint.prediction(from: MLDictionaryFeatureProvider(dictionary: [
+                "encoder_step": MLFeatureValue(multiArray: encStep),
+                "decoder_step": MLFeatureValue(multiArray: decoderOut),
+            ]))
+            guard let tokenArray = out.featureValue(for: "token_id")?.multiArrayValue,
+                  let durArray = out.featureValue(for: "duration")?.multiArrayValue else { throw ParakeetError.badOutput("joint decision") }
+            let token = tokenArray[0].intValue
+            let bin = durArray[0].intValue
+            let duration = Self.durations.indices.contains(bin) ? Self.durations[bin] : 1
+
+            if token == Self.blank {
+                t += max(duration, 1)
+                symbolsHere = 0
+                continue
+            }
+            tokens.append(token)
+            try step(token, &state)
+            if duration > 0 {
+                t += duration
+                symbolsHere = 0
+            } else {
+                symbolsHere += 1
+                if symbolsHere >= Self.maxSymbolsPerFrame { t += 1; symbolsHere = 0 }
+            }
+        }
+        return tokens
+    }
+}

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

@@ -1,13 +1,11 @@
 import CoreGraphics
 
-/// Where the pill and its answer card go on screen, kept free of AppKit so
+/// Where the pill goes on screen, and how it grows into its answer, kept free of AppKit so
 /// the tests can check it without a window. Frames are in screen
 /// coordinates, origin bottom-left, as AppKit uses them.
 enum PillPlacement {
     /// Distance from the screen's edges for the default corner.
     static let inset: CGFloat = 24
-    /// Space between the pill and the answer card.
-    static let cardGap: CGFloat = 8
 
     /// Bottom-right of `visible` (a screen's frame minus the menu bar and
     /// Dock), clear of both.
@@ -38,23 +36,36 @@ enum PillPlacement {
         return inside(frame, screen).origin
     }
 
-    /// Which side of the pill the answer card opens on, and where.
-    struct Card: Equatable {
-        let origin: CGPoint
-        /// True: above the pill. False: below it.
+    /// The pill grown into its answer: where the whole widget goes, and
+    /// which way it grew.
+    struct Expanded: Equatable {
+        let frame: CGRect
+        /// True: the answer opens above the pill's row. False: below it.
         let above: Bool
+        /// True: right edges line up with the pill's. False: left edges.
+        let alignRight: Bool
     }
 
-    /// Above the pill when there is at least as much room above it as
-    /// below, else below. Right edges line up with the pill's, and the
-    /// card is kept on the screen.
-    static func card(size: CGSize, pill: CGRect, visible: CGRect) -> Card {
-        let roomAbove = visible.maxY - pill.maxY
-        let roomBelow = pill.minY - visible.minY
-        let above = roomAbove >= roomBelow
-        let y = above ? pill.maxY + cardGap : pill.minY - cardGap - size.height
-        let frame = CGRect(x: pill.maxX - size.width, y: y, width: size.width, height: size.height)
-        return Card(origin: inside(frame, visible).origin, above: above)
+    /// The pill at `pill` grown to `size`. It grows up when there is at
+    /// least as much room above the pill as below, else down, so its row
+    /// stays where it was. It grows leftwards, keeping the right edge,
+    /// unless that would leave the screen. Too tall for the screen: kept
+    /// on it, top-left in view.
+    static func expanded(size: CGSize, pill: CGRect, visible: CGRect) -> Expanded {
+        let above = visible.maxY - pill.maxY >= pill.minY - visible.minY
+        let alignRight = pill.maxX - size.width >= visible.minX
+        let frame = CGRect(x: alignRight ? pill.maxX - size.width : pill.minX,
+                           y: above ? pill.minY : pill.maxY - size.height,
+                           width: size.width, height: size.height)
+        return Expanded(frame: inside(frame, visible), above: above, alignRight: alignRight)
+    }
+
+    /// Where the pill goes back to when the widget at `frame` collapses:
+    /// its row's end on the side it grew from.
+    static func collapsed(from frame: CGRect, size: CGSize, above: Bool, alignRight: Bool) -> CGRect {
+        CGRect(x: alignRight ? frame.maxX - size.width : frame.minX,
+               y: above ? frame.minY : frame.maxY - size.height,
+               width: size.width, height: size.height)
     }
 
     /// `frame` moved the least distance that puts it inside `bounds`. A

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

@@ -29,6 +29,28 @@ final class Recorder {
     /// between two adjacent 100ms windows — which changes nothing.
     private(set) var level: Float = 0
 
+    /// How a hands-free turn's end is heard: "vad" (Silero VAD, once its
+    /// model is downloaded; the volume threshold until then) or "volume",
+    /// from agentx.json's `voice.endOfTurn`. Push-to-talk sets "hold": its
+    /// turn ends on key release, so no detector runs. Set before `start()`.
+    var endOfTurn = "vad"
+    /// True while this recording's turn is judged by Silero VAD.
+    private(set) var usingVAD = false
+    private var vad: SileroVAD?
+    private var turn = TurnEnd(.level)
+    private let turnLock = NSLock()
+    /// Bumped by every start, so VAD work queued for an earlier recording
+    /// never lands in this one.
+    private var generation = 0
+    private let vadQueue = DispatchQueue(label: "tn.acme.agentx.voice.vad")
+
+    /// Where the hands-free turn stands: nothing said, talking (a pause
+    /// included), or over. Read from the main thread.
+    var turnState: TurnEnd.State {
+        turnLock.lock(); defer { turnLock.unlock() }
+        return turn.state
+    }
+
     /// 16 kHz mono int16 — the format both ElevenLabs and whisper prefer,
     /// and small enough that a 30-second utterance is under 1 MB.
     private let target = AVAudioFormat(
@@ -58,6 +80,7 @@ final class Recorder {
         level = 0
         guard !isRecording else { return }
         lock.lock(); pcm.removeAll(keepingCapacity: true); lock.unlock()
+        prepareTurn()
 
         let input = engine.inputNode
         let inputFormat = input.inputFormat(forBus: 0)
@@ -110,9 +133,8 @@ final class Recorder {
             sum += sample * sample
         }
         let rms = (sum / Float(max(Int(out.frameLength), 1))).squareRoot()
-        // Attack fast, release slow: a level that drops instantly makes a
-        // pause between words look like the end of a sentence.
-        level = rms > level ? rms : level * 0.82 + rms * 0.18
+        level = TurnEnd.smooth(level: level, rms: rms)
+        hearTurn(channel, count: Int(out.frameLength))
 
         let bytes = Int(out.frameLength) * MemoryLayout<Int16>.size
         lock.lock()
@@ -122,6 +144,62 @@ final class Recorder {
         lock.unlock()
     }
 
+    /// A fresh turn for a new recording, judged by Silero VAD when its
+    /// model is installed and loads; otherwise by the volume threshold,
+    /// with the model downloading in the background for next time.
+    private func prepareTurn() {
+        var detector: SileroVAD?
+        // Only a hands-free turn listens for its own end; push-to-talk ("hold")
+        // ends on key release, so it never loads or runs the model.
+        if endOfTurn == "vad" {
+            do {
+                if let model = try SileroVAD.loadModel() {
+                    detector = try SileroVAD(model: model)
+                } else {
+                    ModelStore.installInBackground(ModelStore.vad) { Log.info($0) }
+                }
+            } catch {
+                Log.warn("Silero VAD would not load (\(error.localizedDescription)); using the volume threshold")
+            }
+        }
+        turnLock.lock()
+        generation += 1
+        vad = detector
+        usingVAD = detector != nil
+        turn = TurnEnd(detector != nil ? .vad : .level)
+        turnLock.unlock()
+    }
+
+    /// One converted buffer: to the VAD off the audio thread, or straight
+    /// to the volume check.
+    private func hearTurn(_ channel: UnsafePointer<Int16>, count: Int) {
+        turnLock.lock()
+        let detector = vad, gen = generation
+        if detector == nil {
+            turn.feed(level: level, duration: Double(count) / target.sampleRate)
+        }
+        turnLock.unlock()
+        guard let detector else { return }
+        var samples = [Float](repeating: 0, count: count)
+        for i in 0..<count { samples[i] = Float(channel[i]) / 32768.0 }
+        vadQueue.async { [weak self] in
+            guard let self else { return }
+            let probabilities: [Float]
+            do { probabilities = try detector.process(samples) } catch {
+                Log.warn("Silero VAD failed (\(error.localizedDescription)); using the volume threshold")
+                self.turnLock.lock()
+                if self.generation == gen { self.vad = nil; self.usingVAD = false; self.turn = TurnEnd(.level) }
+                self.turnLock.unlock()
+                return
+            }
+            self.turnLock.lock()
+            if self.generation == gen {
+                for p in probabilities { self.turn.feed(probability: p, duration: SileroVAD.frameDuration) }
+            }
+            self.turnLock.unlock()
+        }
+    }
+
     /// Minimal RIFF/WAVE header for 16-bit mono PCM.
     private func wav(_ body: Data) -> Data {
         let rate = UInt32(target.sampleRate), channels: UInt16 = 1, bits: UInt16 = 16

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

@@ -0,0 +1,90 @@
+import AppKit
+import SwiftUI
+
+/// The settings window's look controls (#211): each agent's orb palette,
+/// and how long and how tall the answer in the pill is. Both are saved in
+/// agentx.json through the daemon, like everything else in the window.
+
+/// A palette as a small gradient disc, for menus that only show images.
+enum PaletteSwatch {
+    static func image(_ hexes: [String], size: CGFloat = 14) -> NSImage {
+        let colors = hexes.compactMap(OrbMath.parseHex).map { NSColor(srgbRed: $0.r, green: $0.g, blue: $0.b, alpha: 1) }
+        return NSImage(size: NSSize(width: size, height: size), flipped: false) { rect in
+            let disc = NSBezierPath(ovalIn: rect.insetBy(dx: 0.5, dy: 0.5))
+            NSGradient(colors: colors.isEmpty ? [.gray] : colors)?.draw(in: disc, angle: -45)
+            NSColor.separatorColor.setStroke()
+            disc.lineWidth = 0.5
+            disc.stroke()
+            return true
+        }
+    }
+}
+
+/// "Orb palette": one of the nature palettes, or the one nearest the
+/// agent's colour.
+struct PalettePicker: View {
+    @Binding var agent: VoiceSettings.Agent
+    let palettes: [VoiceSettings.Palette]
+
+    private func palette(_ id: String?) -> VoiceSettings.Palette? { palettes.first { $0.id == id } }
+
+    var body: some View {
+        let shown = palette(agent.palette ?? agent.paletteDefault)
+        HStack {
+            Picker("Orb palette", selection: $agent.palette) {
+                if let fallback = palette(agent.paletteDefault) {
+                    Label { Text("Match the colour: \(fallback.label)") } icon: { Image(nsImage: PaletteSwatch.image(fallback.colors)) }
+                        .tag(String?.none)
+                } else {
+                    Text("Match the colour").tag(String?.none)
+                }
+                Divider()
+                ForEach(palettes) { p in
+                    Label { Text(p.label) } icon: { Image(nsImage: PaletteSwatch.image(p.colors)) }
+                        .tag(String?.some(p.id))
+                }
+            }
+            if let shown {
+                Image(nsImage: PaletteSwatch.image(shown.colors, size: 20))
+                    .accessibilityHidden(true)
+            }
+        }
+    }
+}
+
+/// "Answer in the pill": how long it stays open once spoken, and how tall
+/// it grows before it scrolls.
+struct AnswerCardSection: View {
+    @Binding var card: VoiceSettings.Card
+
+    /// The usual choices, plus whatever agentx.json already says.
+    private var timeouts: [Double] {
+        let usual: [Double] = [10, 20, 30, 60, 120, 300]
+        return usual.contains(card.timeout) || card.timeout == 0 ? usual : (usual + [card.timeout]).sorted()
+    }
+
+    private static func label(_ s: Double) -> String {
+        if s < 60 || s.truncatingRemainder(dividingBy: 60) != 0 { return "\(Int(s)) seconds" }
+        return s == 60 ? "1 minute" : "\(Int(s / 60)) minutes"
+    }
+
+    var body: some View {
+        Section {
+            Picker("Keep the answer open", selection: $card.timeout) {
+                ForEach(timeouts, id: \.self) { s in
+                    Text(Self.label(s)).tag(s)
+                }
+                Divider()
+                Text("Until I close it").tag(0.0)
+            }
+            Stepper(value: $card.maxHeight, in: 120...800, step: 40) {
+                LabeledContent("Tallest answer", value: "\(Int(card.maxHeight)) points")
+            }
+        } header: {
+            Text("Answer in the pill")
+        } footer: {
+            Text("When an answer has a link, a picture or more to read than was spoken, the pill grows to show it. It closes this long after the answer has been spoken, but not while the pointer is over it. A longer answer scrolls.")
+                .font(.caption).foregroundStyle(.secondary)
+        }
+    }
+}

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

@@ -326,16 +326,19 @@ private struct AgentForm: View {
             get: { Color(hex: agent.color) },
             set: { agent.color = $0.hex; agent.colorSet = true })
         let footer = agent.colorSet
-            ? "Hold the shortcut and speak to ask this agent without changing who is ticked in the menu. The colour also paints this agent's pointer."
-            : "Hold the shortcut and speak to ask this agent without changing who is ticked in the menu. The colour comes from the agent's id until you pick one."
+            ? "Hold the shortcut and speak to ask this agent without changing who is ticked in the menu. The colour also paints this agent's pointer, and picks the orb's palette unless you choose one."
+            : "Hold the shortcut and speak to ask this agent without changing who is ticked in the menu. The colour comes from the agent's id until you pick one, and picks the orb's palette unless you choose one."
         return Section {
             HotkeyField(title: "Ask with shortcut", value: $agent.voice.hotkey, optional: true, model: model, id: "agent.\(agent.id)")
             HStack {
                 ColorPicker("Orb colour", selection: color, supportsOpacity: false)
                 Button("Use default") { agent.colorSet = false }.disabled(!agent.colorSet)
             }
+            if let palettes = settings.palettes, !palettes.isEmpty {
+                PalettePicker(agent: $agent, palettes: palettes)
+            }
         } header: {
-            Text("Shortcut and colour")
+            Text("Shortcut and look")
         } footer: {
             Text(footer).font(.caption).foregroundStyle(.secondary)
         }
@@ -365,7 +368,15 @@ private struct GeneralTab: View {
                     Picker("Speech to text", selection: binding(\.stt)) {
                         Text("Automatic").tag("auto")
                         Text("ElevenLabs").tag("elevenlabs")
-                        Text("On this Mac (Whisper)").tag("local")
+                        Text("On this Mac").tag("local")
+                    }
+                    Picker("On-this-Mac engine", selection: binding(\.localStt)) {
+                        Text("Whisper (mlx-whisper)").tag("mlx-whisper")
+                        Text("Parakeet (downloads 483 MB)").tag("parakeet")
+                    }
+                    Picker("End of a hands-free turn", selection: binding(\.endOfTurn)) {
+                        Text("Voice detection (Silero)").tag("vad")
+                        Text("Volume").tag("volume")
                     }
                     Picker("Default voice provider", selection: binding(\.provider)) {
                         Text("Mac voices (free)").tag("system")
@@ -374,9 +385,13 @@ private struct GeneralTab: View {
                 } header: {
                     Text("Speech")
                 } footer: {
-                    Text("Automatic uses ElevenLabs when a key is set, and Whisper on this Mac otherwise. The default provider is for agents that don't choose their own. Both apply to the next question.")
+                    Text("Automatic uses ElevenLabs when a key is set, and the engine on this Mac otherwise. Parakeet has no Arabic; until its model has downloaded, Whisper answers instead. Voice detection ends a turn when you stop talking, not when the room goes quiet. The default provider is for agents that don't choose their own. All apply to the next question.")
                         .font(.caption).foregroundStyle(.secondary)
                 }
+                if draft.general.card != nil {
+                    AnswerCardSection(card: Binding(get: { model.draft?.general.card ?? .standard },
+                                                    set: { model.draft?.general.card = $0 }))
+                }
                 Section {
                     Toggle("Launch at login", isOn: Binding(get: { model.launchAtLogin }, set: { model.setLaunchAtLogin($0) }))
                         .disabled(LoginItem.managedByInstaller)