@hasna/recordings 0.1.26 → 0.1.28

package/dist/cli/index.js

@@ -5098,7 +5098,7 @@ var init_pg_migrate = __esm(() => {
 var require_package = __commonJS((exports, module) => {
   module.exports = {
     name: "@hasna/recordings",
-    version: "0.1.26",
+    version: "0.1.28",
     type: "module",
     description: "Speech-to-text recording tool with MCP and CLI \u2014 records, transcribes, and optionally enhances text using AI",
     repository: {
@@ -6081,7 +6081,7 @@ async function processText(rawText, config, systemPrompt) {
 }
 
 // src/version.ts
-var VERSION = "0.1.26";
+var VERSION = "0.1.28";
 
 // src/cli/storage.ts
 import chalk from "chalk";

package/dist/mcp/index.js

@@ -4920,7 +4920,7 @@ var require_lib2 = __commonJS((exports, module) => {
 var require_package = __commonJS((exports, module) => {
   module.exports = {
     name: "@hasna/recordings",
-    version: "0.1.26",
+    version: "0.1.28",
     type: "module",
     description: "Speech-to-text recording tool with MCP and CLI \u2014 records, transcribes, and optionally enhances text using AI",
     repository: {
@@ -9797,7 +9797,7 @@ async function processText(rawText, config, systemPrompt) {
 }
 
 // src/version.ts
-var VERSION = "0.1.26";
+var VERSION = "0.1.28";
 
 // src/db/storage-config.ts
 import { existsSync as existsSync2, readFileSync as readFileSync2 } from "fs";

package/dist/version.d.ts

@@ -1,2 +1,2 @@
-export declare const VERSION = "0.1.26";
+export declare const VERSION = "0.1.28";
 //# sourceMappingURL=version.d.ts.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hasna/recordings",
-  "version": "0.1.26",
+  "version": "0.1.28",
   "type": "module",
   "description": "Speech-to-text recording tool with MCP and CLI — records, transcribes, and optionally enhances text using AI",
   "repository": {

package/src/native/Recordings/App/RecordingsApp.swift

@@ -10,6 +10,7 @@ struct RecordingsApp: App {
     @StateObject private var projectStore = ProjectStore()
 
     init() {
+        Self.terminateDuplicateInstances()
         AXIsProcessTrustedWithOptions(
             [kAXTrustedCheckOptionPrompt.takeUnretainedValue(): true] as CFDictionary
         )
@@ -40,4 +41,12 @@ struct RecordingsApp: App {
             SettingsView(engine: engine, shortcuts: shortcuts, projectStore: projectStore)
         }
     }
+
+    private static func terminateDuplicateInstances() {
+        let currentPID = ProcessInfo.processInfo.processIdentifier
+        for app in NSRunningApplication.runningApplications(withBundleIdentifier: "com.hasna.recordings")
+            where app.processIdentifier != currentPID {
+            app.terminate()
+        }
+    }
 }

package/src/native/Recordings/Package.swift

@@ -16,7 +16,8 @@ let package = Package(
             name: "RecordingsLib",
             dependencies: ["KeyboardShortcuts"],
             path: "RecordingsLib",
-            exclude: ["Info.plist", "Recordings.entitlements"]
+            exclude: ["Info.plist", "Recordings.entitlements"],
+            resources: [.process("Resources")]
         ),
         .executableTarget(
             name: "App",

package/src/native/Recordings/RecordingsLib/BrandAssets.swift

@@ -0,0 +1,50 @@
+import SwiftUI
+
+public struct HasnaLogoMark: View {
+    private let size: CGFloat
+
+    public init(size: CGFloat = 22) {
+        self.size = size
+    }
+
+    public var body: some View {
+        Image("HasnaLogo", bundle: .module)
+            .resizable()
+            .interpolation(.high)
+            .scaledToFit()
+            .frame(width: size, height: size)
+            .clipShape(RoundedRectangle(cornerRadius: 4, style: .continuous))
+    }
+}
+
+public struct HasnaMenuBarIcon: View {
+    private let isRecording: Bool
+    private let isTranscribing: Bool
+
+    public init(isRecording: Bool, isTranscribing: Bool) {
+        self.isRecording = isRecording
+        self.isTranscribing = isTranscribing
+    }
+
+    public var body: some View {
+        ZStack(alignment: .bottomTrailing) {
+            Image("HasnaLogo", bundle: .module)
+                .resizable()
+                .renderingMode(.template)
+                .interpolation(.high)
+                .scaledToFit()
+                .frame(width: 18, height: 18)
+
+            if isRecording {
+                Circle()
+                    .fill(.red)
+                    .frame(width: 6, height: 6)
+            } else if isTranscribing {
+                Circle()
+                    .fill(.tint)
+                    .frame(width: 6, height: 6)
+            }
+        }
+        .frame(width: 22, height: 18)
+    }
+}

package/src/native/Recordings/RecordingsLib/MenuBarPopover.swift

@@ -52,8 +52,7 @@ public struct MenuBarPopover: View {
     private var header: some View {
         VStack(alignment: .leading, spacing: 4) {
             HStack {
-                Image(systemName: "mic.fill")
-                    .foregroundStyle(.tint)
+                HasnaLogoMark(size: 22)
                 Text("Hasna Recordings")
                     .font(.headline)
                 Spacer()

package/src/native/Recordings/RecordingsLib/OpenAIAPIKeyStore.swift

@@ -1,6 +1,8 @@
 import Foundation
 
 enum OpenAIAPIKeyStore {
+    static let defaultLanguage = "en"
+
     static func load(
         homePath: String,
         environment: [String: String] = ProcessInfo.processInfo.environment,
@@ -21,6 +23,23 @@ enum OpenAIAPIKeyStore {
         return ""
     }
 
+    static func loadLanguage(
+        homePath: String,
+        environment: [String: String] = ProcessInfo.processInfo.environment,
+        userDefaultLanguage: String? = UserDefaults.standard.string(forKey: "recordingsLanguage")
+    ) -> String {
+        if let language = firstNonEmpty(environment["RECORDINGS_LANGUAGE"]) {
+            return normalizedStoredLanguage(language)
+        }
+        if let language = firstNonEmpty(userDefaultLanguage) {
+            return normalizedStoredLanguage(language)
+        }
+        if let language = loadConfigValue(homePath: homePath, key: "language", environment: environment) {
+            return normalizedStoredLanguage(language)
+        }
+        return defaultLanguage
+    }
+
     /// Persist the key into ~/.hasna/recordings/config.json so the CLI (which the app
     /// shells out to for final transcription) uses the same key as the app itself.
     static func save(key: String, homePath: String) throws {
@@ -47,25 +66,61 @@ enum OpenAIAPIKeyStore {
         try data.write(to: url, options: .atomic)
     }
 
-    private static func loadConfigKey(homePath: String, environment: [String: String]) -> String? {
-        let url = URL(fileURLWithPath: homePath)
-            .appendingPathComponent(".hasna")
-            .appendingPathComponent("recordings")
-            .appendingPathComponent("config.json")
+    static func saveLanguage(language: String, homePath: String) throws {
+        let normalized = normalizedStoredLanguage(language)
+        var json = loadMutableConfig(homePath: homePath)
 
-        guard let data = try? Data(contentsOf: url),
-              let json = try? JSONSerialization.jsonObject(with: data) as? [String: Any]
-        else { return nil }
+        if apiLanguageHint(for: normalized).isEmpty {
+            json.removeValue(forKey: "language")
+        } else {
+            json["language"] = normalized
+        }
+
+        try writeConfig(json, homePath: homePath)
+    }
+
+    static func apiLanguageHint(for storedLanguage: String) -> String {
+        let normalized = normalizedStoredLanguage(storedLanguage)
+        return normalized == "auto" ? "" : normalized
+    }
 
+    private static func loadConfigKey(homePath: String, environment: [String: String]) -> String? {
         for key in ["openai_api_key", "api_key"] {
-            guard let value = json[key] as? String,
-                  let resolved = resolve(value: value, environment: environment)
-            else { continue }
-            return resolved
+            if let resolved = loadConfigValue(homePath: homePath, key: key, environment: environment) {
+                return resolved
+            }
         }
         return nil
     }
 
+    private static func loadConfigValue(homePath: String, key: String, environment: [String: String]) -> String? {
+        let json = loadMutableConfig(homePath: homePath)
+        guard let value = json[key] as? String else { return nil }
+        return resolve(value: value, environment: environment)
+    }
+
+    private static func loadMutableConfig(homePath: String) -> [String: Any] {
+        let url = configURL(homePath: homePath)
+        guard let data = try? Data(contentsOf: url),
+              let json = try? JSONSerialization.jsonObject(with: data) as? [String: Any]
+        else { return [:] }
+        return json
+    }
+
+    private static func writeConfig(_ json: [String: Any], homePath: String) throws {
+        let url = configURL(homePath: homePath)
+        try FileManager.default.createDirectory(at: url.deletingLastPathComponent(), withIntermediateDirectories: true)
+        let data = try JSONSerialization.data(withJSONObject: json, options: [.prettyPrinted, .sortedKeys])
+        try data.write(to: url, options: .atomic)
+    }
+
+    private static func configURL(homePath: String) -> URL {
+        URL(fileURLWithPath: homePath)
+            .appendingPathComponent(".hasna")
+            .appendingPathComponent("recordings")
+            .appendingPathComponent("config.json")
+    }
+
     private static func loadSecretKey(homePath: String) -> String? {
         let root = URL(fileURLWithPath: homePath).appendingPathComponent(".secrets")
         let fileManager = FileManager.default
@@ -127,6 +182,11 @@ enum OpenAIAPIKeyStore {
         return value
     }
 
+    private static func normalizedStoredLanguage(_ language: String) -> String {
+        let trimmed = language.trimmingCharacters(in: .whitespacesAndNewlines).lowercased()
+        return trimmed.isEmpty ? defaultLanguage : trimmed
+    }
+
     private static func firstNonEmpty(_ values: String?...) -> String? {
         for value in values {
             let trimmed = value?.trimmingCharacters(in: .whitespacesAndNewlines) ?? ""

package/src/native/Recordings/RecordingsLib/RealtimeTranscriptionClient.swift

@@ -6,8 +6,9 @@ import Foundation
 /// Receives transcription deltas in real time.
 @MainActor
 public final class RealtimeTranscriptionClient: ObservableObject, @unchecked Sendable {
-    /// Latest stable transcription model.
-    public nonisolated static let modelID = "gpt-4o-transcribe"
+    /// Low-latency model for realtime transcript deltas.
+    public nonisolated static let modelID = "gpt-realtime-whisper"
+    public nonisolated static let transcriptionDelay = "low"
     private nonisolated static let transcriptionURL = URL(string: "wss://api.openai.com/v1/realtime?intent=transcription")!
 
     @Published public var accumulatedText = ""
@@ -80,7 +81,7 @@ public final class RealtimeTranscriptionClient: ObservableObject, @unchecked Sen
 
         var transcription: [String: Any] = [
             "model": Self.modelID,
-            "prompt": Self.verbatimPrompt(context: systemPrompt),
+            "delay": Self.transcriptionDelay,
         ]
         let trimmedLanguage = language.trimmingCharacters(in: .whitespacesAndNewlines)
         if !trimmedLanguage.isEmpty {
@@ -141,7 +142,7 @@ public final class RealtimeTranscriptionClient: ObservableObject, @unchecked Sen
     }
 
     /// Commit buffered input, wait briefly for a final completed event, then close.
-    public func finish(timeoutMilliseconds: UInt64 = 2_800) async -> String {
+    public func finish(timeoutMilliseconds: UInt64 = 700) async -> String {
         guard isStreaming else { return accumulatedText }
         let completedCountBeforeCommit = completedEventCount
         let didManualCommit = await commitInput()
@@ -379,18 +380,8 @@ public final class RealtimeTranscriptionClient: ObservableObject, @unchecked Sen
                             "rate": 24_000,
                         ],
                         "transcription": transcription,
-                        "turn_detection": [
-                            "type": "server_vad",
-                            "threshold": 0.5,
-                            "prefix_padding_ms": 300,
-                            "silence_duration_ms": 350,
-                        ],
-                        "noise_reduction": [
-                            "type": "near_field",
-                        ],
                     ],
                 ],
-                "include": ["item.input_audio_transcription.logprobs"],
             ],
         ]
     }
@@ -442,7 +433,7 @@ extension RealtimeTranscriptionClient {
     public nonisolated static func sessionUpdateTestHelper(prompt: String, language: String = "") -> [String: Any] {
         var transcription: [String: Any] = [
             "model": modelID,
-            "prompt": prompt,
+            "delay": transcriptionDelay,
         ]
         if !language.isEmpty {
             transcription["language"] = language

package/src/native/Recordings/RecordingsLib/RecordingEngine.swift

@@ -26,9 +26,9 @@ public enum RecordingMode: String, CaseIterable, Identifiable, Sendable {
     }
     public var hint: String {
         switch self {
-        case .pushToTalk: return "Hold F5 or your chosen shortcut to record, then release to paste"
-        case .dictation: return "Hold F5 or your chosen shortcut to dictate, then release to paste"
-        case .command: return "Select text, then hold F5 or your chosen shortcut and release to rewrite"
+        case .pushToTalk: return "Hold your recording shortcut, then release to paste"
+        case .dictation: return "Hold your recording shortcut to dictate, then release to paste"
+        case .command: return "Select text, hold your recording shortcut, then release to rewrite"
         }
     }
 }
@@ -56,33 +56,50 @@ struct PasteTargetCandidate: Equatable, Sendable {
     let isRegularApp: Bool
 }
 
-private actor PCMStreamState {
-    private var recordedPCM = Data()
-    private var pendingChunk = Data()
-
-    func append(_ data: Data, chunkSize: Int) -> [Data] {
-        guard !data.isEmpty else { return [] }
+private final class PCMStreamPipe: @unchecked Sendable {
+    private let continuation: AsyncStream<Data>.Continuation
+    private let processor: Task<Data, Never>
 
-        recordedPCM.append(data)
-        pendingChunk.append(data)
+    init(chunkSize: Int, client: RealtimeTranscriptionClient?) {
+        var streamContinuation: AsyncStream<Data>.Continuation!
+        let stream = AsyncStream<Data>(bufferingPolicy: .unbounded) { continuation in
+            streamContinuation = continuation
+        }
+        continuation = streamContinuation
+        processor = Task {
+            var recordedPCM = Data()
+            var pendingChunk = Data()
+
+            for await data in stream {
+                guard !data.isEmpty else { continue }
+                recordedPCM.append(data)
+                pendingChunk.append(data)
+
+                while pendingChunk.count >= chunkSize {
+                    await client?.sendAudio(pendingChunk.prefixData(count: chunkSize))
+                    pendingChunk.removeFirst(chunkSize)
+                }
+            }
 
-        var chunks: [Data] = []
-        while pendingChunk.count >= chunkSize {
-            chunks.append(pendingChunk.prefixData(count: chunkSize))
-            pendingChunk.removeFirst(chunkSize)
+            if !pendingChunk.isEmpty {
+                await client?.sendAudio(pendingChunk)
+            }
+            return recordedPCM
         }
-        return chunks
     }
 
-    func flushPendingChunk() -> Data? {
-        guard !pendingChunk.isEmpty else { return nil }
-        let chunk = pendingChunk
-        pendingChunk.removeAll(keepingCapacity: true)
-        return chunk
+    func append(_ data: Data) {
+        continuation.yield(data)
+    }
+
+    func finish() async -> Data {
+        continuation.finish()
+        return await processor.value
     }
 
-    func capturedPCM() -> Data {
-        recordedPCM
+    func cancel() {
+        continuation.finish()
+        processor.cancel()
     }
 }
 
@@ -116,6 +133,12 @@ public final class RecordingEngine: ObservableObject {
     @Published public var isTranscribing = false
     @Published public var recordingDuration: TimeInterval = 0
     @Published public var liveTranscriptionText = ""
+    @Published public var transcriptionLanguage = OpenAIAPIKeyStore.defaultLanguage {
+        didSet {
+            UserDefaults.standard.set(transcriptionLanguage, forKey: "recordingsLanguage")
+            try? OpenAIAPIKeyStore.saveLanguage(language: transcriptionLanguage, homePath: home)
+        }
+    }
 
     private var nativeRecorder: NativePCMRecorder?
     private var recordingTimer: Timer?
@@ -130,12 +153,15 @@ public final class RecordingEngine: ObservableObject {
     // Real-time streaming
     private var realtimeClient: RealtimeTranscriptionClient?
     private var streamingTask: Task<Void, Never>?
-    private var pcmStreamState: PCMStreamState?
+    private var pcmStreamPipe: PCMStreamPipe?
     private var streamingText = ""
     private var recordedPCM = Data()
     private var activeAudioPath: String?
     private var lastAccessibilityPromptAt: Date?
 
+    private nonisolated static let realtimePeriodicCommitInterval: TimeInterval = 0.9
+    private nonisolated static let realtimeFinishTimeoutMilliseconds: UInt64 = 700
+
     // fn key monitor (CGEventTap-based, swallows fn to prevent emoji picker)
     private let fnMonitor = FnKeyMonitor()
     private var permissionRetryTimer: Timer?
@@ -158,6 +184,7 @@ public final class RecordingEngine: ObservableObject {
            let parsedMode = RecordingMode(rawValue: savedMode) {
             mode = parsedMode
         }
+        transcriptionLanguage = OpenAIAPIKeyStore.loadLanguage(homePath: home)
         useFnKey = UserDefaults.standard.object(forKey: "useFnKey") as? Bool ?? false
         if KeyboardShortcuts.getShortcut(for: .toggleRecording) == nil {
             KeyboardShortcuts.setShortcut(.init(.f5), for: .toggleRecording)
@@ -393,9 +420,6 @@ public final class RecordingEngine: ObservableObject {
     }
 
     private func startNativeRecording() {
-        let streamState = PCMStreamState()
-        pcmStreamState = streamState
-
         let apiKey = openAIAPIKey
         log("startNativeRecording apiKeyConfigured=\(!apiKey.isEmpty)")
         if !apiKey.isEmpty {
@@ -403,18 +427,15 @@ public final class RecordingEngine: ObservableObject {
         }
 
         let client = realtimeClient
+        let streamPipe = PCMStreamPipe(chunkSize: 4_800, client: client)
+        pcmStreamPipe = streamPipe
         let homePath = home
         let firstChunkLogged = LockedFlag()
-        let recorder = NativePCMRecorder { [weak client] data in
+        let recorder = NativePCMRecorder { data in
             if firstChunkLogged.take() {
                 NativeAppLog.write("native recorder received first PCM chunk bytes=\(data.count)", homePath: homePath)
             }
-            Task {
-                let chunks = await streamState.append(data, chunkSize: 4_800)
-                for chunk in chunks {
-                    await client?.sendAudio(chunk)
-                }
-            }
+            streamPipe.append(data)
         }
 
         do {
@@ -445,7 +466,8 @@ public final class RecordingEngine: ObservableObject {
             realtimeClient = nil
             streamingTask?.cancel()
             streamingTask = nil
-            pcmStreamState = nil
+            pcmStreamPipe?.cancel()
+            pcmStreamPipe = nil
             resetRecordingIntent()
             statusMessage = "Failed: \(error.localizedDescription)"
         }
@@ -456,20 +478,29 @@ public final class RecordingEngine: ObservableObject {
     private func startRealtimeStreaming(apiKey: String) {
         let client = RealtimeTranscriptionClient(apiKey: apiKey, homePath: home)
         realtimeClient = client
-        log("realtime streaming task starting")
+        let language = OpenAIAPIKeyStore.apiLanguageHint(for: transcriptionLanguage)
+        log("realtime streaming task starting language=\(language.isEmpty ? "auto" : language)")
 
         streamingTask = Task {
-            await client.startStreaming()
+            await client.startStreaming(language: language)
             self.log("realtime start completed streaming=\(client.isStreaming) error=\(client.error ?? "")")
 
+            var lastPeriodicCommitAt = Date.distantPast
+
             // Receive deltas
             while client.isStreaming {
                 try? await Task.sleep(for: .milliseconds(100))
+                if self.isRecording,
+                   Date().timeIntervalSince(lastPeriodicCommitAt) >= Self.realtimePeriodicCommitInterval {
+                    if await client.commitInput(reason: "periodic") {
+                        lastPeriodicCommitAt = Date()
+                    }
+                }
                 let text = client.accumulatedText
                 if text != streamingText {
                     await MainActor.run {
                         self.streamingText = text
-                        self.liveTranscriptionText = text
+                        self.liveTranscriptionText = Self.cleanRealtimeArtifactText(text)
                     }
                 }
             }
@@ -489,6 +520,7 @@ public final class RecordingEngine: ObservableObject {
 
     public func stopAndTranscribe() {
         guard isRecording else { return }
+        let stopStartedAt = Date()
         log("stopAndTranscribe")
 
         recordingTimer?.invalidate()
@@ -507,30 +539,53 @@ public final class RecordingEngine: ObservableObject {
         let activeProjectId = projectStore?.settings.activeProjectId
         let activeProjectName = projectStore?.activeProject?.name
         let audioPath = activeAudioPath
-        let pcmStreamState = pcmStreamState
+        let pcmStreamPipe = pcmStreamPipe
         let client = realtimeClient
+        let transcriptionLanguage = transcriptionLanguage
         resetRecordingIntent()
-        self.pcmStreamState = nil
+        self.pcmStreamPipe = nil
 
         Task {
-            if let pcmStreamState {
-                if let finalChunk = await pcmStreamState.flushPendingChunk() {
-                    client?.sendAudio(finalChunk)
-                }
-                self.recordedPCM = await pcmStreamState.capturedPCM()
+            if let pcmStreamPipe {
+                self.recordedPCM = await pcmStreamPipe.finish()
             }
             self.log("captured pcm bytes=\(self.recordedPCM.count)")
 
-            let streamingResult = await client?.finish() ?? ""
+            let streamingResult = await client?.finish(timeoutMilliseconds: Self.realtimeFinishTimeoutMilliseconds) ?? ""
 
             self.realtimeClient = nil
             self.streamingTask?.cancel()
             self.streamingTask = nil
 
-            let realtimeText = streamingResult.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty ? nil : streamingResult
+            let realtimeText = Self.normalizedRealtimeTranscript(streamingResult)
 
             self.liveTranscriptionText = ""
 
+            if Self.shouldUseRealtimeFastPath(
+                realtimeText: streamingResult,
+                pcmByteCount: self.recordedPCM.count,
+                language: transcriptionLanguage
+            ),
+               let realtimeText {
+                let releaseToTextMS = Int(Date().timeIntervalSince(stopStartedAt) * 1_000)
+                self.log("using realtime fast path chars=\(realtimeText.count) releaseToTextMs=\(releaseToTextMS)")
+                self.isTranscribing = false
+                self.finishWithText(
+                    realtimeText,
+                    curMode: curMode,
+                    targetAppBundleIdentifier: targetAppBundleIdentifier,
+                    targetAppPid: targetAppPid,
+                    activeProjectId: activeProjectId,
+                    activeProjectName: activeProjectName
+                )
+                if let audioPath, !self.recordedPCM.isEmpty {
+                    Self.saveCapturedWAVInBackground(pcmData: self.recordedPCM, audioPath: audioPath, homePath: self.home)
+                }
+                self.activeAudioPath = nil
+                self.recordedPCM.removeAll(keepingCapacity: true)
+                return
+            }
+
             if let audioPath, self.writeCapturedWAV(to: audioPath) {
                 self.log("transcribing captured full audio audioPath=\(audioPath) realtimePreviewChars=\(realtimeText?.count ?? 0)")
                 self.fallbackTranscribe(
@@ -573,10 +628,166 @@ public final class RecordingEngine: ObservableObject {
         return trimmed.count < 12 || words.count <= 2
     }
 
+    public nonisolated static func normalizedRealtimeTranscript(_ text: String?) -> String? {
+        guard let text else { return nil }
+        let trimmed = cleanRealtimeArtifactText(text).trimmingCharacters(in: .whitespacesAndNewlines)
+        return trimmed.isEmpty ? nil : trimmed
+    }
+
+    public nonisolated static func shouldUseRealtimeFastPath(
+        realtimeText: String?,
+        pcmByteCount: Int,
+        language: String = "en"
+    ) -> Bool {
+        guard let text = normalizedRealtimeTranscript(realtimeText) else { return false }
+        guard isSafeRealtimeFastPathText(rawText: realtimeText ?? "", cleanedText: text, language: language) else {
+            return false
+        }
+        return !shouldFallbackFromPartialRealtime(text: text, pcmByteCount: pcmByteCount)
+    }
+
+    public nonisolated static func isSafeRealtimeFastPathText(rawText: String, cleanedText: String, language: String) -> Bool {
+        guard !cleanedText.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty else { return false }
+        let languageHint = OpenAIAPIKeyStore.apiLanguageHint(for: language)
+        guard languageHint == "en" else { return true }
+
+        let rawTrimmed = rawText.trimmingCharacters(in: .whitespacesAndNewlines)
+        guard !containsCJKArtifact(in: rawTrimmed) else { return false }
+
+        let rawNormalized = rawTrimmed.replacingOccurrences(
+            of: #"\s+"#,
+            with: " ",
+            options: .regularExpression
+        )
+        let cleanedNormalized = cleanedText.replacingOccurrences(
+            of: #"\s+"#,
+            with: " ",
+            options: .regularExpression
+        )
+        return rawNormalized == cleanedNormalized
+    }
+
+    public nonisolated static func cleanRealtimeArtifactText(_ text: String) -> String {
+        var cleaned = text
+            .replacingOccurrences(of: "\n", with: " ")
+            .replacingOccurrences(of: "\t", with: " ")
+        cleaned = cleaned.replacingOccurrences(
+            of: #"(?i)(?<=[A-Za-z])어\b"#,
+            with: "",
+            options: .regularExpression
+        )
+        cleaned = cleaned.replacingOccurrences(
+            of: #"\s+"#,
+            with: " ",
+            options: .regularExpression
+        )
+        cleaned = removeStandaloneRealtimeArtifacts(from: cleaned)
+        cleaned = collapseAdjacentDuplicateWords(in: cleaned)
+        cleaned = collapseAdjacentDuplicatePhrases(in: cleaned)
+        cleaned = cleaned.replacingOccurrences(
+            of: #"\s+([,.;:!?])"#,
+            with: "$1",
+            options: .regularExpression
+        )
+        return cleaned.trimmingCharacters(in: .whitespacesAndNewlines)
+    }
+
+    private nonisolated static func removeStandaloneRealtimeArtifacts(from text: String) -> String {
+        let artifactTokens: Set<String> = ["어", "음", "um", "umm", "uh", "uhh", "erm", "hmm", "eh"]
+        let englishDominant = latinLetterCount(in: text) >= max(12, cjkLetterCount(in: text) * 3)
+        let words = text.split(separator: " ").compactMap { rawWord -> String? in
+            let normalized = rawWord
+                .trimmingCharacters(in: .punctuationCharacters.union(.whitespacesAndNewlines))
+                .lowercased()
+            return artifactTokens.contains(normalized) ? nil : String(rawWord)
+        }.compactMap { word -> String? in
+            guard englishDominant else { return word }
+            let normalized = word.trimmingCharacters(in: .punctuationCharacters.union(.whitespacesAndNewlines))
+            guard !normalized.isEmpty else { return word }
+            return isMostlyCJKArtifact(normalized) ? nil : word
+        }
+        return words.joined(separator: " ")
+    }
+
+    private nonisolated static func collapseAdjacentDuplicateWords(in text: String) -> String {
+        let words = text.split(separator: " ").map(String.init)
+        guard words.count > 1 else { return text }
+
+        var output: [String] = []
+        for word in words {
+            if let last = output.last,
+               normalizedTranscriptWord(last) == normalizedTranscriptWord(word) {
+                continue
+            }
+            output.append(word)
+        }
+        return output.joined(separator: " ")
+    }
+
+    private nonisolated static func collapseAdjacentDuplicatePhrases(in text: String) -> String {
+        var words = text.split(separator: " ").map(String.init)
+        guard words.count >= 6 else { return text }
+
+        var i = 0
+        while i < words.count {
+            let maxLength = min(24, (words.count - i) / 2)
+            var removedDuplicate = false
+            if maxLength >= 3 {
+                for length in stride(from: maxLength, through: 3, by: -1) {
+                    let first = words[i..<(i + length)].map(normalizedTranscriptWord)
+                    let second = words[(i + length)..<(i + (2 * length))].map(normalizedTranscriptWord)
+                    if first == second {
+                        words.removeSubrange((i + length)..<(i + (2 * length)))
+                        removedDuplicate = true
+                        break
+                    }
+                }
+            }
+            if !removedDuplicate {
+                i += 1
+            }
+        }
+        return words.joined(separator: " ")
+    }
+
+    private nonisolated static func normalizedTranscriptWord(_ word: String) -> String {
+        word.trimmingCharacters(in: .punctuationCharacters.union(.whitespacesAndNewlines)).lowercased()
+    }
+
+    private nonisolated static func isMostlyCJKArtifact(_ word: String) -> Bool {
+        let cjkCount = word.unicodeScalars.filter(isCJKScalar).count
+        guard cjkCount > 0 else { return false }
+        let letterCount = word.unicodeScalars.filter { CharacterSet.letters.contains($0) }.count
+        return cjkCount >= max(1, letterCount - cjkCount)
+    }
+
+    private nonisolated static func latinLetterCount(in text: String) -> Int {
+        text.unicodeScalars.filter { scalar in
+            (65...90).contains(Int(scalar.value)) || (97...122).contains(Int(scalar.value))
+        }.count
+    }
+
+    private nonisolated static func cjkLetterCount(in text: String) -> Int {
+        text.unicodeScalars.filter(isCJKScalar).count
+    }
+
+    private nonisolated static func containsCJKArtifact(in text: String) -> Bool {
+        cjkLetterCount(in: text) > 0
+    }
+
+    private nonisolated static func isCJKScalar(_ scalar: UnicodeScalar) -> Bool {
+        switch scalar.value {
+        case 0x3040...0x30FF, 0x3400...0x4DBF, 0x4E00...0x9FFF, 0xAC00...0xD7AF:
+            return true
+        default:
+            return false
+        }
+    }
+
     private func finishWithText(_ text: String, curMode: RecordingMode, targetAppBundleIdentifier: String?, targetAppPid: pid_t?, activeProjectId: String?, activeProjectName: String?) {
         log("finishWithText mode=\(curMode.rawValue) chars=\(text.count)")
         if curMode == .command {
-            runCommandMode(instruction: text)
+            runCommandMode(instruction: text, targetAppBundleIdentifier: targetAppBundleIdentifier, targetAppPid: targetAppPid)
             return
         }
 
@@ -615,7 +826,24 @@ public final class RecordingEngine: ObservableObject {
         }
     }
 
-    private static func writeWAV(pcmData: Data, sampleRate: UInt32, channelCount: UInt16, bitsPerSample: UInt16, to url: URL) throws {
+    private nonisolated static func saveCapturedWAVInBackground(pcmData: Data, audioPath: String, homePath: String) {
+        Task.detached(priority: .utility) {
+            do {
+                try Self.writeWAV(
+                    pcmData: pcmData,
+                    sampleRate: 24_000,
+                    channelCount: 1,
+                    bitsPerSample: 16,
+                    to: URL(fileURLWithPath: audioPath)
+                )
+                NativeAppLog.write("wrote wav path=\(audioPath) pcmBytes=\(pcmData.count)", homePath: homePath)
+            } catch {
+                NativeAppLog.write("failed to save wav after realtime fast path error=\(error.localizedDescription)", homePath: homePath)
+            }
+        }
+    }
+
+    private nonisolated static func writeWAV(pcmData: Data, sampleRate: UInt32, channelCount: UInt16, bitsPerSample: UInt16, to url: URL) throws {
         let byteRate = sampleRate * UInt32(channelCount) * UInt32(bitsPerSample / 8)
         let blockAlign = channelCount * (bitsPerSample / 8)
         let dataSize = UInt32(pcmData.count)
@@ -729,17 +957,35 @@ public final class RecordingEngine: ObservableObject {
 
     // MARK: - Command Mode
 
-    private func runCommandMode(instruction: String) {
+    private func runCommandMode(instruction: String, targetAppBundleIdentifier: String?, targetAppPid: pid_t?) {
         guard ensureAccessibilityPermission(prompt: shouldPromptAccessibility()) else {
             log("command mode blocked by accessibility permission")
             statusMessage = "Enable Accessibility permission for Recordings to rewrite selected text"
             return
         }
-        postKey(0x08, flags: .maskCommand) // Cmd+C
-        let homePath = home
+        let targetApp = selectedRunningPasteTarget(
+            targetAppBundleIdentifier: targetAppBundleIdentifier,
+            targetAppPid: targetAppPid,
+            frontmostPid: NSWorkspace.shared.frontmostApplication?.processIdentifier
+        )
+        guard let targetApp else {
+            log("command mode target app not found")
+            statusMessage = "No target app found"
+            return
+        }
+        let alreadyFrontmost = targetApp.processIdentifier == NSWorkspace.shared.frontmostApplication?.processIdentifier
+        if !alreadyFrontmost {
+            targetApp.activate(options: [.activateIgnoringOtherApps])
+        }
 
+        let copyDelay: TimeInterval = alreadyFrontmost ? 0.15 : 0.5
+        DispatchQueue.main.asyncAfter(deadline: .now() + copyDelay) {
+            self.postKey(0x08, flags: .maskCommand) // Cmd+C
+        }
+
+        let homePath = home
         Task {
-            try? await Task.sleep(for: .milliseconds(250))
+            try? await Task.sleep(for: .milliseconds(Int((copyDelay + 0.25) * 1_000)))
             let selected = NSPasteboard.general.string(forType: .string) ?? ""
             guard !selected.isEmpty else {
                 statusMessage = "No text selected"
@@ -793,7 +1039,7 @@ public final class RecordingEngine: ObservableObject {
     func pasteIntoFrontApp(_ text: String, targetAppBundleIdentifier: String? = nil, targetAppPid: pid_t? = nil, restoreClipboard: Bool = false) {
         log("paste requested chars=\(text.count) target=\(targetAppBundleIdentifier ?? "nil") pid=\(targetAppPid.map(String.init) ?? "nil") accessibility=\(AXIsProcessTrusted())")
         let pb = NSPasteboard.general
-        let previousClipboard = restoreClipboard ? pb.string(forType: .string) : nil
+        let previousClipboard = restoreClipboard ? ClipboardSnapshot(pasteboard: pb) : nil
         pb.clearContents()
         pb.setString(text, forType: .string)
 
@@ -806,30 +1052,16 @@ public final class RecordingEngine: ObservableObject {
             return
         }
 
-        let myPID = ProcessInfo.processInfo.processIdentifier
-        let runningApps = NSWorkspace.shared.runningApplications
         let frontmostPid = NSWorkspace.shared.frontmostApplication?.processIdentifier
-        let candidates = runningApps.map {
-            PasteTargetCandidate(
-                pid: $0.processIdentifier,
-                bundleIdentifier: $0.bundleIdentifier,
-                isRegularApp: $0.activationPolicy == .regular
-            )
-        }
-        let selectedTarget = Self.selectPasteTarget(
-            candidates: candidates,
-            currentPid: myPID,
-            targetBundleIdentifier: targetAppBundleIdentifier,
-            targetPid: targetAppPid,
+        let targetApp = selectedRunningPasteTarget(
+            targetAppBundleIdentifier: targetAppBundleIdentifier,
+            targetAppPid: targetAppPid,
             frontmostPid: frontmostPid
         )
-        let targetApp = selectedTarget.flatMap { selected in
-            runningApps.first { $0.processIdentifier == selected.pid }
-        }
 
         guard let app = targetApp else {
             log("paste target app not found")
-            self.statusMessage = "No target app found"
+            self.statusMessage = "Copied — no target app found"
             return
         }
 
@@ -857,14 +1089,35 @@ public final class RecordingEngine: ObservableObject {
                 DispatchQueue.main.asyncAfter(deadline: .now() + 0.6) {
                     let pb = NSPasteboard.general
                     if pb.string(forType: .string) == text {
-                        pb.clearContents()
-                        pb.setString(previousClipboard, forType: .string)
+                        previousClipboard.restore(to: pb)
                     }
                 }
             }
         }
     }
 
+    private func selectedRunningPasteTarget(targetAppBundleIdentifier: String?, targetAppPid: pid_t?, frontmostPid: pid_t?) -> NSRunningApplication? {
+        let myPID = ProcessInfo.processInfo.processIdentifier
+        let runningApps = NSWorkspace.shared.runningApplications
+        let candidates = runningApps.map {
+            PasteTargetCandidate(
+                pid: $0.processIdentifier,
+                bundleIdentifier: $0.bundleIdentifier,
+                isRegularApp: $0.activationPolicy == .regular
+            )
+        }
+        let selectedTarget = Self.selectPasteTarget(
+            candidates: candidates,
+            currentPid: myPID,
+            targetBundleIdentifier: targetAppBundleIdentifier,
+            targetPid: targetAppPid,
+            frontmostPid: frontmostPid
+        )
+        return selectedTarget.flatMap { selected in
+            runningApps.first { $0.processIdentifier == selected.pid }
+        }
+    }
+
     nonisolated static func selectPasteTarget(
         candidates: [PasteTargetCandidate],
         currentPid: pid_t,
@@ -882,8 +1135,6 @@ public final class RecordingEngine: ObservableObject {
         } ?? candidates.first {
             guard let frontmostPid else { return false }
             return $0.pid == frontmostPid && $0.pid != currentPid && $0.isRegularApp
-        } ?? candidates.first {
-            $0.isRegularApp && $0.pid != currentPid
         }
     }
 
@@ -941,6 +1192,35 @@ private final class LockedFlag: @unchecked Sendable {
     }
 }
 
+private struct ClipboardSnapshot {
+    private let items: [[NSPasteboard.PasteboardType: Data]]
+
+    init?(pasteboard: NSPasteboard) {
+        let capturedItems = pasteboard.pasteboardItems?.compactMap { item -> [NSPasteboard.PasteboardType: Data]? in
+            let dataByType = item.types.reduce(into: [NSPasteboard.PasteboardType: Data]()) { result, type in
+                if let data = item.data(forType: type) {
+                    result[type] = data
+                }
+            }
+            return dataByType.isEmpty ? nil : dataByType
+        } ?? []
+        guard !capturedItems.isEmpty else { return nil }
+        items = capturedItems
+    }
+
+    func restore(to pasteboard: NSPasteboard) {
+        pasteboard.clearContents()
+        let pasteboardItems = items.map { itemData in
+            let item = NSPasteboardItem()
+            for (type, data) in itemData {
+                item.setData(data, forType: type)
+            }
+            return item
+        }
+        pasteboard.writeObjects(pasteboardItems)
+    }
+}
+
 // MARK: - CLI Runner
 
 enum CLIRunner: Sendable {

package/src/native/Recordings/RecordingsLib/SettingsView.swift

@@ -33,6 +33,10 @@ public struct SettingsView: View {
                         // Keep the CLI config in sync — final transcription shells out to it.
                         try? OpenAIAPIKeyStore.save(key: openAIAPIKey, homePath: engine.home)
                     }
+                Picker("Language", selection: $engine.transcriptionLanguage) {
+                    Text("English").tag("en")
+                    Text("Auto Detect").tag("auto")
+                }
                 Text("Used for live transcription and the final paste. Stored in ~/.hasna/recordings/config.json.")
                     .foregroundStyle(.secondary)
             }
@@ -44,7 +48,12 @@ public struct SettingsView: View {
                     KeyboardShortcuts.Recorder(for: .toggleRecording) { _ in
                         engine.updateStatus()
                     }
+                    Button("Reset to F5") {
+                        KeyboardShortcuts.setShortcut(.init(.f5), for: .toggleRecording)
+                        engine.updateStatus()
+                    }
                 }
+                Toggle("Use fn/Globe as recording key", isOn: $engine.useFnKey)
                 Text("Hold to record, release to transcribe and paste.")
                     .foregroundStyle(.secondary)
             }

package/src/native/Recordings/RecordingsTests/OpenAIAPIKeyStoreTests.swift

@@ -52,6 +52,32 @@ struct OpenAIAPIKeyStoreTests {
         #expect(key == "referenced-key")
     }
 
+    @Test("Language defaults to English and can be loaded from config")
+    func languageConfig() throws {
+        let home = try makeHome()
+        #expect(OpenAIAPIKeyStore.loadLanguage(homePath: home.path, environment: [:], userDefaultLanguage: nil) == "en")
+
+        try writeConfig(home: home, ["language": "FR"])
+        #expect(OpenAIAPIKeyStore.loadLanguage(homePath: home.path, environment: [:], userDefaultLanguage: nil) == "fr")
+        #expect(OpenAIAPIKeyStore.apiLanguageHint(for: "auto") == "")
+        #expect(OpenAIAPIKeyStore.apiLanguageHint(for: "en") == "en")
+    }
+
+    @Test("Saving language writes the CLI language config")
+    func saveLanguageWritesConfig() throws {
+        let home = try makeHome()
+
+        try OpenAIAPIKeyStore.saveLanguage(language: "en", homePath: home.path)
+
+        let configURL = home
+            .appendingPathComponent(".hasna")
+            .appendingPathComponent("recordings")
+            .appendingPathComponent("config.json")
+        let data = try Data(contentsOf: configURL)
+        let json = try #require(JSONSerialization.jsonObject(with: data) as? [String: Any])
+        #expect(json["language"] as? String == "en")
+    }
+
     @Test("Secrets env files are searched recursively")
     func recursiveSecrets() throws {
         let home = try makeHome()

package/src/native/Recordings/RecordingsTests/PasteTargetTests.swift

@@ -19,8 +19,8 @@ struct PasteTargetTests {
         #expect(selected?.pid == 20)
     }
 
-    @Test("paste target ignores current app when falling back")
-    func ignoresCurrentApp() {
+    @Test("paste target does not choose arbitrary apps without a captured or frontmost target")
+    func noArbitraryFallback() {
         let candidates = [
             PasteTargetCandidate(pid: 99, bundleIdentifier: "com.hasna.recordings", isRegularApp: true),
             PasteTargetCandidate(pid: 30, bundleIdentifier: "com.notes", isRegularApp: true),
@@ -33,7 +33,7 @@ struct PasteTargetTests {
             targetPid: nil
         )
 
-        #expect(selected?.pid == 30)
+        #expect(selected == nil)
     }
 
     @Test("paste target prefers the frontmost app over an arbitrary regular app")
@@ -69,7 +69,7 @@ struct PasteTargetTests {
             frontmostPid: 99
         )
 
-        #expect(selected?.pid == 30)
+        #expect(selected == nil)
     }
 
     @Test("captured pid wins over frontmost fallback")

package/src/native/Recordings/RecordingsTests/RealtimeTranscriptionTests.swift

@@ -4,9 +4,10 @@ import Testing
 // MARK: - RealtimeTranscriptionClient Event Parsing Tests
 
 struct RealtimeTranscriptionTests {
-    @Test("Model ID is set to latest gpt-4o-transcribe")
+    @Test("Model ID is set to low-latency realtime transcription model")
     func modelID() {
-        #expect(RealtimeTranscriptionClient.modelID == "gpt-4o-transcribe")
+        #expect(RealtimeTranscriptionClient.modelID == "gpt-realtime-whisper")
+        #expect(RealtimeTranscriptionClient.transcriptionDelay == "low")
     }
 
     @Test("Parses transcription delta events")
@@ -94,15 +95,16 @@ struct RealtimeTranscriptionTests {
         #expect(format?["rate"] as? Int == 24_000)
 
         let transcription = input?["transcription"] as? [String: Any]
-        #expect(transcription?["model"] as? String == "gpt-4o-transcribe")
-        #expect(transcription?["prompt"] as? String == "Use Alumia as vocabulary")
+        #expect(transcription?["model"] as? String == "gpt-realtime-whisper")
+        #expect(transcription?["delay"] as? String == "low")
+        #expect(transcription?["prompt"] as? String == nil)
         #expect(transcription?["language"] as? String == "en")
 
         let turnDetection = input?["turn_detection"] as? [String: Any]
-        #expect(turnDetection?["type"] as? String == "server_vad")
+        #expect(turnDetection == nil)
 
         let include = session?["include"] as? [String]
-        #expect(include?.contains("item.input_audio_transcription.logprobs") == true)
+        #expect(include == nil)
     }
 
     @Test("Joins transcript parts without dropping spoken text")
@@ -123,4 +125,38 @@ struct RealtimeTranscriptionTests {
         #expect(RecordingEngine.shouldFallbackFromPartialRealtime(text: "This is a complete sentence.", pcmByteCount: 96_000) == false)
         #expect(RecordingEngine.shouldFallbackFromPartialRealtime(text: "Hi", pcmByteCount: 12_000) == false)
     }
+
+    @Test("Realtime fast path accepts useful text and rejects empty or suspicious partial output")
+    func realtimeFastPathDecision() {
+        #expect(RecordingEngine.shouldUseRealtimeFastPath(realtimeText: "  this is a useful transcript  ", pcmByteCount: 96_000))
+        #expect(RecordingEngine.shouldUseRealtimeFastPath(realtimeText: "Hi", pcmByteCount: 12_000))
+        #expect(RecordingEngine.shouldUseRealtimeFastPath(realtimeText: "Hi", pcmByteCount: 96_000) == false)
+        #expect(RecordingEngine.shouldUseRealtimeFastPath(realtimeText: "   ", pcmByteCount: 96_000) == false)
+        #expect(RecordingEngine.shouldUseRealtimeFastPath(
+            realtimeText: "Actually 리수 Zoom your goal",
+            pcmByteCount: 96_000,
+            language: "en"
+        ) == false)
+        #expect(RecordingEngine.shouldUseRealtimeFastPath(
+            realtimeText: "Actually Zoom your goal",
+            pcmByteCount: 96_000,
+            language: "en"
+        ))
+    }
+
+    @Test("Realtime artifact cleanup removes duplicated chunks and filler tokens")
+    func realtimeArtifactCleanup() {
+        let cleaned = RecordingEngine.cleanRealtimeArtifactText(
+            "어 Okay I don't know if this This is working어 Okay I don't know if this This is working"
+        )
+        #expect(cleaned == "Okay I don't know if this is working")
+    }
+
+    @Test("Realtime artifact cleanup removes CJK tokens from English-dominant text")
+    func realtimeCJKArtifactCleanup() {
+        let cleaned = RecordingEngine.cleanRealtimeArtifactText(
+            "Actually 리수 Zoom your goal and do this work with sabi 度扫 agents actually"
+        )
+        #expect(cleaned == "Actually Zoom your goal and do this work with sabi agents actually")
+    }
 }

package/src/native/Recordings/RecordingsTests/TranscriptResolutionTests.swift

@@ -55,4 +55,26 @@ struct TranscriptResolutionTests {
         #expect(resolved.text == nil)
         #expect(resolved.failureStatus == "Empty transcription")
     }
+
+    @Test("Realtime transcripts are normalized before fast-path use")
+    func realtimeNormalization() {
+        #expect(RecordingEngine.normalizedRealtimeTranscript("  hello world\n") == "hello world")
+        #expect(RecordingEngine.normalizedRealtimeTranscript("working어") == "working")
+        #expect(RecordingEngine.normalizedRealtimeTranscript(" \n ") == nil)
+        #expect(RecordingEngine.normalizedRealtimeTranscript(nil) == nil)
+    }
+
+    @Test("Unsafe English realtime text is not eligible for fast-path paste")
+    func unsafeRealtimeTextRejectedForFastPath() {
+        #expect(RecordingEngine.isSafeRealtimeFastPathText(
+            rawText: "Actually 리수 Zoom your goal",
+            cleanedText: "Actually Zoom your goal",
+            language: "en"
+        ) == false)
+        #expect(RecordingEngine.isSafeRealtimeFastPathText(
+            rawText: "Actually Zoom your goal",
+            cleanedText: "Actually Zoom your goal",
+            language: "en"
+        ))
+    }
 }

package/src/native/Recordings/build.sh

@@ -16,9 +16,10 @@ BUILD_DIR=".build/$MODE"
 APP_DIR="$BUILD_DIR/Recordings.app"
 CONTENTS="$APP_DIR/Contents"
 MACOS="$CONTENTS/MacOS"
+RESOURCES="$CONTENTS/Resources"
 
 rm -rf "$APP_DIR"
-mkdir -p "$MACOS"
+mkdir -p "$MACOS" "$RESOURCES"
 
 # Copy binary
 cp "$BUILD_DIR/App" "$MACOS/Recordings"
@@ -26,6 +27,13 @@ cp "$BUILD_DIR/App" "$MACOS/Recordings"
 # Copy Info.plist
 cp RecordingsLib/Info.plist "$CONTENTS/Info.plist"
 
+# Copy SwiftPM resource bundles used by Bundle.module.
+for bundle in "$BUILD_DIR"/*.resources "$BUILD_DIR"/*.bundle .build/*/"$MODE"/*.resources .build/*/"$MODE"/*.bundle; do
+    [ -e "$bundle" ] || continue
+    rm -rf "$RESOURCES/$(basename "$bundle")"
+    ditto "$bundle" "$RESOURCES/$(basename "$bundle")"
+done
+
 # Copy entitlements (for codesigning)
 if [ -f RecordingsLib/Recordings.entitlements ]; then
     codesign --force --sign - --entitlements RecordingsLib/Recordings.entitlements "$APP_DIR" 2>/dev/null || true