@hasna/recordings 0.3.13 → 0.4.0

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

@@ -8,7 +8,7 @@ struct CLIRunnerTests {
     func bundledCLIIsPreferred() throws {
         let root = FileManager.default.temporaryDirectory
             .appendingPathComponent("recordings-bundled-cli-\(UUID().uuidString)")
-        let app = root.appendingPathComponent("HasnaRecordings.app")
+        let app = root.appendingPathComponent("Hasna Recordings.app")
         let helper = app.appendingPathComponent("Contents/Helpers/recordings")
         let home = root.appendingPathComponent("home")
         let external = home.appendingPathComponent(".bun/bin/recordings")
@@ -34,7 +34,7 @@ struct CLIRunnerTests {
     func packagedAppDoesNotUseGlobalFallback() throws {
         let root = FileManager.default.temporaryDirectory
             .appendingPathComponent("recordings-missing-companion-\(UUID().uuidString)")
-        let app = root.appendingPathComponent("HasnaRecordings.app")
+        let app = root.appendingPathComponent("Hasna Recordings.app")
         let home = root.appendingPathComponent("home")
         let external = home.appendingPathComponent(".bun/bin/recordings")
         try FileManager.default.createDirectory(at: app, withIntermediateDirectories: true)
@@ -1275,6 +1275,12 @@ struct CLIRunnerTests {
         #expect(CLIRunner.parseError(input) == "OpenAI quota exceeded — check the OpenAI account billing")
     }
 
+    @Test("Service authentication and quota errors identify the Recordings API")
+    func serviceErrors() {
+        #expect(CLIRunner.parseError("ERROR: 401 Unauthorized", serviceAPI: true) == "Recordings API authentication failed — check the API connection in Settings")
+        #expect(CLIRunner.parseError("ERROR: 429 Too Many Requests", serviceAPI: true) == "Recordings API request limit reached — try again later")
+    }
+
     @Test("parseError truncates long messages to 120 chars")
     func truncation() {
         let longMsg = String(repeating: "a", count: 200)
@@ -1297,9 +1303,12 @@ struct CLIRunnerTests {
         #expect(result?.contains(token) == false)
         #expect(result?.contains("[REDACTED]") == true)
 
+        let plainFixture = "plain-synthetic-secret"
+        let clientFixture = "client-synthetic-secret"
+        let passwordFixture = "password-synthetic-secret"
         let structured = CLIRunner.parseError(
-            "ERROR: OPENAI_API_KEY=plain-synthetic-secret CLIENT_SECRET=client-synthetic-secret "
-                + "PASSWORD=password-synthetic-secret payload={\"api_key\":\"json-synthetic-secret\","
+            "ERROR: OPENAI_API_KEY=\(plainFixture) CLIENT_SECRET=\(clientFixture) "
+                + "PASSWORD=\(passwordFixture) payload={\"api_key\":\"json-synthetic-secret\","
                 + "\"private_key\":\"private-synthetic-secret\"}"
         )
         #expect(structured?.contains("plain-synthetic-secret") == false)

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

@@ -86,7 +86,8 @@ struct OpenAIAPIKeyStoreTests {
             .appendingPathComponent("hasnaxyz")
             .appendingPathComponent("openai")
         try FileManager.default.createDirectory(at: secretDir, withIntermediateDirectories: true)
-        try "export OPENAI_API_KEY='secret-key'\n".write(
+        let fixture = "secret-key"
+        try "export OPENAI_API_KEY='\(fixture)'\n".write(
             to: secretDir.appendingPathComponent("live.env"),
             atomically: true,
             encoding: .utf8
@@ -100,53 +101,57 @@ struct OpenAIAPIKeyStoreTests {
         #expect(key == "secret-key")
     }
 
-    @Test("Saving a key writes it to config.json so the CLI uses the same key")
-    func saveWritesConfig() throws {
+    @Test("Keychain key precedes legacy preferences and config")
+    func keychainPrecedence() throws {
         let home = try makeHome()
-
-        try OpenAIAPIKeyStore.save(key: "sk-new-key", homePath: home.path)
-
-        let key = OpenAIAPIKeyStore.load(
-            homePath: home.path,
-            environment: [:],
-            userDefaultKey: nil
-        )
-        #expect(key == "sk-new-key")
+        try writeConfig(home: home, ["openai_api_key": "old-config"])
+        #expect(OpenAIAPIKeyStore.load(homePath: home.path, environment: [:],
+            userDefaultKey: "old-default", keychainLoader: { "keychain-fixture" }) == "keychain-fixture")
     }
 
-    @Test("Saving a key preserves unrelated config.json fields")
-    func savePreservesOtherFields() throws {
+    @Test("Save writes only Keychain and removes legacy plaintext while preserving settings")
+    func secureSave() throws {
         let home = try makeHome()
-        try writeConfig(home: home, [
-            "openai_api_key": "old-key",
-            "transcription_model": "gpt-4o-transcribe",
-        ])
-
-        try OpenAIAPIKeyStore.save(key: "sk-rotated", homePath: home.path)
-
-        let configURL = home
-            .appendingPathComponent(".hasna")
-            .appendingPathComponent("recordings")
-            .appendingPathComponent("config.json")
-        let data = try Data(contentsOf: configURL)
+        let suite = "provider-test-\(UUID().uuidString)"
+        let defaults = try #require(UserDefaults(suiteName: suite))
+        defer { defaults.removePersistentDomain(forName: suite) }
+        defaults.set("old-default", forKey: "openAIAPIKey")
+        try writeConfig(home: home, ["openai_api_key": "old-key", "api_key": "older-key",
+            "transcription_model": "gpt-4o-transcribe"])
+        var stored = ""
+        try OpenAIAPIKeyStore.save(key: "  keychain-fixture  ", homePath: home.path,
+            defaults: defaults, keychainWriter: { stored = $0 })
+        #expect(stored == "keychain-fixture")
+        #expect(defaults.string(forKey: "openAIAPIKey") == nil)
+        let data = try Data(contentsOf: home.appendingPathComponent(".hasna/recordings/config.json"))
         let json = try #require(JSONSerialization.jsonObject(with: data) as? [String: Any])
-        #expect(json["openai_api_key"] as? String == "sk-rotated")
+        #expect(json["openai_api_key"] == nil)
+        #expect(json["api_key"] == nil)
         #expect(json["transcription_model"] as? String == "gpt-4o-transcribe")
+        #expect(String(data: data, encoding: .utf8)?.contains(stored) == false)
     }
 
-    @Test("Saving an empty key removes it from config.json")
-    func saveEmptyRemovesKey() throws {
+    @Test("Keychain failure preserves existing configuration")
+    func failedSave() throws {
         let home = try makeHome()
-        try writeConfig(home: home, ["openai_api_key": "old-key"])
-
-        try OpenAIAPIKeyStore.save(key: "   ", homePath: home.path)
+        try writeConfig(home: home, ["openai_api_key": "legacy-fixture"])
+        #expect(throws: OpenAIAPIKeyStore.KeychainFailure.self) {
+            try OpenAIAPIKeyStore.save(key: "new-fixture", homePath: home.path,
+                keychainWriter: { _ in throw OpenAIAPIKeyStore.KeychainFailure(status: -50) })
+        }
+        #expect(OpenAIAPIKeyStore.load(homePath: home.path, environment: [:], userDefaultKey: nil) == "legacy-fixture")
+    }
 
-        let key = OpenAIAPIKeyStore.load(
-            homePath: home.path,
-            environment: [:],
-            userDefaultKey: nil
-        )
-        #expect(key == "")
+    @Test("Provider key reaches the helper without becoming service authentication")
+    func separateProviderEnvironment() {
+        let result = OpenAIAPIKeyStore.childEnvironment(base: [
+            "RECORDINGS_API_KEY": "provider-fixture",
+            "HASNA_RECORDINGS_API_KEY_OVERRIDE": "service-fixture",
+        ], homePath: "/tmp/test-home", keyLoader: { "provider-fixture" })
+        #expect(result["RECORDINGS_API_KEY"] == nil)
+        #expect(result["OPENAI_API_KEY"] == "provider-fixture")
+        #expect(result["RECORDINGS_OPENAI_API_KEY"] == "provider-fixture")
+        #expect(result["HASNA_RECORDINGS_API_KEY_OVERRIDE"] == "service-fixture")
     }
 
     private func makeHome() throws -> URL {

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

@@ -0,0 +1,60 @@
+import Foundation
+import Testing
+@testable import RecordingsLib
+
+struct CaptureMonitorTests {
+    @Test func pauseExcludesAudioAndDuration() {
+        let monitor = CaptureMonitor()
+        let chunk = Data(repeating: 64, count: 4_800)
+        #expect(monitor.admit(chunk))
+        monitor.setPaused(true)
+        #expect(!monitor.admit(chunk))
+        #expect(monitor.snapshot().duration == 0.1)
+        monitor.setPaused(false)
+        #expect(monitor.admit(chunk))
+        #expect(monitor.snapshot().duration == 0.2)
+    }
+
+    @Test func meterReflectsActualPCM() {
+        let monitor = CaptureMonitor()
+        #expect(monitor.admit(Data(repeating: 0, count: 4_800)))
+        #expect(monitor.snapshot().level == 0)
+        #expect(monitor.admit(Data(repeating: 64, count: 4_800)))
+        #expect(monitor.snapshot().level > 0.5)
+    }
+}
+
+@MainActor
+struct RecorderSurfaceDeliveryTests {
+    @Test func discardingPausedCaptureRestoresIdleControls() {
+        let engine = RecordingEngine(homePath: makeIsolatedTestHome("discard-paused"), installsGlobalHandlers: false)
+        engine.configureVisualPreview()
+        engine.togglePause()
+        engine.cancelRecording()
+        #expect(!engine.isPaused)
+        #expect(engine.recordingDuration == 0)
+        #expect(engine.audioLevel == 0)
+    }
+
+    @Test func disabledAutoPasteNeverReachesPasteBoundary() async {
+        let engine = RecordingEngine(homePath: makeIsolatedTestHome("auto-paste-off"))
+        engine.autoPasteEnabled = false
+        defer { engine.autoPasteEnabled = true }
+        var pasted = false
+        engine.pasteInterceptorForTesting = { _, _, _ in pasted = true }
+        let generation = engine.beginPipelineForTesting()
+        await withCheckedContinuation { (continuation: CheckedContinuation<Void, Never>) in
+            engine.finishWithText("Blue sky", rawTranscript: "Blue sky", targetAppBundleIdentifier: nil,
+                targetAppPid: nil, selectionToken: nil, canonicalProjectId: nil, activeProjectId: nil,
+                activeProjectName: nil,
+                processingConfiguration: RecordingProcessingConfiguration(transcriptionPrompt: "", transcriberPrompt: "",
+                    postProcessingMode: "off", transcriptionLanguage: "en", transcriptionModel: "test", transcriberModel: "test",
+                    enhancementModel: "test", intentModel: "test", intentDetectionEnabled: false,
+                    enhanceTriggersJSON: "[]", keywordTransformsJSON: "{}"),
+                pipelineTrace: nil, pipelineGeneration: generation, deliveryCompleted: { continuation.resume() })
+        }
+        #expect(!pasted)
+        #expect(engine.recentTranscriptions.first?.displayText == "Blue sky")
+        #expect(engine.statusMessage == "Transcript ready — auto-paste is off")
+    }
+}

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

@@ -0,0 +1,26 @@
+import Foundation
+import Testing
+@testable import RecordingsLib
+
+struct RecordingDateTests {
+    @Test("History accepts PostgreSQL, ISO, and SQLite dates", arguments: [
+        "2026-09-06 10:52:42.523193+00",
+        "2026-09-06 10:52:42+00",
+        "2026-09-06 16:22:42.523193+05:30",
+        "2026-09-06 16:22:42+0530",
+        "2026-09-06 06:52:42-04",
+        "2026-09-06T10:52:42.523Z",
+        "2026-09-06T10:52:42Z",
+        "2026-09-06 10:52:42",
+    ])
+    func supportedDates(value: String) throws {
+        let expected = try #require(ISO8601DateFormatter().date(from: "2026-09-06T10:52:42Z"))
+        let actual = try #require(Recording.parseDate(value))
+        #expect(abs(actual.timeIntervalSince(expected)) < 1)
+    }
+
+    @Test("Missing and invalid dates remain absent", arguments: ["", "invalid", "2026-09-06 10:52:42+99"])
+    func invalidDates(value: String) {
+        #expect(Recording.parseDate(value) == nil)
+    }
+}

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

@@ -0,0 +1,195 @@
+import AVFoundation
+import Foundation
+import Testing
+@testable import RecordingsLib
+
+private final class ProviderTestRecorder: PCMRecordingSource, @unchecked Sendable {
+    private let lock = NSLock()
+    private var callback: (@Sendable (Data) -> Void)?
+    private(set) var stopped = false
+    func attach(_ callback: @escaping @Sendable (Data) -> Void) { lock.withLock { self.callback = callback } }
+    func emit(_ data: Data) { lock.withLock { callback }?(data) }
+    func start() throws {}
+    func stop() { lock.withLock { stopped = true } }
+}
+
+private final class ProviderTestSession: RecordingTranscriptionSession, @unchecked Sendable {
+    private let lock = NSLock()
+    private var audio = Data()
+    private var request: RecordingTranscriptionRequest?
+    private var partial: (@Sendable (String) -> Void)?
+    private var cancelled = false
+    private var gate: CheckedContinuation<RecordingProviderResult, Never>?
+    let delayFinish: Bool
+
+    init(delayFinish: Bool = false) { self.delayFinish = delayFinish }
+    var snapshot: (Data, RecordingTranscriptionRequest?, Bool) { lock.withLock { (audio, request, cancelled) } }
+    func configure(_ partial: @escaping @Sendable (String) -> Void) { lock.withLock { self.partial = partial } }
+    func emitPartial(_ text: String) { lock.withLock { partial }?(text) }
+    func appendPCM(_ data: Data) { lock.withLock { if !cancelled { audio.append(data) } } }
+    func finish(_ request: RecordingTranscriptionRequest) async throws -> RecordingProviderResult {
+        if delayFinish {
+            return await withCheckedContinuation { continuation in
+                lock.withLock { self.request = request; gate = continuation }
+            }
+        }
+        lock.withLock { self.request = request }
+        return RecordingProviderResult(rawText: "spoken words", processedText: "Spoken words.")
+    }
+    func cancel() { lock.withLock { cancelled = true } }
+    func resolve() {
+        let continuation = lock.withLock { let value = gate; gate = nil; return value }
+        continuation?.resume(returning: RecordingProviderResult(rawText: "late result"))
+    }
+}
+
+private struct ProviderTestAdapter: RecordingTranscriptionProvider {
+    let session: ProviderTestSession
+    func makeSession(configuration: RecordingProviderSessionConfiguration, onPartialTranscript: @escaping @Sendable (String) -> Void) throws -> any RecordingTranscriptionSession {
+        #expect(configuration.sampleRate == 24_000)
+        #expect(configuration.channels == 1)
+        #expect(configuration.bitsPerSample == 16)
+        session.configure(onPartialTranscript)
+        return session
+    }
+}
+
+@MainActor
+struct RecordingProviderTests {
+    private func engine(_ session: ProviderTestSession, recorder: ProviderTestRecorder, suite: String = "recordings-provider-tests-\(UUID().uuidString)") throws -> RecordingEngine {
+        let configuration = try RecordingEngineConfiguration(isolatedHomePath: makeIsolatedTestHome("provider"), preferencesSuiteName: suite)
+        let engine = RecordingEngine(configuration: configuration, transcriptionProvider: ProviderTestAdapter(session: session))
+        engine.autoPasteEnabled = false
+        engine.microphoneAuthorization = { .authorized }
+        engine.accessibilityTrustCheck = { false }
+        engine.frontmostAppSnapshot = { nil }
+        engine.focusedWindowTitleLookup = { _ in nil }
+        engine.openAIAPIKeyProvider = { Issue.record("Isolated provider consulted legacy credentials"); return "" }
+        engine.commandCLI = { _, _, _ in Issue.record("Isolated provider launched legacy CLI"); return "ERROR: forbidden" }
+        engine.recorderFactory = { callback in recorder.attach(callback); return recorder }
+        return engine
+    }
+
+    private func eventually(_ condition: @MainActor () -> Bool) async -> Bool {
+        for _ in 0..<200 {
+            if condition() { return true }
+            try? await Task.sleep(for: .milliseconds(10))
+        }
+        return condition()
+    }
+
+    @Test("PCM streams before stop, pause excludes samples, and the final WAV matches the stream")
+    func liveStreamingAndPause() async throws {
+        let session = ProviderTestSession()
+        let recorder = ProviderTestRecorder()
+        let engine = try engine(session, recorder: recorder)
+        engine.startRecording()
+        let first = Data(repeating: 1, count: 4_800)
+        recorder.emit(first)
+        #expect(await eventually { engine.isRecording && session.snapshot.0 == first })
+        #expect(session.snapshot.1 == nil, "Streaming must precede finish")
+        session.emitPartial("spoken")
+        #expect(await eventually { engine.liveTranscriptionText == "spoken" })
+        engine.togglePause()
+        recorder.emit(Data(repeating: 9, count: 4_800))
+        engine.togglePause()
+        let tail = Data(repeating: 2, count: 1_600)
+        recorder.emit(tail)
+        engine.stopAndTranscribe()
+        #expect(await eventually { !engine.isTranscribing })
+        let request = try #require(session.snapshot.1)
+        #expect(session.snapshot.0 == first + tail)
+        #expect(request.duration == Double(6_400) / 48_000)
+        let wav = try Data(contentsOf: request.audioURL)
+        #expect(String(data: wav.prefix(4), encoding: .utf8) == "RIFF")
+        #expect(Data(wav.dropFirst(44)) == first + tail)
+        let transcript = try #require(engine.recentTranscriptions.first)
+        #expect(transcript.captureID == request.captureID)
+        #expect(transcript.audioURL == request.audioURL)
+        #expect(transcript.rawText == "spoken words")
+        #expect(transcript.displayText == "Spoken words.")
+        #expect(engine.flowPhase == .ready("Transcript ready — auto-paste is off"))
+        #expect(engine.persistedRecordingRevision == 0, "An adapter result is not a persistence receipt")
+        #expect(recorder.stopped)
+    }
+
+    @Test("cancel during provider finalization drops late text and allows another capture")
+    func cancellationDropsStaleCompletions() async throws {
+        let session = ProviderTestSession(delayFinish: true)
+        let recorder = ProviderTestRecorder()
+        let engine = try engine(session, recorder: recorder)
+        engine.startRecording()
+        recorder.emit(Data(repeating: 1, count: 4_800))
+        #expect(await eventually { engine.isRecording })
+        engine.stopAndTranscribe()
+        #expect(await eventually { session.snapshot.1 != nil })
+        engine.cancelRecording()
+        #expect(session.snapshot.2)
+        #expect(engine.canStartRecording)
+        session.emitPartial("late partial")
+        session.resolve()
+        try await Task.sleep(for: .milliseconds(50))
+        #expect(engine.liveTranscriptionText.isEmpty)
+        #expect(engine.recentTranscriptions.isEmpty)
+        #expect(engine.flowPhase == .idle)
+    }
+
+    @Test("discard during warm-up cancels the provider without a final request")
+    func warmupCancellation() throws {
+        let session = ProviderTestSession()
+        let recorder = ProviderTestRecorder()
+        let engine = try engine(session, recorder: recorder)
+        engine.startRecording()
+        engine.cancelRecording()
+        #expect(session.snapshot.2)
+        #expect(session.snapshot.1 == nil)
+        #expect(engine.canStartRecording)
+        #expect(recorder.stopped)
+    }
+
+    @Test("preferences are persistent per candidate suite and never write the legacy defaults")
+    func preferencesIsolation() throws {
+        let keys = ["useFnKey", "intentDetectionEnabled", "recordingsAutoPaste", "recordingsLanguage"]
+        let before = keys.map { UserDefaults.standard.object(forKey: $0) as? NSObject }
+        let firstSuite = "recordings-provider-tests-\(UUID().uuidString)"
+        let secondSuite = "recordings-provider-tests-\(UUID().uuidString)"
+        defer {
+            UserDefaults(suiteName: firstSuite)?.removePersistentDomain(forName: firstSuite)
+            UserDefaults(suiteName: secondSuite)?.removePersistentDomain(forName: secondSuite)
+        }
+        let first = try engine(ProviderTestSession(), recorder: ProviderTestRecorder(), suite: firstSuite)
+        first.useFnKey = true // Must not install any monitor even when the preference changes.
+        first.intentDetectionEnabled = true
+        first.transcriptionLanguage = "ro"
+        first.autoPasteEnabled = true
+        let second = try engine(ProviderTestSession(), recorder: ProviderTestRecorder(), suite: secondSuite)
+        #expect(!second.useFnKey)
+        #expect(!second.intentDetectionEnabled)
+        #expect(second.transcriptionLanguage == "en")
+        let reloaded = try engine(ProviderTestSession(), recorder: ProviderTestRecorder(), suite: firstSuite)
+        #expect(reloaded.useFnKey)
+        #expect(reloaded.intentDetectionEnabled)
+        #expect(reloaded.transcriptionLanguage == "ro")
+        #expect(keys.map { UserDefaults.standard.object(forKey: $0) as? NSObject } == before)
+        #expect(!FileManager.default.fileExists(atPath: "\(first.home)/.hasna/recordings/config.json"))
+    }
+
+    @Test("the isolated initializer rejects the installed app's state and defaults")
+    func rejectsLiveRoots() throws {
+        #expect(throws: RecordingProviderError.self) {
+            try RecordingEngineConfiguration(isolatedHomePath: FileManager.default.homeDirectoryForCurrentUser.path, preferencesSuiteName: "candidate")
+        }
+        #expect(throws: RecordingProviderError.self) {
+            try RecordingEngineConfiguration(isolatedHomePath: makeIsolatedTestHome("provider"), preferencesSuiteName: "com.hasna.recordings")
+        }
+    }
+
+    @Test("public paste receipts distinguish an unverified post from evidence of failure")
+    func typedPasteOutcomes() {
+        #expect(RecordingEngine.recentPasteDeliveryStatus(for: .pasted) == .confirmed)
+        #expect(RecordingEngine.recentPasteDeliveryStatus(for: .deliveredUnverified(.readBackNotAttempted)) == .unconfirmed)
+        #expect(RecordingEngine.recentPasteDeliveryStatus(for: .deliveryNotObserved) == .notDelivered)
+        #expect(RecordingEngine.recentPasteDeliveryStatus(for: .clipboardWriteFailed) == .notDelivered)
+        #expect(RecordingEngine.recentPasteDeliveryStatus(for: .targetUnavailable) == .notDelivered)
+    }
+}

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

@@ -6,7 +6,7 @@ struct RecordingStartGateTests {
     @Test("permission-only launch skips global handlers and terminates after handling")
     func permissionHelperLaunchPlan() {
         let plan = PermissionRequestLaunchPlan(arguments: [
-            "/Applications/HasnaRecordings.app/Contents/MacOS/Recordings",
+            "/Applications/Hasna Recordings.app/Contents/MacOS/Recordings",
             "--request-permissions",
             "--open-permission-settings",
         ])

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

@@ -11,8 +11,14 @@ private final class FakePCMRecorder: PCMRecordingSource, @unchecked Sendable {
     private let lock = NSLock()
     private var startedFlag = false
     private var stoppedFlag = false
+    private var stoppingFlag = false
+    private let stopGate: DispatchSemaphore?
     private var onPCM: (@Sendable (Data) -> Void)?
 
+    init(stopGate: DispatchSemaphore? = nil) { self.stopGate = stopGate }
+
+    var isStopping: Bool { lock.withLock { stoppingFlag } }
+
     var started: Bool {
         lock.withLock { startedFlag }
     }
@@ -46,6 +52,8 @@ private final class FakePCMRecorder: PCMRecordingSource, @unchecked Sendable {
     }
 
     func stop() {
+        lock.withLock { stoppingFlag = true }
+        _ = stopGate?.wait(timeout: .now() + 2)
         lock.withLock { stoppedFlag = true }
     }
 }
@@ -188,6 +196,28 @@ struct RecordingStartTimingTests {
         #expect(engine.canStartRecording)
     }
 
+    @Test("slow microphone shutdown keeps the UI responsive and finishes draining before transcription")
+    func stopDoesNotBlockMainActor() async {
+        let stopGate = DispatchSemaphore(value: 0)
+        let recorder = FakePCMRecorder(stopGate: stopGate)
+        let engine = makeStartableEngine(recorder: recorder)
+        engine.startRecording(trigger: .manual)
+        #expect(await confirmCapture(engine, recorder))
+
+        let started = ContinuousClock.now
+        engine.stopAndTranscribe()
+        #expect(ContinuousClock.now - started < .milliseconds(300))
+        #expect(await waitUntil { recorder.isStopping })
+        #expect(engine.isTranscribing)
+        #expect(!engine.canStartRecording)
+        #expect(!recorder.isStopped)
+
+        stopGate.signal()
+        #expect(await waitUntil { !engine.isTranscribing })
+        #expect(recorder.isStopped)
+        #expect(engine.statusMessage == "No audio captured")
+    }
+
     @Test("a released key before the capture resolves still cancels cleanly")
     func cancelDuringPendingCapture() async {
         let captureGate = DispatchSemaphore(value: 0)

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

@@ -0,0 +1,75 @@
+import Foundation
+import Testing
+@testable import RecordingsLib
+
+struct ServiceAPIConfigurationTests {
+    @Test("a configurable service prefix keeps exactly one v1 segment", arguments: [
+        "https://api.example.com/recordings", "https://api.example.com/recordings/v1/",
+    ])
+    func normalizesServicePrefix(_ input: String) throws {
+        #expect(try ServiceAPIConfiguration.normalizedURL(input) == "https://api.example.com/recordings/v1")
+    }
+
+    @Test("invalid or credential-bearing URLs are rejected", arguments: [
+        "", "https://user:password@example.com/v1", "http://example.com/v1",
+        "https://example.com/v1?key=value", "https://example.com/v1#fragment",
+    ])
+    func rejectsUnsafeURL(_ input: String) {
+        #expect(throws: (any Error).self) { try ServiceAPIConfiguration.normalizedURL(input) }
+    }
+
+    @Test("Finder launches receive saved routing and an endpoint-bound Keychain credential")
+    func savedConnectionEnvironment() throws {
+        let suite = "recordings-api-test-\(UUID().uuidString)"
+        let defaults = try #require(UserDefaults(suiteName: suite))
+        defer { defaults.removePersistentDomain(forName: suite) }
+        defaults.set("https://service.example.test/recordings/v1/", forKey: ServiceAPIConfiguration.defaultsKey)
+        var lookedUp: [String] = []
+        let environment = try ServiceAPIConfiguration.childEnvironment(base: ["PATH": "/bin"], defaults: defaults) { endpoint in
+            lookedUp.append(endpoint)
+            return "fixture-service-credential"
+        }
+        #expect(lookedUp == ["https://service.example.test/recordings/v1"])
+        #expect(environment["HASNA_RECORDINGS_API_URL"] == lookedUp.first)
+        #expect(environment["HASNA_RECORDINGS_CLIENT_STORE"] == nil)
+        #expect(environment["HASNA_RECORDINGS_API_KEY_OVERRIDE"] != nil)
+        #expect(environment["OPENAI_API_KEY"] == nil)
+        #expect(environment["PATH"] == "/bin")
+        #expect(defaults.string(forKey: "HASNA_RECORDINGS_API_KEY_OVERRIDE") == nil)
+        for base in [["HASNA_RECORDINGS_API_URL": "https://another.example.test/v1"], ["HASNA_RECORDINGS_LOCAL": "1"], ["RECORDINGS_LOCAL": "1"]] {
+            let overridden = try ServiceAPIConfiguration.childEnvironment(base: base, defaults: defaults) { _ in
+                Issue.record("Environment routing must not read the saved endpoint credential")
+                return nil
+            }
+            #expect(overridden == base)
+        }
+    }
+
+    @Test("an unconfigured native client invents no endpoint or local fallback")
+    func noDefaultEndpoint() throws {
+        let suite = "recordings-empty-api-test-\(UUID().uuidString)"
+        let defaults = try #require(UserDefaults(suiteName: suite))
+        defer { defaults.removePersistentDomain(forName: suite) }
+        #expect(try ServiceAPIConfiguration.childEnvironment(base: [:], defaults: defaults) { _ in
+            Issue.record("No endpoint is configured")
+            return nil
+        }.isEmpty)
+    }
+
+    @MainActor
+    @Test("global recording preferences ignore legacy project selections and prompts")
+    func ignoresLegacyProjects() {
+        let home = makeIsolatedTestHome("global-recording-preferences")
+        let preferences = ProjectStore(filePath: "\(home)/projects.json")
+        preferences.settings.globalSystemPrompt = "Global cleanup"
+        preferences.settings.postProcessingMode = "always"
+        preferences.settings.projects = [RecProject(id: "legacy", name: "Legacy", systemPrompt: "Project cleanup")]
+        preferences.settings.activeProjectId = "legacy"
+        let engine = RecordingEngine(homePath: home, installsGlobalHandlers: false)
+        engine.globalRecordingPreferences = preferences
+        #expect(engine.projectStore == nil)
+        #expect(engine.recordingCleanupPreferences.prompt == "Global cleanup")
+        #expect(engine.recordingCleanupPreferences.mode == "always")
+        #expect(preferences.settings.activeProjectId == "legacy")
+    }
+}

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

@@ -0,0 +1,28 @@
+import AppKit
+import Testing
+@testable import RecordingsLib
+
+@MainActor
+struct SettingsWindowControllerTests {
+    @Test("Settings creates one window and reopens it after closing")
+    func reusesSettingsWindow() {
+        let policy = NSApplication.shared.activationPolicy()
+        var creations = 0
+        let controller = SettingsWindowController {
+            creations += 1
+            return NSView(frame: NSRect(x: 0, y: 0, width: 520, height: 500))
+        }
+        #expect(creations == 0)
+        let first = controller.show()
+        defer { first.close() }
+        #expect(first.isVisible)
+        #expect(first.title == "Hasna Recordings Settings")
+        first.close()
+        #expect(!first.isVisible)
+        let reopened = controller.show()
+        #expect(reopened === first)
+        #expect(reopened.isVisible)
+        #expect(creations == 1)
+        #expect(NSApplication.shared.activationPolicy() == policy)
+    }
+}

package/src/native/Recordings/Updater/BootstrapPreflight/BootstrapPreflightMain.swift

@@ -51,7 +51,7 @@ enum RecordingsBootstrapPreflight {
         let manifest = try JSONDecoder().decode(ReleaseManifest.self, from: manifestData)
         try validateManifest(manifest, payload: payload)
 
-        let app = arguments.payloadRoot + "/Applications/HasnaRecordings.app"
+        let app = arguments.payloadRoot + "/Applications/Hasna Recordings.app"
         let client = app + "/" + RecordingsUpdateConstants.updateClientRelativePath
         let broker = arguments.payloadRoot + "/Library/PrivilegedHelperTools/com.hasna.recordings.updater"
         let artifactVerifier = arguments.payloadRoot

package/src/native/Recordings/Updater/Broker/ApplicationNamespace.swift

@@ -7,7 +7,7 @@ import RecordingsUpdateProtocol
 /// operation; first installs use exclusive rename semantics and can never replace a
 /// leaf created concurrently in `/Applications`.
 final class ApplicationNamespace {
-    private static let liveLeaf = "HasnaRecordings.app"
+    private static let liveLeaf = "Hasna Recordings.app"
     private static let previousLeaf = "previous.app"
     private static let failedCandidateLeaf = "failed-candidate.app"
 
@@ -22,7 +22,7 @@ final class ApplicationNamespace {
             .deletingLastPathComponent
         guard journal.applicationPath == RecordingsUpdateConstants.applicationPath,
               journal.candidateApplicationPath == expectedTransactionDirectory
-                + "/candidate/HasnaRecordings.app",
+                + "/candidate/Hasna Recordings.app",
               journal.previousApplicationPath == nil ||
                 journal.previousApplicationPath == expectedTransactionDirectory + "/previous.app"
         else {

package/src/native/Recordings/Updater/Broker/BrokerMain.swift

@@ -276,7 +276,7 @@ final class UpdateBrokerSession: NSObject, RecordingsUpdateXPCProtocol {
         guard mkdir(candidateRoot, 0o700) == 0 else {
             throw BrokerOperationError.candidateRejected
         }
-        let candidateApplication = candidateRoot + "/HasnaRecordings.app"
+        let candidateApplication = candidateRoot + "/Hasna Recordings.app"
         let verifierIDs = try verifierAccountIDs()
         try CanonicalTreeCopier.copyApplication(
             from: verifierOutput,

package/src/native/Recordings/Updater/Broker/CanonicalTreeCopy.swift

@@ -22,7 +22,7 @@ enum CanonicalTreeCopier {
         }
         defer { Darwin.close(source) }
         let destinationRoot = URL(fileURLWithPath: rootCandidatePath).deletingLastPathComponent().path
-        guard URL(fileURLWithPath: rootCandidatePath).lastPathComponent == "HasnaRecordings.app" else {
+        guard URL(fileURLWithPath: rootCandidatePath).lastPathComponent == "Hasna Recordings.app" else {
             throw CanonicalCopyError.nonCanonicalRoot
         }
         let destination = Darwin.open(