@hasna/recordings 0.3.13 → 0.5.0

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

@@ -0,0 +1,215 @@
+import Darwin
+import Foundation
+import Testing
+
+/// Test-only observation of the original pipes, independent of transient pre-exec copies.
+enum PipeClosureFixture {
+    static func now() -> UInt64 {
+        var value = timespec()
+        precondition(clock_gettime(CLOCK_MONOTONIC, &value) == 0)
+        return UInt64(value.tv_sec) * 1_000_000_000 + UInt64(value.tv_nsec)
+    }
+
+    static func request(pid: pid_t, deadlineFile: URL) throws -> UInt64 {
+        let deadline = now() + 3_000_000_000
+        try String(deadline).write(to: deadlineFile, atomically: true, encoding: .utf8)
+        try #require(Darwin.kill(pid, SIGUSR1) == 0)
+        return deadline
+    }
+
+    static func marker(at file: URL) -> String? {
+        guard let value = try? String(contentsOf: file, encoding: .utf8), !value.isEmpty else { return nil }
+        return value
+    }
+
+    static func waitForMarker(at file: URL, deadline: UInt64) -> String? {
+        while now() < deadline {
+            if let value = marker(at: file), now() < deadline { return value }
+            Thread.sleep(forTimeInterval: 0.01)
+        }
+        return nil
+    }
+
+    // Shared by both silent-holder fixtures and the deterministic observer controls.
+    // Success is published atomically only when both EPIPE observations are before the
+    // same parent-supplied deadline. Retry the observation, never the command or test.
+    static let observerSource = #"""
+    #include <errno.h>
+    #include <fcntl.h>
+    #include <limits.h>
+    #include <stdint.h>
+    #include <stdio.h>
+    #include <time.h>
+    #include <unistd.h>
+
+    static uint64_t monotonic_ns(void) {
+        struct timespec value;
+        if (clock_gettime(CLOCK_MONOTONIC, &value)) _exit(70);
+        return (uint64_t)value.tv_sec * 1000000000ULL + (uint64_t)value.tv_nsec;
+    }
+
+    static int observePipeClosure(const char *deadlinePath, const char *markerPath,
+        const char *detailsPath, const char *connectedPath, void (*owners)(FILE *, int)) {
+        unsigned long long deadline;
+        FILE *request = fopen(deadlinePath, "r");
+        if (!request) return 71;
+        int parsed = fscanf(request, "%llu", &deadline);
+        fclose(request);
+        if (parsed != 1) return 72;
+        for (int fd = STDOUT_FILENO; fd <= STDERR_FILENO; fd++) {
+            int flags = fcntl(fd, F_GETFL);
+            if (flags < 0 || fcntl(fd, F_SETFL, flags | O_NONBLOCK) < 0) return 73;
+        }
+        ssize_t results[2] = {0, 0}, first[2] = {0, 0};
+        int errors[2] = {0, 0}, firstErrors[2] = {0, 0}, broken[2] = {0, 0};
+        unsigned attempts = 0;
+        uint64_t observedAt = 0;
+        int invalid = 0;
+        while (monotonic_ns() < deadline) {
+            for (int i = 0; i < 2; i++) {
+                if (broken[i]) continue;
+                errno = 0;
+                results[i] = write(STDOUT_FILENO + i, "x", 1);
+                errors[i] = errno;
+                broken[i] = results[i] == -1 && errors[i] == EPIPE;
+                if (results[i] != 1 && !broken[i] &&
+                    !(results[i] == -1 && (errors[i] == EINTR || errors[i] == EAGAIN))) invalid = 1;
+            }
+            observedAt = monotonic_ns();
+            if (attempts++ == 0) {
+                for (int i = 0; i < 2; i++) { first[i] = results[i]; firstErrors[i] = errors[i]; }
+                if (connectedPath && !broken[0] && !broken[1] && !invalid) {
+                    FILE *connected = fopen(connectedPath, "w");
+                    if (!connected) return 74;
+                    fputs("connected", connected);
+                    fclose(connected);
+                }
+            }
+            if (invalid || (broken[0] && broken[1]) || observedAt >= deadline) break;
+            uint64_t remaining = deadline - observedAt;
+            struct timespec delay = {0, (long)(remaining < 10000000 ? remaining : 10000000)};
+            nanosleep(&delay, NULL);
+        }
+        int success = !invalid && broken[0] && broken[1] && observedAt < deadline;
+        FILE *details = detailsPath ? fopen(detailsPath, "w") : NULL;
+        if (details) {
+            fprintf(details, "first_stdout=%ld,errno=%d; first_stderr=%ld,errno=%d; stdout=%ld,errno=%d; stderr=%ld,errno=%d; attempts=%u; observed_ns=%llu; deadline_ns=%llu",
+                (long)first[0], firstErrors[0], (long)first[1], firstErrors[1],
+                (long)results[0], errors[0], (long)results[1], errors[1], attempts,
+                (unsigned long long)observedAt, deadline);
+            if (!success && owners) { owners(details, STDOUT_FILENO); owners(details, STDERR_FILENO); }
+            fclose(details);
+        }
+        char pending[PATH_MAX];
+        int length = snprintf(pending, sizeof(pending), "%s.pending", markerPath);
+        if (length < 0 || length >= (int)sizeof(pending)) return 75;
+        FILE *marker = fopen(pending, "w");
+        if (!marker) return 76;
+        fputs(success ? "both-epipe" : invalid ? "probe-error" : "still-connected", marker);
+        if (fclose(marker) || rename(pending, markerPath)) return 77;
+        return 0;
+    }
+    """#
+}
+
+extension CLIRunnerTests {
+    @Test("pipe closure observer distinguishes transient readers from one persistent reader", arguments: [false, true])
+    func pipeClosureObserverControls(persistentReader: Bool) throws {
+        let root = FileManager.default.temporaryDirectory
+            .appendingPathComponent("recordings-pipe-observer-\(UUID().uuidString)")
+        try FileManager.default.createDirectory(at: root, withIntermediateDirectories: true)
+        defer { try? FileManager.default.removeItem(at: root) }
+        let source = root.appendingPathComponent("observer.c")
+        let executable = root.appendingPathComponent("observer")
+        let ready = root.appendingPathComponent("ready")
+        let deadlineFile = root.appendingPathComponent("deadline")
+        let marker = root.appendingPathComponent("result")
+        let details = root.appendingPathComponent("details")
+        let connected = root.appendingPathComponent("connected")
+        try """
+        #include <signal.h>
+        \(PipeClosureFixture.observerSource)
+        static volatile sig_atomic_t requested = 0;
+        static void requestProbe(int signo) { (void)signo; requested = 1; }
+        int main(int argc, char **argv) {
+            if (argc != 6) return 64;
+            signal(SIGPIPE, SIG_IGN);
+            signal(SIGUSR1, requestProbe);
+            FILE *ready = fopen(argv[1], "w");
+            if (!ready) return 65;
+            fputs("ready", ready);
+            fclose(ready);
+            while (!requested) {
+                struct timespec delay = {0, 1000000};
+                nanosleep(&delay, NULL);
+            }
+            return observePipeClosure(argv[2], argv[3], argv[4], argv[5], NULL);
+        }
+        """.write(to: source, atomically: true, encoding: .utf8)
+        let compile = Process()
+        compile.executableURL = URL(fileURLWithPath: "/usr/bin/cc")
+        compile.arguments = ["-Wall", "-Wextra", "-Werror", "-o", executable.path, source.path]
+        try compile.run()
+        compile.waitUntilExit()
+        try #require(compile.terminationStatus == 0)
+
+        let output = Pipe(), error = Pipe()
+        var leases: [Int32] = []
+        defer {
+            for descriptor in leases where descriptor >= 0 { _ = Darwin.close(descriptor) }
+            for handle in [output.fileHandleForReading, output.fileHandleForWriting,
+                           error.fileHandleForReading, error.fileHandleForWriting] { try? handle.close() }
+        }
+        for pipe in [output, error] {
+            let descriptor = Darwin.fcntl(pipe.fileHandleForReading.fileDescriptor, F_DUPFD_CLOEXEC, 3)
+            try #require(descriptor >= 0)
+            leases.append(descriptor)
+        }
+        let child = Process()
+        child.executableURL = executable
+        child.arguments = [ready.path, deadlineFile.path, marker.path, details.path, connected.path]
+        child.standardOutput = output
+        child.standardError = error
+        try child.run()
+        defer {
+            if child.isRunning { _ = Darwin.kill(child.processIdentifier, SIGKILL) }
+            child.waitUntilExit()
+        }
+        try output.fileHandleForReading.close()
+        try error.fileHandleForReading.close()
+        try output.fileHandleForWriting.close()
+        try error.fileHandleForWriting.close()
+        try #require(PipeClosureFixture.waitForMarker(at: ready, deadline: PipeClosureFixture.now() + 3_000_000_000) == "ready")
+        let deadline = try PipeClosureFixture.request(pid: child.processIdentifier, deadlineFile: deadlineFile)
+        // The observer must actually see retained readers before this test releases
+        // either lease. No delay or scheduling assumption substitutes for that handshake.
+        try #require(PipeClosureFixture.waitForMarker(at: connected, deadline: deadline) == "connected")
+        try #require(Darwin.close(leases[0]) == 0)
+        leases[0] = -1
+        if !persistentReader {
+            try #require(Darwin.close(leases[1]) == 0)
+            leases[1] = -1
+            #expect(PipeClosureFixture.waitForMarker(at: marker, deadline: deadline) == "both-epipe")
+        }
+        // This extra second is only for reaping/reporting the negative control after
+        // its original deadline expires. It cannot admit a late successful observation.
+        while child.isRunning && PipeClosureFixture.now() < deadline + 1_000_000_000 {
+            Thread.sleep(forTimeInterval: 0.01)
+        }
+        try #require(!child.isRunning)
+        child.waitUntilExit()
+        #expect(child.terminationStatus == 0)
+        let observations = try String(contentsOf: details, encoding: .utf8)
+        #expect(observations.contains("first_stdout=1,errno=0; first_stderr=1,errno=0"))
+        if persistentReader {
+            #expect(PipeClosureFixture.now() >= deadline)
+            #expect(PipeClosureFixture.marker(at: marker) == "still-connected")
+            #expect(observations.contains("stdout=-1,errno=\(EPIPE); stderr=1,errno=0"))
+            try #require(Darwin.close(leases[1]) == 0)
+            leases[1] = -1
+            #expect(PipeClosureFixture.marker(at: marker) == "still-connected")
+        } else {
+            #expect(observations.contains("stdout=-1,errno=\(EPIPE); stderr=-1,errno=\(EPIPE)"))
+        }
+    }
+}

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

@@ -27,7 +27,7 @@ struct ProjectStoreTests {
     @Test("legacy app projects migrate to canonical Store ids without losing metadata")
     @MainActor
     func migratesProjectsToCanonicalStore() async throws {
-        let root = FileManager.default.temporaryDirectory.appendingPathComponent(UUID().uuidString)
+        let root = URL(fileURLWithPath: makeIsolatedTestHome("project-store"), isDirectory: true)
         defer { try? FileManager.default.removeItem(at: root) }
         let bin = root.appendingPathComponent(".bun/bin")
         try FileManager.default.createDirectory(at: bin, withIntermediateDirectories: true)
@@ -80,7 +80,7 @@ struct ProjectStoreTests {
     @Test("duplicate legacy project ids reconcile without crashing or duplicating canonical rows")
     @MainActor
     func duplicateProjectIDsAreDeduplicated() async throws {
-        let root = FileManager.default.temporaryDirectory.appendingPathComponent(UUID().uuidString)
+        let root = URL(fileURLWithPath: makeIsolatedTestHome("project-store"), isDirectory: true)
         defer { try? FileManager.default.removeItem(at: root) }
         let bin = root.appendingPathComponent(".bun/bin")
         try FileManager.default.createDirectory(at: bin, withIntermediateDirectories: true)
@@ -110,7 +110,7 @@ struct ProjectStoreTests {
     @Test("failed canonical registration preserves recording metadata and can be retried")
     @MainActor
     func failedRegistrationDoesNotDisableCaptureForAppLifetime() async throws {
-        let root = FileManager.default.temporaryDirectory.appendingPathComponent(UUID().uuidString)
+        let root = URL(fileURLWithPath: makeIsolatedTestHome("project-store"), isDirectory: true)
         defer { try? FileManager.default.removeItem(at: root) }
         let bin = root.appendingPathComponent(".bun/bin")
         try FileManager.default.createDirectory(at: bin, withIntermediateDirectories: true)
@@ -180,7 +180,7 @@ struct ProjectStoreTests {
     @Test("adding a project preserves color in canonical local metadata")
     @MainActor
     func addProjectPreservesColor() async throws {
-        let root = FileManager.default.temporaryDirectory.appendingPathComponent(UUID().uuidString)
+        let root = URL(fileURLWithPath: makeIsolatedTestHome("project-store"), isDirectory: true)
         defer { try? FileManager.default.removeItem(at: root) }
         let bin = root.appendingPathComponent(".bun/bin")
         try FileManager.default.createDirectory(at: bin, withIntermediateDirectories: true)
@@ -220,7 +220,7 @@ struct ProjectStoreTests {
     @Test("project mutations are rejected while canonical reconciliation is in flight")
     @MainActor
     func serializesReconciliationAndMutations() async throws {
-        let root = FileManager.default.temporaryDirectory.appendingPathComponent(UUID().uuidString)
+        let root = URL(fileURLWithPath: makeIsolatedTestHome("project-store"), isDirectory: true)
         defer { try? FileManager.default.removeItem(at: root) }
         let bin = root.appendingPathComponent(".bun/bin")
         try FileManager.default.createDirectory(at: bin, withIntermediateDirectories: true)
@@ -257,7 +257,7 @@ struct ProjectStoreTests {
     @Test("project decode failures are visible and prevent readiness")
     @MainActor
     func reportsLoadFailure() async throws {
-        let root = FileManager.default.temporaryDirectory.appendingPathComponent(UUID().uuidString)
+        let root = URL(fileURLWithPath: makeIsolatedTestHome("project-store"), isDirectory: true)
         defer { try? FileManager.default.removeItem(at: root) }
         try FileManager.default.createDirectory(at: root, withIntermediateDirectories: true)
         let file = root.appendingPathComponent("projects.json")
@@ -280,7 +280,7 @@ struct ProjectStoreTests {
     @Test("unreadable project data blocks every mutation without overwriting the file")
     @MainActor
     func unreadableDataBlocksMutations() async throws {
-        let root = FileManager.default.temporaryDirectory.appendingPathComponent(UUID().uuidString)
+        let root = URL(fileURLWithPath: makeIsolatedTestHome("project-store"), isDirectory: true)
         defer { try? FileManager.default.removeItem(at: root) }
         try FileManager.default.createDirectory(at: root, withIntermediateDirectories: true)
         let file = root.appendingPathComponent("projects.json")
@@ -310,7 +310,7 @@ struct ProjectStoreTests {
     @Test("a project file that becomes unreadable after launch is never overwritten")
     @MainActor
     func postLaunchReadFailureBlocksMutations() throws {
-        let root = FileManager.default.temporaryDirectory.appendingPathComponent(UUID().uuidString)
+        let root = URL(fileURLWithPath: makeIsolatedTestHome("project-store"), isDirectory: true)
         defer { try? FileManager.default.removeItem(at: root) }
         try FileManager.default.createDirectory(at: root, withIntermediateDirectories: true)
         let file = root.appendingPathComponent("projects.json")
@@ -334,7 +334,7 @@ struct ProjectStoreTests {
     @Test("external project file changes are never replaced by stale in-memory settings")
     @MainActor
     func externalChangeBlocksMutations() throws {
-        let root = FileManager.default.temporaryDirectory.appendingPathComponent(UUID().uuidString)
+        let root = URL(fileURLWithPath: makeIsolatedTestHome("project-store"), isDirectory: true)
         defer { try? FileManager.default.removeItem(at: root) }
         try FileManager.default.createDirectory(at: root, withIntermediateDirectories: true)
         let file = root.appendingPathComponent("projects.json")
@@ -354,7 +354,7 @@ struct ProjectStoreTests {
     @Test("a stale app instance cannot overwrite a newer project save")
     @MainActor
     func staleStoreCannotOverwriteNewerSave() throws {
-        let root = FileManager.default.temporaryDirectory.appendingPathComponent(UUID().uuidString)
+        let root = URL(fileURLWithPath: makeIsolatedTestHome("project-store"), isDirectory: true)
         defer { try? FileManager.default.removeItem(at: root) }
         try FileManager.default.createDirectory(at: root, withIntermediateDirectories: true)
         let file = root.appendingPathComponent("projects.json")

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

@@ -67,7 +67,7 @@ private func makeEngine(
     accessibilityTrusted: Bool = true,
     pasteRecorder: PasteRecorder? = nil
 ) -> RecordingEngine {
-    let engine = RecordingEngine(homePath: makeIsolatedTestHome("delivery-tests"))
+    let engine = RecordingEngine(homePath: makeIsolatedTestHome("delivery-tests"), installsGlobalHandlers: false)
     engine.openAIAPIKeyProvider = { "" }
     engine.microphoneAuthorization = { .denied }
     engine.accessibilityTrustCheck = { accessibilityTrusted }

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

@@ -0,0 +1,50 @@
+import AVFoundation
+import Foundation
+import Testing
+@testable import RecordingsLib
+
+private struct TargetNoopProvider: RecordingTranscriptionProvider {
+    func makeSession(configuration: RecordingProviderSessionConfiguration, onPartialTranscript: @escaping @Sendable (String) -> Void) throws -> any RecordingTranscriptionSession {
+        throw RecordingProviderError.noAudio
+    }
+}
+@MainActor struct RecordingFrozenPasteTargetTests {
+    private let a = PasteApplicationObservation(pid: 90101, bundleIdentifier: "example.editor", launchDate: Date(timeIntervalSince1970: 100), name: "Editor")
+    private let b = PasteApplicationObservation(pid: 90102, bundleIdentifier: "example.notes", launchDate: Date(timeIntervalSince1970: 200), name: "Notes")
+    private func engine() throws -> RecordingEngine {
+        let configuration = try RecordingEngineConfiguration(isolatedHomePath: makeIsolatedTestHome("frozen-target"), preferencesSuiteName: "example.frozen-tests.\(UUID().uuidString)")
+        let engine = RecordingEngine(configuration: configuration, transcriptionProvider: TargetNoopProvider())
+        engine.microphoneAuthorization = { .denied }
+        engine.accessibilityTrustCheck = { false }
+        engine.protectedOperationTrust = { AccessibilityTrustResult(trusted: true, didPrompt: false) }
+        engine.focusedWindowTitleLookup = { _ in nil }
+        engine.selectionCapture = { _ in Issue.record("No Accessibility reads allowed"); return nil }
+        engine.frontmostAppSnapshot = { FrontmostAppSnapshot(pid: ProcessInfo.processInfo.processIdentifier, bundleIdentifier: "example.recorder", launchDate: Date()) }
+        engine.pasteTargetApplicationLookup = { pid in pid == a.pid ? a : b }
+        return engine
+    }
+    private func candidates(_ apps: [PasteApplicationObservation]) -> [PasteTargetCandidate] {
+        apps.map { PasteTargetCandidate(pid: $0.pid, bundleIdentifier: $0.bundleIdentifier, isRegularApp: $0.isRegular, launchDate: $0.launchDate) }
+    }
+    @Test func explicitObservedTargetSurvivesSelfFocusAndLaterAppFocus() throws {
+        let engine = try engine()
+        let target = try #require(RecordingPasteTarget(observation: a, currentPID: ProcessInfo.processInfo.processIdentifier))
+        engine.startRecording(pasteTarget: .frozen(target))
+        let generation = engine.recordingGeneration
+        #expect(engine.resolvePasteTarget(candidates: candidates([a, b]), targetBundleIdentifier: a.bundleIdentifier, targetPid: a.pid, frontmostPid: b.pid, pipelineGeneration: generation)?.pid == a.pid)
+        var reused = a; reused.launchDate = Date(timeIntervalSince1970: 101)
+        #expect(engine.resolvePasteTarget(candidates: candidates([reused, b]), targetBundleIdentifier: a.bundleIdentifier, targetPid: a.pid, frontmostPid: b.pid, pipelineGeneration: generation) == nil)
+        #expect(engine.resolvePasteTarget(candidates: candidates([b]), targetBundleIdentifier: a.bundleIdentifier, targetPid: a.pid, frontmostPid: b.pid, pipelineGeneration: generation) == nil)
+        var helper = a; helper.isRegular = false
+        #expect(engine.resolvePasteTarget(candidates: candidates([helper]), targetBundleIdentifier: a.bundleIdentifier, targetPid: a.pid, frontmostPid: a.pid, pipelineGeneration: generation) == nil)
+    }
+    @Test func explicitNilAndInvalidAtStartNeverAdoptTheFinishTimeApp() throws {
+        for target in [nil, RecordingPasteTarget(observation: a, currentPID: ProcessInfo.processInfo.processIdentifier)] {
+            let engine = try engine(); engine.pasteTargetApplicationLookup = { _ in nil }
+            engine.startRecording(pasteTarget: .frozen(target))
+            #expect(engine.resolvePasteTarget(candidates: candidates([b]), targetBundleIdentifier: nil, targetPid: nil, frontmostPid: b.pid, pipelineGeneration: engine.recordingGeneration) == nil)
+        }
+        let legacy = try engine(); legacy.startRecording()
+        #expect(legacy.resolvePasteTarget(candidates: candidates([b]), targetBundleIdentifier: nil, targetPid: nil, frontmostPid: b.pid, pipelineGeneration: legacy.recordingGeneration)?.pid == b.pid, "Omitting explicit selection preserves the legacy default")
+    }
+}

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

@@ -0,0 +1,48 @@
+import Foundation
+import Testing
+@testable import RecordingsLib
+
+@MainActor struct RecordingPasteTargetTrackerTests {
+    private let a = PasteApplicationObservation(pid: 801, bundleIdentifier: "example.editor", launchDate: Date(timeIntervalSince1970: 100), name: "Editor")
+    private let b = PasteApplicationObservation(pid: 802, bundleIdentifier: "example.notes", launchDate: Date(timeIntervalSince1970: 200), name: "Notes")
+    private let own = PasteApplicationObservation(pid: 900, bundleIdentifier: "example.recorder", launchDate: Date(timeIntervalSince1970: 300))
+
+    @Test func remembersObservedExternalAcrossRecorderActivationAndFreezesValue() throws {
+        var frontmost = a
+        let tracker = RecordingPasteTargetTracker(currentPID: own.pid, frontmost: { frontmost }, lookup: { pid in pid == a.pid ? a : b })
+        frontmost = own; tracker.observe(own)
+        let frozen = try #require(tracker.snapshot())
+        #expect(frozen.processIdentifier == a.pid)
+        #expect(frozen.bundleIdentifier == a.bundleIdentifier)
+        #expect(frozen.launchDate == a.launchDate)
+        frontmost = b; tracker.observe(b)
+        #expect(tracker.snapshot()?.processIdentifier == b.pid)
+        #expect(frozen.processIdentifier == a.pid, "Later focus cannot mutate a capture's value")
+    }
+    @Test func refusesUnobservedSelfNonregularIncompleteAndTerminatedApps() {
+        let tracker = RecordingPasteTargetTracker(currentPID: own.pid, frontmost: { own }, lookup: { _ in a })
+        #expect(tracker.snapshot() == nil)
+        for invalid in [PasteApplicationObservation(pid: 803, bundleIdentifier: "example.helper", launchDate: Date(), isRegular: false),
+                        PasteApplicationObservation(pid: 804, bundleIdentifier: nil, launchDate: Date()),
+                        PasteApplicationObservation(pid: 805, bundleIdentifier: "example.unknown", launchDate: nil),
+                        PasteApplicationObservation(pid: 806, bundleIdentifier: "example.dead", launchDate: Date(), isTerminated: true)] {
+            tracker.observe(invalid); #expect(tracker.snapshot() == nil)
+        }
+    }
+    @Test func refusesPIDReuseAndDoesNotRecoverAnOlderApp() throws {
+        var live = b
+        let tracker = RecordingPasteTargetTracker(currentPID: own.pid, frontmost: { own }, lookup: { _ in live })
+        tracker.observe(a); tracker.observe(b)
+        #expect(tracker.snapshot()?.processIdentifier == b.pid)
+        live.launchDate = Date(timeIntervalSince1970: 201)
+        #expect(tracker.snapshot() == nil)
+        live = b
+        #expect(tracker.snapshot() == nil, "Revalidation failure consumes the remembered destination")
+        tracker.observe(b)
+        var oldIncarnation = b; oldIncarnation.launchDate = Date(timeIntervalSince1970: 199)
+        tracker.terminated(oldIncarnation)
+        #expect(tracker.snapshot() != nil)
+        tracker.terminated(b)
+        #expect(tracker.snapshot() == nil)
+    }
+}