Zerm 2.1.2: fix recording drops, stuck state, and terminal text selection (#244)

Three user-reported issues:

1. Long recordings dropped mid-dictation with no warning.
   The silence auto-stop window was 1.1s — short enough that a normal
   thinking pause in long-form speech tripped it and cut the recording.
   Raised the default to 2.5s, which tolerates natural pauses while still
   stopping promptly when the user is done.

2. After a drop, the app reported the recording was "already running" and
   required mashing the hotkey before dictation worked again.
   When the audio unit dies mid-recording (device unplugged, render error),
   CoreAudio's input callback stops firing while the engine still believes
   it is recording: the capture is silently lost and the state machine gets
   stuck. CoreAudioRecorder now exposes the time since the last input
   callback, and the recording monitor runs a dropped-capture watchdog
   (always, regardless of the auto-stop setting): if no audio arrives for
   3s after the unit was delivering, it notifies the user, transcribes
   whatever was captured before the drop, and returns cleanly to idle so
   the next press starts fresh.

3. "No text selected" when reading/handling highlighted text in terminal
   and TUI apps (e.g. Claude Code, cmux), breaking Read-Aloud-Selected-Text.
   Terminals render text in custom views that expose neither AXSelectedText
   (.accessibility) nor a standard Edit > Copy item (.menuAction). Added the
   .shortcut strategy (simulated Cmd+C + pasteboard read, auto-restored) as
   a final fallback, which terminals handle reliably.

Co-authored-by: thefourCraft <thefourCraft@users.noreply.github.com>

Author: thefourcraft

Zerm.xcodeproj/project.pbxproj

@@ -496,7 +496,7 @@
 				"CODE_SIGN_IDENTITY[sdk=macosx*]" = "Apple Development";
 				CODE_SIGN_STYLE = Automatic;
 				COMBINE_HIDPI_IMAGES = YES;
-				CURRENT_PROJECT_VERSION = 211;
+				CURRENT_PROJECT_VERSION = 212;
 				DEVELOPMENT_ASSET_PATHS = "\"Zerm/Preview Content\"";
 				DEVELOPMENT_TEAM = V6J6A3VWY2;
 				ENABLE_HARDENED_RUNTIME = YES;
@@ -511,7 +511,7 @@
 					"@executable_path/../Frameworks",
 				);
 				MACOSX_DEPLOYMENT_TARGET = 14.4;
-				MARKETING_VERSION = 2.1.1;
+				MARKETING_VERSION = 2.1.2;
 				PRODUCT_BUNDLE_IDENTIFIER = com.arcusis.zerm;
 				PRODUCT_NAME = "$(TARGET_NAME)";
 				SWIFT_ACTIVE_COMPILATION_CONDITIONS = "DEBUG ENABLE_NATIVE_SPEECH_ANALYZER $(inherited)";
@@ -537,7 +537,7 @@
 				"CODE_SIGN_IDENTITY[sdk=macosx*]" = "Apple Development";
 				CODE_SIGN_STYLE = Automatic;
 				COMBINE_HIDPI_IMAGES = YES;
-				CURRENT_PROJECT_VERSION = 211;
+				CURRENT_PROJECT_VERSION = 212;
 				DEVELOPMENT_ASSET_PATHS = "\"Zerm/Preview Content\"";
 				DEVELOPMENT_TEAM = V6J6A3VWY2;
 				ENABLE_HARDENED_RUNTIME = YES;
@@ -552,7 +552,7 @@
 					"@executable_path/../Frameworks",
 				);
 				MACOSX_DEPLOYMENT_TARGET = 14.4;
-				MARKETING_VERSION = 2.1.1;
+				MARKETING_VERSION = 2.1.2;
 				PRODUCT_BUNDLE_IDENTIFIER = com.arcusis.zerm;
 				PRODUCT_NAME = "$(TARGET_NAME)";
 				SWIFT_ACTIVE_COMPILATION_CONDITIONS = "ENABLE_NATIVE_SPEECH_ANALYZER $(inherited)";

Zerm/AppDefaults.swift

@@ -24,7 +24,10 @@ enum AppDefaults {
             "IsTextFormattingEnabled": true,
             "IsVADEnabled": true,
             "AutoStopAfterSilence": true,
-            "AutoStopSilenceSeconds": 1.1,
+            // 1.1s was short enough that a normal thinking pause in long-form
+            // dictation tripped auto-stop and cut the recording off. 2.5s tolerates
+            // natural pauses while still stopping promptly when the user is done.
+            "AutoStopSilenceSeconds": 2.5,
             "AutoStopMinimumRecordingSeconds": 0.8,
             "AutoStopInitialSilenceSeconds": 6.0,
             "AutoStopLevelThreshold": 0.12,

Zerm/CoreAudioRecorder.swift

@@ -31,6 +31,10 @@ final class CoreAudioRecorder: @unchecked Sendable {
     private let meterLock = NSLock()
     private var _averagePower: Float = -160.0
     private var _peakPower: Float = -160.0
+    /// Monotonic timestamp of the last successful input callback. Lets the engine
+    /// detect a silently-dropped capture: if the audio unit dies (device removed,
+    /// render error) the callback stops firing while `isRecording` stays true.
+    private var _lastInputUptimeNanos: UInt64 = 0
 
     var averagePower: Float {
         meterLock.lock()
@@ -44,6 +48,18 @@ final class CoreAudioRecorder: @unchecked Sendable {
         return _peakPower
     }
 
+    /// Seconds since the last input callback fired, or `nil` if none has yet.
+    /// A value that keeps climbing while recording means the capture has stalled.
+    var secondsSinceLastInput: Double? {
+        meterLock.lock()
+        let last = _lastInputUptimeNanos
+        meterLock.unlock()
+        guard last != 0 else { return nil }
+        let now = DispatchTime.now().uptimeNanoseconds
+        guard now > last else { return 0 }
+        return Double(now - last) / 1_000_000_000.0
+    }
+
     // Pre-allocated render buffer (to avoid malloc in real-time callback)
     private var renderBuffer: UnsafeMutablePointer<Float32>?
     private var renderBufferSize: UInt32 = 0
@@ -147,6 +163,7 @@ final class CoreAudioRecorder: @unchecked Sendable {
         meterLock.lock()
         _averagePower = -160.0
         _peakPower = -160.0
+        _lastInputUptimeNanos = 0
         meterLock.unlock()
     }
 
@@ -625,6 +642,7 @@ final class CoreAudioRecorder: @unchecked Sendable {
         meterLock.lock()
         _averagePower = avgDb
         _peakPower = peakDb
+        _lastInputUptimeNanos = DispatchTime.now().uptimeNanoseconds
         meterLock.unlock()
     }
 

Zerm/Recorder.swift

@@ -31,6 +31,14 @@ class Recorder: NSObject, ObservableObject {
     enum RecorderError: Error {
         case couldNotStartRecording
     }
+
+    /// True while the underlying audio unit is live. Goes false once the hardware
+    /// recorder is stopped/disposed.
+    var isHardwareRecording: Bool { recorder?.isCurrentlyRecording ?? false }
+
+    /// Seconds since the last audio input callback, or `nil` if not recording or
+    /// none received yet. Used to detect a silently-dropped capture.
+    var secondsSinceLastAudioInput: Double? { recorder?.secondsSinceLastInput }
 
     override init() {
         super.init()

Zerm/Services/SelectedTextService.swift

@@ -4,7 +4,12 @@ import SelectedTextKit
 
 class SelectedTextService {
     static func fetchSelectedText() async -> String? {
-        let strategies: [TextStrategy] = [.accessibility, .menuAction]
+        // `.shortcut` simulates ⌘C and reads the pasteboard (restoring it afterward).
+        // It is the only strategy that works in terminal emulators and TUI apps
+        // (e.g. Claude Code, cmux), which render text in custom views that do not
+        // expose AXSelectedText (.accessibility) and have no standard Edit ▸ Copy
+        // menu item (.menuAction). Keep it last so the cheaper strategies win first.
+        let strategies: [TextStrategy] = [.accessibility, .menuAction, .shortcut]
         do {
             let selectedText = try await SelectedTextManager.shared.getSelectedText(strategies: strategies)
             return selectedText

Zerm/Transcription/Engine/ZermEngine.swift

@@ -259,13 +259,20 @@ class ZermEngine: NSObject, ObservableObject {
     private func startAutoStopMonitor() {
         cancelAutoStopMonitor()
 
-        guard UserDefaults.standard.bool(forKey: "AutoStopAfterSilence") else { return }
-
         let defaults = UserDefaults.standard
+        // The silence auto-stop is opt-out, but the loop always runs so the
+        // dropped-capture watchdog below works regardless of that setting.
+        let autoStopEnabled = defaults.bool(forKey: "AutoStopAfterSilence")
         let silenceSeconds = max(defaults.double(forKey: "AutoStopSilenceSeconds"), 0.6)
         let minimumRecordingSeconds = max(defaults.double(forKey: "AutoStopMinimumRecordingSeconds"), 0.3)
         let initialSilenceSeconds = max(defaults.double(forKey: "AutoStopInitialSilenceSeconds"), 2.0)
         let levelThreshold = max(defaults.double(forKey: "AutoStopLevelThreshold"), 0.02)
+        // If the audio unit dies mid-recording (device unplugged, render error)
+        // the input callback stops firing while the engine still believes it is
+        // recording — the capture is silently lost and the UI gets stuck. If no
+        // audio has arrived for this long after the unit was delivering, treat the
+        // recording as dropped and recover.
+        let captureStallSeconds = 3.0
         let startedAt = Date()
 
         autoStopTask = Task { @MainActor [weak self] in
@@ -281,6 +288,24 @@ class ZermEngine: NSObject, ObservableObject {
 
                 let now = Date()
                 let elapsed = now.timeIntervalSince(startedAt)
+
+                // Dropped-capture watchdog. `secondsSinceLastAudioInput` is non-nil
+                // only once the callback has fired at least once, so this never
+                // false-fires during the brief hardware start-up window.
+                if let sinceInput = self.recorder.secondsSinceLastAudioInput,
+                   sinceInput >= captureStallSeconds {
+                    self.logger.error("Recording dropped: no audio input for \(sinceInput, privacy: .public)s — recovering")
+                    await NotificationManager.shared.showNotification(
+                        title: "Recording stopped — microphone dropped",
+                        type: .warning,
+                        duration: 3.0
+                    )
+                    // Stop and transcribe whatever was captured before the drop,
+                    // then return cleanly to idle so the next press starts fresh.
+                    await self.toggleRecord()
+                    return
+                }
+
                 let level = max(self.recorder.audioMeter.averagePower, self.recorder.audioMeter.peakPower * 0.65)
 
                 if level >= levelThreshold {
@@ -289,6 +314,8 @@ class ZermEngine: NSObject, ObservableObject {
                     continue
                 }
 
+                guard autoStopEnabled else { continue }
+
                 if heardSpeech,
                    elapsed >= minimumRecordingSeconds,
                    now.timeIntervalSince(lastSpeechAt) >= silenceSeconds {