@hasna/recordings 0.3.13 → 0.5.0

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

@@ -0,0 +1,308 @@
+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 let stopPCM: Data
+    private(set) var stopped = false
+    init(stopPCM: Data = Data()) { self.stopPCM = stopPCM }
+    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() {
+        let delivery = lock.withLock { () -> (@Sendable (Data) -> Void)? in
+            guard !stopped else { return nil }
+            stopped = true
+            return callback
+        }
+        if !stopPCM.isEmpty { delivery?(stopPCM) }
+    }
+}
+
+private final class ProviderTestSession: RecordingTranscriptionSession, @unchecked Sendable {
+    private let lock = NSLock()
+    private var audio = Data()
+    private var packets: [Data] = []
+    private var request: RecordingTranscriptionRequest?
+    private var partial: (@Sendable (String) -> Void)?
+    private var cancelled = false
+    private var inputEndings: [Data] = []
+    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) } }
+    var endedPCM: [Data] { lock.withLock { inputEndings } }
+    var receivedPackets: [Data] { lock.withLock { packets } }
+    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); packets.append(data) } }
+    }
+    func inputEnded() { lock.withLock { if !cancelled { inputEndings.append(audio) } } }
+    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(session.endedPCM == [first + tail], "Input ends exactly once after the short tail, before file-based finish")
+        #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("A paused provider receives the entire first packet without waiting for a network chunk or Stop",
+          arguments: [2, 1_600, 3_888, 4_800, 4_802])
+    func subChunkPCMReachesProviderBeforeStop(byteCount: Int) async throws {
+        let session = ProviderTestSession()
+        let recorder = ProviderTestRecorder()
+        let engine = try engine(session, recorder: recorder)
+        defer { engine.cancelRecording() }
+        let pcm = Data((0..<byteCount).map { UInt8(truncatingIfNeeded: $0 * 17) })
+        engine.startRecording()
+        recorder.emit(pcm)
+        #expect(await eventually { engine.isRecording })
+        engine.togglePause()
+        recorder.emit(Data(repeating: 9, count: 4_800))
+        #expect(await eventually { session.snapshot.0 == pcm }, "Pause must not withhold a partial network chunk")
+        #expect(session.receivedPackets == [pcm])
+        #expect(session.endedPCM.isEmpty)
+        #expect(session.snapshot.1 == nil)
+
+        engine.stopAndTranscribe()
+        #expect(await eventually { !engine.isTranscribing })
+        let request = try #require(session.snapshot.1)
+        #expect(session.receivedPackets == [pcm], "Stop must not repeat already delivered PCM")
+        #expect(session.endedPCM == [pcm])
+        #expect(Data(try Data(contentsOf: request.audioURL).dropFirst(44)) == pcm)
+        #expect(request.duration == Double(pcm.count) / 48_000)
+    }
+
+    @Test("Pause and resume preserve packet order; an admitted converter tail precedes inputEnded",
+          arguments: [false, true])
+    func orderedPauseResumeAndConverterTail(stopWhilePaused: Bool) async throws {
+        let session = ProviderTestSession()
+        let converterTail = Data([0x10, 0x20, 0x30, 0x40])
+        let recorder = ProviderTestRecorder(stopPCM: converterTail)
+        let engine = try engine(session, recorder: recorder)
+        defer { engine.cancelRecording() }
+        let first = Data(repeating: 1, count: 4_800)
+        let pauseTail = Data(repeating: 2, count: 3_888)
+        let resumed = [Data([3, 4]), Data(repeating: 5, count: 4_798), Data(repeating: 6, count: 9_602)]
+        engine.startRecording()
+        recorder.emit(first)
+        #expect(await eventually { engine.isRecording && session.snapshot.0 == first })
+        recorder.emit(pauseTail)
+        engine.togglePause()
+        recorder.emit(Data(repeating: 9, count: 5_000))
+        #expect(await eventually { session.snapshot.0 == first + pauseTail })
+        #expect(session.receivedPackets == [first, pauseTail])
+        engine.togglePause()
+        recorder.emit(Data())
+        for packet in resumed { recorder.emit(packet) }
+        let beforeStopPackets = [first, pauseTail] + resumed
+        let beforeStopPCM = beforeStopPackets.reduce(into: Data()) { $0.append($1) }
+        #expect(await eventually { session.snapshot.0 == beforeStopPCM })
+        #expect(session.receivedPackets == beforeStopPackets)
+        #expect(session.endedPCM.isEmpty)
+        if stopWhilePaused { engine.togglePause() }
+
+        engine.stopAndTranscribe()
+        #expect(await eventually { !engine.isTranscribing })
+        let request = try #require(session.snapshot.1)
+        let expectedPackets = beforeStopPackets + (stopWhilePaused ? [] : [converterTail])
+        let expectedPCM = expectedPackets.reduce(into: Data()) { $0.append($1) }
+        #expect(session.receivedPackets == expectedPackets)
+        #expect(session.endedPCM == [expectedPCM], "All admitted PCM must arrive exactly once before inputEnded")
+        #expect(Data(try Data(contentsOf: request.audioURL).dropFirst(44)) == expectedPCM)
+        #expect(request.duration == Double(expectedPCM.count) / 48_000)
+        #expect(recorder.stopped)
+    }
+
+    @Test("explicit no-target capture saves transcript and records copy-only non-delivery without AX or a paste")
+    func frozenNoTargetReceipt() async throws {
+        for copied in [true, false] {
+            let session = ProviderTestSession()
+            let recorder = ProviderTestRecorder()
+            let engine = try engine(session, recorder: recorder)
+            engine.autoPasteEnabled = true
+            engine.protectedOperationTrust = { Issue.record("No-target delivery must not request Accessibility"); return AccessibilityTrustResult(trusted: false, didPrompt: false) }
+            var writes: [String] = []
+            engine.pasteFallbackWriter = { text in writes.append(text); return copied }
+            engine.startRecording(pasteTarget: .frozen(nil))
+            recorder.emit(Data(repeating: 1, count: 4_800))
+            #expect(await eventually { engine.isRecording })
+            engine.stopAndTranscribe()
+            #expect(await eventually { engine.recentPastes.count == 1 })
+            let transcript = try #require(engine.recentTranscriptions.first)
+            let receipt = try #require(engine.recentPastes.first)
+            #expect(receipt.captureID == transcript.captureID)
+            #expect(receipt.deliveryStatus == .notDelivered)
+            #expect(!receipt.verified)
+            #expect(receipt.bundleIdentifier == nil)
+            #expect(receipt.appName == "No target app")
+            #expect(receipt.location == (copied ? "Clipboard only" : ""))
+            #expect(writes == ["Spoken words."])
+            #expect(engine.canStartRecording)
+        }
+    }
+
+    @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 }
     }
 }
@@ -53,9 +61,24 @@ private final class FakePCMRecorder: PCMRecordingSource, @unchecked Sendable {
 @MainActor
 private func makeStartableEngine(
     recorder: FakePCMRecorder,
+    intentDetectionEnabled: Bool = false,
     selectionCapture: @escaping @Sendable (pid_t) -> AccessibilitySelectionToken? = { _ in nil }
 ) -> RecordingEngine {
-    let engine = RecordingEngine(homePath: makeIsolatedTestHome("start-timing-tests"))
+    let engine = RecordingEngine(homePath: makeIsolatedTestHome("start-timing-tests"), installsGlobalHandlers: false)
+    // The legacy engine persists this setting. Keep the explicit mode on this instance,
+    // restoring the exact application-domain value before another MainActor test can run.
+    // This factory and the restoration are synchronous: there is no suspension in between.
+    let defaults = UserDefaults.standard
+    let domain = Bundle.main.bundleIdentifier ?? ProcessInfo.processInfo.processName
+    let priorIntent = defaults.persistentDomain(forName: domain)?["intentDetectionEnabled"]
+    defer {
+        if let priorIntent {
+            defaults.set(priorIntent, forKey: "intentDetectionEnabled")
+        } else {
+            defaults.removeObject(forKey: "intentDetectionEnabled")
+        }
+    }
+    engine.intentDetectionEnabled = intentDetectionEnabled
     engine.openAIAPIKeyProvider = { "" }
     engine.microphoneAuthorization = { .authorized }
     engine.accessibilityTrustCheck = { true }
@@ -74,6 +97,27 @@ private func makeStartableEngine(
     return engine
 }
 
+/// An entered callback is essential evidence: with intent detection disabled the engine
+/// correctly skips selection capture, so merely installing a blocked closure proves nothing.
+private final class BlockedSelectionCapture: @unchecked Sendable {
+    private let lock = NSLock()
+    private let gate = DispatchSemaphore(value: 0)
+    private var capturedPIDs: [pid_t] = []
+    private var returned = false
+
+    var pids: [pid_t] { lock.withLock { capturedPIDs } }
+    var isPending: Bool { lock.withLock { !capturedPIDs.isEmpty && !returned } }
+
+    func capture(_ pid: pid_t) -> AccessibilitySelectionToken? {
+        lock.withLock { capturedPIDs.append(pid) }
+        gate.wait()
+        lock.withLock { returned = true }
+        return AccessibilitySelectionToken.unsafeTestToken(selectedText: "frozen words")
+    }
+
+    func release() { gate.signal() }
+}
+
 @MainActor
 private func waitUntil(
     timeout: TimeInterval = 5,
@@ -130,14 +174,12 @@ private func expectEmptyAttemptDisclosed(
 @MainActor
 struct RecordingStartTimingTests {
     @Test("the recorder starts on keydown even while the AX selection capture is blocked")
-    func recorderStartDoesNotWaitOnSelectionCapture() async {
-        let captureGate = DispatchSemaphore(value: 0)
+    func recorderStartDoesNotWaitOnSelectionCapture() async throws {
+        let capture = BlockedSelectionCapture()
+        defer { capture.release() }
         let recorder = FakePCMRecorder()
-        let engine = makeStartableEngine(recorder: recorder) { _ in
-            // Simulates a beachballing target app: the capture IPC hangs far longer than
-            // any acceptable start budget.
-            captureGate.wait()
-            return nil
+        let engine = makeStartableEngine(recorder: recorder, intentDetectionEnabled: true) { pid in
+            capture.capture(pid)
         }
 
         // `startRecording` runs synchronously on the MainActor through recorder start.
@@ -149,25 +191,29 @@ struct RecordingStartTimingTests {
         #expect(engine.isWarmingUpCapture, "start() returning is warm-up, not captured audio")
         #expect(engine.captureIsActive)
         #expect(engine.flowPhase == .listening)
+        try #require(await waitUntil { capture.isPending })
+        #expect(capture.pids == [99_999])
 
         #expect(await confirmCapture(engine, recorder))
         #expect(!engine.isWarmingUpCapture)
 
-        captureGate.signal()
+        capture.release()
         engine.cancelRecording()
         #expect(engine.flowPhase == .idle)
     }
 
     @Test("stopping waits for the generation-bound start context instead of dropping the frozen target")
-    func stopAwaitsFrozenStartContext() async {
-        let captureGate = DispatchSemaphore(value: 0)
+    func stopAwaitsFrozenStartContext() async throws {
+        let capture = BlockedSelectionCapture()
+        defer { capture.release() }
         let recorder = FakePCMRecorder()
-        let engine = makeStartableEngine(recorder: recorder) { _ in
-            captureGate.wait()
-            return AccessibilitySelectionToken.unsafeTestToken(selectedText: "frozen words")
+        let engine = makeStartableEngine(recorder: recorder, intentDetectionEnabled: true) { pid in
+            capture.capture(pid)
         }
 
         engine.startRecording(trigger: .manual)
+        try #require(await waitUntil { capture.isPending })
+        #expect(capture.pids == [99_999])
         #expect(await confirmCapture(engine, recorder))
         engine.stopAndTranscribe()
         #expect(engine.isTranscribing)
@@ -175,9 +221,10 @@ struct RecordingStartTimingTests {
         // The pipeline must hold in finalizing while the frozen context is unresolved —
         // it may not deliver without the selection frozen at start.
         try? await Task.sleep(for: .milliseconds(150))
+        #expect(capture.isPending)
         #expect(engine.flowPhase == .finalizing)
 
-        captureGate.signal()
+        capture.release()
         // No audio was produced by the fake recorder, so the pipeline ends in the
         // fail-closed no-audio state — importantly, only after the context resolved.
         #expect(await waitUntil {
@@ -188,20 +235,75 @@ struct RecordingStartTimingTests {
         #expect(engine.canStartRecording)
     }
 
+    @Test("intent detection disabled skips selection capture and can finish the empty attempt")
+    func disabledIntentDoesNotWaitForSelection() async throws {
+        let capture = BlockedSelectionCapture()
+        defer { capture.release() }
+        let recorder = FakePCMRecorder()
+        let engine = makeStartableEngine(recorder: recorder, intentDetectionEnabled: false) { pid in
+            capture.capture(pid)
+        }
+        engine.startRecording(trigger: .manual)
+        try #require(await confirmCapture(engine, recorder))
+        engine.stopAndTranscribe()
+        try #require(await waitUntil { !engine.isTranscribing })
+        #expect(capture.pids.isEmpty)
+        #expect(engine.flowPhase == .failed("No audio captured"))
+        #expect(engine.canStartRecording)
+    }
+
+    @Test("fixture intent modes stay on their engine without changing the process preference")
+    func fixtureIntentModeIsInstanceScoped() {
+        let defaults = UserDefaults.standard
+        let domain = Bundle.main.bundleIdentifier ?? ProcessInfo.processInfo.processName
+        let before = defaults.persistentDomain(forName: domain)?["intentDetectionEnabled"] as? NSObject
+        let enabled = makeStartableEngine(recorder: FakePCMRecorder(), intentDetectionEnabled: true)
+        #expect(enabled.intentDetectionEnabled)
+        #expect((defaults.persistentDomain(forName: domain)?["intentDetectionEnabled"] as? NSObject) == before)
+        let disabled = makeStartableEngine(recorder: FakePCMRecorder())
+        #expect(!disabled.intentDetectionEnabled)
+        #expect(enabled.intentDetectionEnabled)
+        #expect((defaults.persistentDomain(forName: domain)?["intentDetectionEnabled"] as? NSObject) == before)
+    }
+
+    @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)
+    func cancelDuringPendingCapture() async throws {
+        let capture = BlockedSelectionCapture()
+        defer { capture.release() }
         let recorder = FakePCMRecorder()
-        let engine = makeStartableEngine(recorder: recorder) { _ in
-            captureGate.wait()
-            return nil
+        let engine = makeStartableEngine(recorder: recorder, intentDetectionEnabled: true) { pid in
+            capture.capture(pid)
         }
         engine.startRecording(trigger: .manual)
+        try #require(await waitUntil { capture.isPending })
+        #expect(capture.pids == [99_999])
         #expect(await confirmCapture(engine, recorder))
         engine.cancelRecording()
         #expect(!engine.isRecording)
         #expect(engine.flowPhase == .idle)
-        captureGate.signal()
+        capture.release()
         #expect(engine.canStartRecording)
     }
 }

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/RecordingsTests/TestHomeDirectory.swift

@@ -16,7 +16,11 @@ import Foundation
 /// back only the engine and so have no scope to remove it from; `CLIRunnerTests` instead
 /// passes the temp home it already creates and already deletes.
 func makeIsolatedTestHome(_ label: String) -> String {
-    let url = FileManager.default.temporaryDirectory
+    // Foundation can ignore TMPDIR under the Darwin test-bundle launcher. An
+    // explicit fixture root keeps confined tests inside their owned write scope.
+    let root = ProcessInfo.processInfo.environment["RECORDINGS_TEST_TMP_ROOT"]
+        .map { URL(fileURLWithPath: $0, isDirectory: true) } ?? FileManager.default.temporaryDirectory
+    let url = root
         .appendingPathComponent("recordings-\(label)-\(UUID().uuidString)")
     try? FileManager.default.createDirectory(at: url, withIntermediateDirectories: true)
     return url.path