agentix-cli 0.57.0 → 0.59.0

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/ResultCard.swift

@@ -22,9 +22,8 @@ final class ResultCard: NSPanel {
     private let links = NSStackView()
     private let thumb = NSImageView()
 
-    /// The orb's frame on screen while it shows, for the card to slide in
-    /// under it. Nil: the card sits above the pill. Set by the app.
-    var anchor: (() -> NSRect?)?
+    /// The pill's frame on screen, which the card attaches to. Set by the app.
+    var anchor: (() -> NSRect)?
 
     init() {
         super.init(contentRect: NSRect(x: 0, y: 0, width: 380, height: 260),
@@ -129,19 +128,32 @@ final class ResultCard: NSPanel {
         }
 
         if let c = contentView { layout(c) }
-        if let orb = anchor?() {
-            slideIn(under: orb)
-        } else {
-            positionAboveWidget()
-            orderFrontRegardless()
-        }
+        slideIn()
+    }
+
+    /// Where the card goes against the pill: above it when there is at
+    /// least as much room above as below, else below; right edges aligned.
+    @MainActor
+    private func placement() -> PillPlacement.Card? {
+        guard let pill = anchor?() else { return nil }
+        let screen = NSScreen.screens.first { $0.frame.intersects(pill) } ?? NSScreen.main
+        guard let visible = screen?.visibleFrame else { return nil }
+        return PillPlacement.card(size: frame.size, pill: pill, visible: visible)
     }
 
-    /// Under the orb, right edges aligned, sliding down into place. With
-    /// Reduce Motion it simply appears there.
+    /// The pill moved: the open card moves with it, without animation.
     @MainActor
-    private func slideIn(under orb: NSRect) {
-        let target = NSPoint(x: orb.maxX - frame.width, y: orb.minY - frame.height - 8)
+    func follow() {
+        guard isVisible, let spot = placement() else { return }
+        setFrameOrigin(spot.origin)
+    }
+
+    /// Slides out of the pill into place: up when it opens above, down
+    /// when below. With Reduce Motion it simply appears there.
+    @MainActor
+    private func slideIn() {
+        guard let spot = placement() else { alphaValue = 1; orderFrontRegardless(); return }
+        let target = spot.origin
         let wasVisible = isVisible
         guard !wasVisible, !NSWorkspace.shared.accessibilityDisplayShouldReduceMotion else {
             setFrameOrigin(target)
@@ -149,7 +161,7 @@ final class ResultCard: NSPanel {
             orderFrontRegardless()
             return
         }
-        setFrameOrigin(NSPoint(x: target.x, y: target.y + 18))
+        setFrameOrigin(NSPoint(x: target.x, y: target.y + (spot.above ? -18 : 18)))
         alphaValue = 0
         orderFrontRegardless()
         NSAnimationContext.runAnimationGroup { ctx in
@@ -165,14 +177,6 @@ final class ResultCard: NSPanel {
         NSWorkspace.shared.open(u)
     }
 
-    /// Sits just above the pill so the two read as one thing.
-    private func positionAboveWidget() {
-        guard let screen = NSScreen.main else { return }
-        let v = screen.visibleFrame
-        setFrameOrigin(NSPoint(x: v.maxX - frame.width - 24, y: v.minY + 24 + 54 + 10))
-        alphaValue = 1
-    }
-
     override var canBecomeKey: Bool { true }
 }
 

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

@@ -365,7 +365,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,7 +382,7 @@ 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)
                 }
                 Section {

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

@@ -0,0 +1,92 @@
+import CoreML
+import Foundation
+
+/// Silero VAD on Core ML: how likely each 32 ms of 16 kHz audio is speech.
+///
+/// Core ML rather than ONNX Runtime: the model is 0.9 MB, macOS already
+/// ships the runtime, and the app keeps building with plain swiftc and no
+/// package dependency. The weights come from ModelStore.vad on first use.
+///
+/// Streaming: the model is an LSTM, so each call carries the previous
+/// call's state and the last 64 samples as context, exactly as Silero's
+/// own ONNX wrapper does. One `SileroVAD` per recording; the loaded model
+/// is shared.
+final class SileroVAD {
+    static let chunk = 512
+    static let context = 64
+    static let sampleRate = 16_000.0
+    static var frameDuration: TimeInterval { Double(chunk) / sampleRate }
+
+    private static let lock = NSLock()
+    nonisolated(unsafe) private static var cached: MLModel?
+
+    /// The shared model, loaded once. Nil when it is not installed or will
+    /// not load; the caller then falls back to the volume threshold.
+    static func loadModel() throws -> MLModel? {
+        lock.lock(); defer { lock.unlock() }
+        if let cached { return cached }
+        guard ModelStore.vad.isInstalled else { return nil }
+        let config = MLModelConfiguration()
+        // Tiny and called every 32 ms: the CPU answers faster than a trip
+        // to the Neural Engine.
+        config.computeUnits = .cpuOnly
+        let url = ModelStore.vad.url("silero-vad-unified-v6.0.0.mlmodelc")
+        let model = try MLModel(contentsOf: url, configuration: config)
+        cached = model
+        return model
+    }
+
+    private let model: MLModel
+    private let audio: MLMultiArray
+    private var hidden: MLMultiArray
+    private var cell: MLMultiArray
+    private var pending: [Float] = []
+    private var tail = [Float](repeating: 0, count: SileroVAD.context)
+
+    init(model: MLModel) throws {
+        self.model = model
+        audio = try MLMultiArray(shape: [1, NSNumber(value: Self.context + Self.chunk)], dataType: .float32)
+        hidden = try Self.zeros()
+        cell = try Self.zeros()
+    }
+
+    private static func zeros() throws -> MLMultiArray {
+        let a = try MLMultiArray(shape: [1, 128], dataType: .float32)
+        for i in 0..<a.count { a[i] = 0 }
+        return a
+    }
+
+    /// Feeds samples (16 kHz, -1…1) and returns one probability per
+    /// complete 512-sample frame; leftovers wait for the next call.
+    func process(_ samples: [Float]) throws -> [Float] {
+        pending.append(contentsOf: samples)
+        var out: [Float] = []
+        var start = 0
+        while pending.count - start >= Self.chunk {
+            let frame = pending[start..<start + Self.chunk]
+            out.append(try score(frame))
+            start += Self.chunk
+        }
+        pending.removeFirst(start)
+        return out
+    }
+
+    private func score(_ frame: ArraySlice<Float>) throws -> Float {
+        let ptr = audio.dataPointer.bindMemory(to: Float.self, capacity: audio.count)
+        for i in 0..<Self.context { ptr[i] = tail[i] }
+        var i = Self.context
+        for s in frame { ptr[i] = s; i += 1 }
+        tail = Array(frame.suffix(Self.context))
+
+        let input = try MLDictionaryFeatureProvider(dictionary: [
+            "audio_input": MLFeatureValue(multiArray: audio),
+            "hidden_state": MLFeatureValue(multiArray: hidden),
+            "cell_state": MLFeatureValue(multiArray: cell),
+        ])
+        let result = try model.prediction(from: input)
+        if let h = result.featureValue(for: "new_hidden_state")?.multiArrayValue { hidden = h }
+        if let c = result.featureValue(for: "new_cell_state")?.multiArrayValue { cell = c }
+        guard let p = result.featureValue(for: "vad_output")?.multiArrayValue, p.count > 0 else { return 0 }
+        return p[0].floatValue
+    }
+}

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

@@ -38,16 +38,18 @@ enum Speech {
     // MARK: Speech to text
 
     /// `engine` is agentx.json's `voice.stt`: "auto" and "elevenlabs" use
-    /// ElevenLabs when there is a key, falling back to mlx-whisper; "local"
-    /// never sends audio off the Mac.
-    static func transcribe(wav: Data, engine: String = "auto") async throws -> String {
+    /// ElevenLabs when there is a key, falling back to the local engine;
+    /// "local" never sends audio off the Mac. `local` is `voice.localStt`:
+    /// "mlx-whisper" or "parakeet".
+    static func transcribe(wav: Data, engine: String = "auto", local: String = "mlx-whisper") async throws -> String {
         if engine == "elevenlabs" && Config.elevenLabsKey == nil {
-            Log.warn("speech to text is set to ElevenLabs but no key is set; using mlx-whisper")
+            Log.warn("speech to text is set to ElevenLabs but no key is set; using \(local)")
         }
         if engine != "local", let key = Config.elevenLabsKey {
             do { return try await elevenLabsSTT(wav: wav, key: key) }
-            catch { Log.warn("ElevenLabs STT failed (\(error.localizedDescription)); falling back to mlx-whisper") }
+            catch { Log.warn("ElevenLabs STT failed (\(error.localizedDescription)); falling back to \(local)") }
         }
+        if local == "parakeet", let text = await LocalSTT.parakeet(wav: wav) { return text }
         return try await mlxWhisper(wav: wav)
     }
 

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

@@ -23,6 +23,8 @@ final class StatusMenu: NSObject, NSMenuDelegate {
     /// The daemon's speaking queue, polled while anything is in flight.
     private var queue: AgentClient.QueueState?
     private var queuePoll: Timer?
+    /// The last three voice exchanges, for a quick replay.
+    private let recent = RecentExchanges()
 
     /// Questions this widget has in flight, per agent. Set by the app.
     var thinking: [String: Int] = [:] {
@@ -34,7 +36,13 @@ final class StatusMenu: NSObject, NSMenuDelegate {
     var onHoldChanged: ((Bool) -> Void)?
     var onTargetChanged: ((String) -> Void)?
     var onPillChanged: ((Bool) -> Void)?
-    var onOrbChanged: ((Bool) -> Void)?
+    var onAnimatedOrbChanged: ((Bool) -> Void)?
+    /// Hide the pill and stop speech, as its close button does.
+    var onHidePill: (() -> Void)?
+    /// Put the pill back in the bottom-right corner.
+    var onResetPosition: (() -> Void)?
+    /// Whether the pill is on screen, for "Hide pill".
+    var pillVisible: () -> Bool = { false }
     var onSettings: (() -> Void)?
 
     override init() {
@@ -70,6 +78,7 @@ final class StatusMenu: NSObject, NSMenuDelegate {
             let agents = await AgentClient.agents()
             roster = agents.map { .loaded($0) } ?? .down
             queue = await AgentClient.queueState()
+            await recent.refresh()
             rebuild()
             showBadge()
             if reopenAfterRefresh { reopenAfterRefresh = false; open() }
@@ -169,6 +178,7 @@ final class StatusMenu: NSObject, NSMenuDelegate {
                 menu.addItem(row)
             }
         }
+        recent.addItems(to: menu, name: name(of:))
 
         menu.addItem(.separator())
         menu.addItem(action("Stop speaking", #selector(stop), key: ".", modifiers: [.command, .option]))
@@ -178,9 +188,13 @@ final class StatusMenu: NSObject, NSMenuDelegate {
         let pill = action("Show floating pill", #selector(togglePill), key: "")
         pill.state = Config.showPill ? .on : .off
         menu.addItem(pill)
-        let orb = action("Show orb", #selector(toggleOrb), key: "")
-        orb.state = Config.showOrb ? .on : .off
+        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)
+        menu.addItem(action("Reset position", #selector(resetPosition), key: ""))
 
         menu.addItem(.separator())
         menu.addItem(action("Settings…", #selector(openSettings), key: ","))
@@ -232,13 +246,16 @@ final class StatusMenu: NSObject, NSMenuDelegate {
     }
 
     @objc private func toggleOrb() {
-        Config.showOrb.toggle()
-        onOrbChanged?(Config.showOrb)
+        Config.animatedOrb.toggle()
+        onAnimatedOrbChanged?(Config.animatedOrb)
     }
 
+    @objc private func hidePill() { onHidePill?() }
+    @objc private func resetPosition() { onResetPosition?() }
+
     @objc private func openSettings() { onSettings?() }
     @objc private func openDashboardHome() { openDashboard("/admin") }
-    @objc private func openHistory() { openDashboard("/activity") }
+    @objc private func openHistory() { HistoryWindow.shared.show() }
 
     private func openDashboard(_ path: String) {
         guard let url = URL(string: Config.dashboardURL + path) else { return }

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

@@ -0,0 +1,110 @@
+import Foundation
+
+/// When a hands-free turn has ended: the person spoke, then stopped for
+/// long enough that the sentence is over.
+///
+/// It is fed one audio frame at a time with how likely that frame is to be
+/// speech (0…1) and how long it lasted. Two sources feed it:
+///
+/// - Silero VAD, 32 ms frames with a real probability. A voice model
+///   tells a word from a fan, a keyboard or a café, so the noise of a room
+///   neither holds the microphone open nor counts as talking.
+/// - The old volume check when the VAD model is not available: 1 above
+///   `speechLevel`, 0 below, per audio buffer.
+///
+/// Foundation only and time passed in, so the tests can drive it with
+/// synthetic frames.
+struct TurnEnd {
+    struct Tuning: Equatable {
+        /// A frame at or above this starts speech (Silero's own default).
+        var start: Float
+        /// Once talking, a frame at or above this still counts as speech.
+        /// Lower than `start`: the soft end of a word is not a pause.
+        var keep: Float
+        /// Speech must last this long in one go before the turn counts as
+        /// started, so a cough, a door or a click does not open it.
+        var minSpeech: TimeInterval
+        /// A burst this short inside a pause does not restart the pause:
+        /// one noisy frame must not hold the microphone open.
+        var resume: TimeInterval
+        /// A pause this long after speech ends the turn. People pause
+        /// inside sentences; this is longer than those pauses.
+        var endSilence: TimeInterval
+
+        /// For Silero VAD probabilities.
+        static let vad = Tuning(start: 0.5, keep: 0.35, minSpeech: 0.25, resume: 0.1, endSilence: 1.2)
+
+        /// The volume threshold as it always worked: any buffer above the
+        /// level is speech, and 1.2 s below it ends the turn.
+        static let level = Tuning(start: 0.5, keep: 0.5, minSpeech: 0, resume: 0, endSilence: 1.2)
+    }
+
+    enum State: Equatable {
+        /// Nothing said yet.
+        case waiting
+        /// Speech heard; the turn is open (possibly in a short pause).
+        case speaking
+        /// Speech, then `endSilence` of quiet: send it.
+        case ended
+    }
+
+    /// RMS above which the microphone is hearing a voice rather than a
+    /// room. The fallback's whole notion of speech.
+    static let speechLevel: Float = 0.02
+
+    let tuning: Tuning
+    private(set) var state: State = .waiting
+    /// How long the current run of speech frames has lasted.
+    private var speechRun: TimeInterval = 0
+    /// How long the current pause has lasted (a short burst does not
+    /// reset it).
+    private var silence: TimeInterval = 0
+
+    init(_ tuning: Tuning) { self.tuning = tuning }
+
+    /// One frame: `probability` that it is speech, `duration` it covers.
+    @discardableResult
+    mutating func feed(probability: Float, duration: TimeInterval) -> State {
+        guard state != .ended else { return state }
+        let threshold = state == .speaking && silence == 0 ? tuning.keep : tuning.start
+        let speech = probability >= threshold
+
+        switch state {
+        case .waiting:
+            speechRun = speech ? speechRun + duration : 0
+            if speech && speechRun >= tuning.minSpeech {
+                state = .speaking
+                silence = 0
+            }
+        case .speaking:
+            if speech {
+                speechRun += duration
+                if silence == 0 || speechRun >= tuning.resume {
+                    silence = 0
+                } else {
+                    silence += duration
+                }
+            } else {
+                speechRun = 0
+                silence += duration
+            }
+            if silence >= tuning.endSilence { state = .ended }
+        case .ended:
+            break
+        }
+        return state
+    }
+
+    /// The fallback's frame: the smoothed microphone level.
+    @discardableResult
+    mutating func feed(level: Float, duration: TimeInterval) -> State {
+        feed(probability: level > Self.speechLevel ? 1 : 0, duration: duration)
+    }
+
+    /// The microphone level after one buffer of loudness `rms`. Attack
+    /// fast, release slow: a level that drops instantly makes a pause
+    /// between words look like the end of a sentence.
+    static func smooth(level: Float, rms: Float) -> Float {
+        rms > level ? rms : level * 0.82 + rms * 0.18
+    }
+}

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

@@ -12,7 +12,28 @@ struct VoiceSettings: Codable, Equatable {
         var provider: String
         var fallback: String
         var stt: String
+        /// The on-device engine: "mlx-whisper" or "parakeet".
+        var localStt: String
+        /// How a hands-free turn's end is heard: "vad" or "volume".
+        var endOfTurn: String
         var hotkeys: Hotkeys
+
+        init(provider: String, fallback: String, stt: String, localStt: String = "mlx-whisper",
+             endOfTurn: String = "vad", hotkeys: Hotkeys) {
+            self.provider = provider; self.fallback = fallback; self.stt = stt
+            self.localStt = localStt; self.endOfTurn = endOfTurn; self.hotkeys = hotkeys
+        }
+
+        /// A daemon from before these fields leaves them out: the defaults.
+        init(from decoder: Decoder) throws {
+            let c = try decoder.container(keyedBy: CodingKeys.self)
+            provider = try c.decode(String.self, forKey: .provider)
+            fallback = try c.decode(String.self, forKey: .fallback)
+            stt = try c.decode(String.self, forKey: .stt)
+            localStt = try c.decodeIfPresent(String.self, forKey: .localStt) ?? "mlx-whisper"
+            endOfTurn = try c.decodeIfPresent(String.self, forKey: .endOfTurn) ?? "vad"
+            hotkeys = try c.decode(Hotkeys.self, forKey: .hotkeys)
+        }
     }
     struct Voice: Codable, Equatable {
         var provider: String?
@@ -55,6 +76,8 @@ struct VoiceSettings: Codable, Equatable {
         var general: [String: Any] = [:]
         if self.general.provider != old.general.provider { general["provider"] = self.general.provider }
         if self.general.stt != old.general.stt { general["stt"] = self.general.stt }
+        if self.general.localStt != old.general.localStt { general["localStt"] = self.general.localStt }
+        if self.general.endOfTurn != old.general.endOfTurn { general["endOfTurn"] = self.general.endOfTurn }
         var keys: [String: Any] = [:]
         if self.general.hotkeys.talk != old.general.hotkeys.talk { keys["talk"] = self.general.hotkeys.talk }
         if self.general.hotkeys.stop != old.general.hotkeys.stop { keys["stop"] = self.general.hotkeys.stop }