@hasna/recordings 0.4.0 → 0.5.0

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

@@ -689,18 +689,19 @@ private final class PCMStreamPipe: @unchecked Sendable {
                 guard !Task.isCancelled else { break }
                 guard !data.isEmpty else { continue }
                 recordedPCM.append(data)
+                // Providers need every admitted packet before a pause can settle.
+                // Only the legacy realtime client waits for network-sized chunks.
+                providerSession?.appendPCM(data)
                 pendingChunk.append(data)
 
                 while pendingChunk.count >= chunkSize {
                     let chunk = pendingChunk.prefixData(count: chunkSize)
-                    providerSession?.appendPCM(chunk)
                     await client?.sendAudio(chunk)
                     pendingChunk.removeFirst(chunkSize)
                 }
             }
 
             if !Task.isCancelled && !pendingChunk.isEmpty {
-                providerSession?.appendPCM(pendingChunk)
                 await client?.sendAudio(pendingChunk)
             }
             return recordedPCM
@@ -939,6 +940,10 @@ public final class RecordingEngine: ObservableObject {
     private var providerSession: (any RecordingTranscriptionSession)?
     private var providerConfiguration: RecordingProviderSessionConfiguration?
     private var providerCompletionTask: Task<Void, Never>?
+    /// Injection keeps persistence ordering testable without changing the public file contract.
+    var providerAudioWriter: @Sendable (Data, URL) throws -> Void = { pcm, url in
+        try RecordingEngine.writeWAV(pcmData: pcm, sampleRate: 24_000, channelCount: 1, bitsPerSample: 16, to: url)
+    }
 
     private var nativeRecorder: PCMRecordingSource?
     private var recordingTimer: Timer?
@@ -948,6 +953,7 @@ public final class RecordingEngine: ObservableObject {
     private var fnKeyIsDown = false
     private var targetAppBundleIdentifier: String?
     private var targetAppPid: pid_t?
+    private var frozenPasteTargetsByGeneration: [UInt64: RecordingPasteTargetSelection] = [:]
     private var pasteTargetProcessIdentityByGeneration: [UInt64: PasteTargetProcessIdentity] = [:]
     public var projectStore: ProjectStore?
     /// The minimal app uses only global cleanup preferences from the legacy settings
@@ -980,6 +986,12 @@ public final class RecordingEngine: ObservableObject {
             launchDate: app.launchDate
         )
     }
+    var pasteTargetApplicationLookup: (pid_t) -> PasteApplicationObservation? = {
+        NSRunningApplication(processIdentifier: $0).map(PasteApplicationObservation.init)
+    }
+    var pasteFallbackWriter: (String) -> Bool = { text in
+        RecordingEngine.writeClipboardPreservingOnFailure(text, to: .general)
+    }
     var recorderFactory: (@escaping @Sendable (Data) -> Void) -> PCMRecordingSource = {
         NativePCMRecorder(onPCM: $0)
     }
@@ -990,12 +1002,15 @@ public final class RecordingEngine: ObservableObject {
         RecordingEngine.focusedWindowTitle(pid: $0)
     }
     var commandCLI: @Sendable (_ args: [String], _ home: String, _ timeout: TimeInterval) -> String = { args, home, ceiling in
-        // The caller's timeout is the public ceiling on *observable* wall time. CLIRunner's
+        // The caller supplies the remaining public budget after queue admission. CLIRunner's
         // total deadline (execution, termination grace, kill grace, pipe drain) sits a full
         // return margin below it: spawn setup, waitid poll granularity, capture shutdown,
         // and the hop back to the caller all run outside CLIRunner's clamped waits and must
         // fit inside the reserved margin.
         let cliDeadline = ceiling - RecordingEngine.commandRewriteReturnMargin
+        guard cliDeadline > CLIRunner.wallClockCleanupReserve else {
+            return "ERROR: \(CLIRunner.ExecutionError.deadlineExhausted.localizedDescription)"
+        }
         return CLIRunner.run(args, home: home, timeout: cliDeadline, totalWallClockBudget: cliDeadline)
     }
     /// Resolves and revalidates the frozen rewrite target immediately before a rewrite:
@@ -1227,6 +1242,23 @@ public final class RecordingEngine: ObservableObject {
     /// *observable* rewrite time under the public ceiling even when the execution window,
     /// termination grace, and pipe drain all run to exhaustion.
     nonisolated static let commandRewriteReturnMargin: TimeInterval = 1
+
+    /// Create this operation synchronously before awaiting the blocking queue: creating
+    /// its deadline inside the submitted closure would give delayed work a fresh budget.
+    nonisolated static func makeCommandRewriteOperation(
+        args: [String],
+        home: String,
+        runCLI: @escaping @Sendable ([String], String, TimeInterval) -> String,
+        deadline: CLIRunner.WallClockDeadline = .init(after: commandRewriteTimeout)
+    ) -> @Sendable () -> String {
+        return {
+            let remaining = min(commandRewriteTimeout, deadline.remaining())
+            guard remaining > commandRewriteReturnMargin + CLIRunner.wallClockCleanupReserve else {
+                return "ERROR: \(CLIRunner.ExecutionError.deadlineExhausted.localizedDescription)"
+            }
+            return runCLI(args, home, remaining)
+        }
+    }
     /// Wait before each read-back of the target app's focused field. The window server
     /// delivers the posted keystroke asynchronously and the app then does its own work, so a
     /// read taken on the posting turn would report "unchanged" for a paste that is simply
@@ -1738,7 +1770,8 @@ public final class RecordingEngine: ObservableObject {
 
     // MARK: - Start Recording (Streaming)
 
-    public func startRecording(trigger: RecordingTrigger = .manual) {
+    public func startRecording(trigger: RecordingTrigger = .manual,
+                               pasteTarget: RecordingPasteTargetSelection = .frontmostApplication) {
         guard Self.canBeginRecording(
             isRecording: isRecording,
             isTranscribing: isTranscribing,
@@ -1755,11 +1788,12 @@ public final class RecordingEngine: ObservableObject {
         }
         log("startRecording trigger=\(trigger) microphoneStatus=\(microphoneAuthorization().rawValue) accessibility=\(accessibilityTrustCheck())")
         recordingGeneration &+= 1
-        if pasteTargetProcessIdentityByGeneration.count >= 32 {
+        if pasteTargetProcessIdentityByGeneration.count >= 32 || frozenPasteTargetsByGeneration.count >= 32 {
             let oldestRetainedGeneration = recordingGeneration > 16 ? recordingGeneration - 16 : 0
             pasteTargetProcessIdentityByGeneration = pasteTargetProcessIdentityByGeneration.filter {
                 $0.key >= oldestRetainedGeneration
             }
+            frozenPasteTargetsByGeneration = frozenPasteTargetsByGeneration.filter { $0.key >= oldestRetainedGeneration }
         }
         activeTrigger = trigger
         keyboardShortcutIsDown = trigger == .keyboardShortcut
@@ -1778,7 +1812,19 @@ public final class RecordingEngine: ObservableObject {
         setBlockedReason(nil, for: .delivery)
 
         let myPID = ProcessInfo.processInfo.processIdentifier
-        let frontmostApp = frontmostAppSnapshot()
+        let frontmostApp: FrontmostAppSnapshot?
+        switch pasteTarget {
+        case .frontmostApplication:
+            frontmostApp = frontmostAppSnapshot()
+        case .frozen(let target):
+            // Keep explicit nil distinct from omission, including when a previously
+            // observed target terminated between the host's snapshot and this call.
+            frozenPasteTargetsByGeneration[recordingGeneration] = pasteTarget
+            if let target, target.processIdentifier != myPID,
+               let app = pasteTargetApplicationLookup(target.processIdentifier), target.matches(app) {
+                frontmostApp = FrontmostAppSnapshot(pid: target.processIdentifier, bundleIdentifier: target.bundleIdentifier, launchDate: target.launchDate)
+            } else { frontmostApp = nil }
+        }
         let isOwnApp = frontmostApp?.pid == myPID
         targetAppBundleIdentifier = isOwnApp ? nil : frontmostApp?.bundleIdentifier
         targetAppPid = isOwnApp ? nil : frontmostApp?.pid
@@ -1798,8 +1844,8 @@ public final class RecordingEngine: ObservableObject {
         // The selection is still frozen for every recording (not only an exposed "command
         // mode"), so a later command decision can only ever act on the exact text and
         // element that were selected when the user started speaking. The Accessibility IPC
-        // that reads it runs on a detached task, concurrently with recorder start: the
-        // microphone must never wait on a beachballing target app, and the MainActor stays
+        // that reads it runs on a blocking-work queue, concurrently with recorder start:
+        // neither the microphone nor a cooperative worker waits on a beachballing app. The MainActor stays
         // free to process the key-up that stops the recording. Skipped entirely when intent
         // detection is off — no command route exists to consume it.
         let shouldCaptureSelection = Self.shouldCaptureSelection(
@@ -1812,12 +1858,14 @@ public final class RecordingEngine: ObservableObject {
         let windowTitleLookup = focusedWindowTitleLookup
         let windowTitlePid = frontmostApp?.pid
         let axSnapshotTask = Task.detached(priority: .userInitiated) { () -> RecordingStartAXSnapshot in
-            let selectionToken = shouldCaptureSelection ? capturePid.flatMap { captureSelection($0) } : nil
-            let focusedWindowTitle = windowTitlePid.flatMap { windowTitleLookup($0) }
-            return RecordingStartAXSnapshot(
-                selectionToken: selectionToken,
-                focusedWindowTitle: focusedWindowTitle
-            )
+            await BlockingOperation.run {
+                let selectionToken = shouldCaptureSelection ? capturePid.flatMap { captureSelection($0) } : nil
+                let focusedWindowTitle = windowTitlePid.flatMap { windowTitleLookup($0) }
+                return RecordingStartAXSnapshot(
+                    selectionToken: selectionToken,
+                    focusedWindowTitle: focusedWindowTitle
+                )
+            }
         }
 
         // Project auto-selection and the processing configuration resolve with the
@@ -2367,14 +2415,22 @@ public final class RecordingEngine: ObservableObject {
             let pcm = await pipe?.finish() ?? Data()
             guard !Task.isCancelled, let self,
                   self.recordingGeneration == pipelineGeneration else { return }
+            var timings = [pipelineTrace.message(stage: "pcm_drain_complete", detail: "pcm_bytes=\(pcm.count)")]
+            // Capture timestamps now, but batch their I/O after completion. Instrumentation
+            // must not add a log-file write before the early network commit or WAV write.
+            defer { self.log(timings.joined(separator: "\n")) }
             do {
                 guard !pcm.isEmpty, let audioPath else { throw RecordingProviderError.noAudio }
                 let audioURL = URL(fileURLWithPath: audioPath)
+                session.inputEnded()
+                timings.append(pipelineTrace.message(stage: "provider_input_ended"))
+                let writeAudio = self.providerAudioWriter
                 try await Task.detached(priority: .userInitiated) {
-                    try Self.writeWAV(pcmData: pcm, sampleRate: 24_000, channelCount: 1, bitsPerSample: 16, to: audioURL)
+                    try writeAudio(pcm, audioURL)
                 }.value
                 try Task.checkCancellation()
                 guard self.recordingGeneration == pipelineGeneration else { return }
+                timings.append(pipelineTrace.message(stage: "wav_write_complete"))
                 let duration = Double(pcm.count) / 48_000
                 self.recordingDuration = duration
                 let result = try await session.finish(RecordingTranscriptionRequest(
@@ -2383,6 +2439,7 @@ public final class RecordingEngine: ObservableObject {
                 ))
                 try Task.checkCancellation()
                 guard self.recordingGeneration == pipelineGeneration else { return }
+                timings.append(pipelineTrace.message(stage: "provider_finish_complete"))
                 let rawText = result.rawText.trimmingCharacters(in: .whitespacesAndNewlines)
                 let processed = result.processedText?.trimmingCharacters(in: .whitespacesAndNewlines)
                 let text = (processed?.isEmpty == false ? processed : nil) ?? rawText
@@ -4067,10 +4124,12 @@ public final class RecordingEngine: ObservableObject {
                 activeProjectId: canonicalProjectId,
                 processingConfiguration: processingConfiguration
             )
-            let runCLI = self.commandCLI
-            let result = await Task.detached {
-                runCLI(rewriteArguments, homePath, Self.commandRewriteTimeout)
-            }.value
+            let rewriteOperation = Self.makeCommandRewriteOperation(
+                args: rewriteArguments,
+                home: homePath,
+                runCLI: self.commandCLI
+            )
+            let result = await BlockingOperation.run(rewriteOperation)
             if self.canOwnBusyState(pipelineGeneration: pipelineGeneration) {
                 self.isTranscribing = false
                 self.liveTranscriptionText = ""
@@ -4272,13 +4331,21 @@ public final class RecordingEngine: ObservableObject {
             deliveryCompleted?()
             return
         }
-        let pb = NSPasteboard.general
+        if let generation = pipelineGeneration, frozenPasteTargetsByGeneration[generation] != nil,
+           pasteTargetProcessIdentityByGeneration[generation] == nil {
+            completeUnavailablePaste(text, deliveryKind: deliveryKind, captureID: captureID,
+                                     pipelineGeneration: pipelineGeneration)
+            deliveryCompleted?()
+            return
+        }
         var previousClipboard: ClipboardSnapshot?
 
         let accessibility = protectedOperationTrust()
         guard accessibility.trusted else {
             let shouldCopy = Self.shouldCopyPasteFallback(deliveryKind: deliveryKind)
-            let copied = shouldCopy && Self.writeClipboardPreservingOnFailure(text, to: pb)
+            let copied = shouldCopy && pasteFallbackWriter(text)
+            appendUndeliveredPaste(text: text, copied: copied, captureID: captureID,
+                                   pipelineGeneration: pipelineGeneration, fallbackBundle: targetAppBundleIdentifier)
             log("paste blocked by accessibility permission")
             let message = if deliveryKind == .commandRewrite {
                 "Paste cancelled because Accessibility permission changed"
@@ -4306,18 +4373,8 @@ public final class RecordingEngine: ObservableObject {
         )
 
         guard let app = targetApp else {
-            let shouldCopy = Self.shouldCopyPasteFallback(deliveryKind: deliveryKind)
-            let copied = shouldCopy && Self.writeClipboardPreservingOnFailure(text, to: pb)
-            log("paste target app not found")
-            updateDeliveryStatus(
-                deliveryKind == .commandRewrite
-                    ? "Paste cancelled because the target app is unavailable"
-                    : copied
-                        ? "Copied — no target app found"
-                        : "Transcription ready, but the clipboard could not be updated",
-                kind: .failure,
-                pipelineGeneration: pipelineGeneration
-            )
+            completeUnavailablePaste(text, deliveryKind: deliveryKind, captureID: captureID,
+                                     pipelineGeneration: pipelineGeneration, fallbackBundle: targetAppBundleIdentifier)
             deliveryCompleted?()
             return
         }
@@ -4840,15 +4897,37 @@ public final class RecordingEngine: ObservableObject {
         setBlockedReason(nil, for: .pressConsumed)
     }
 
+    private func appendUndeliveredPaste(text: String, copied: Bool, captureID: String?,
+                                       pipelineGeneration: UInt64?, fallbackBundle: String? = nil) {
+        let selection = pipelineGeneration.flatMap { frozenPasteTargetsByGeneration[$0] }
+        let target: RecordingPasteTarget? = if case .frozen(let value) = selection { value } else { nil }
+        recentPastes.insert(RecentPaste(text: text, bundleIdentifier: target?.bundleIdentifier ?? fallbackBundle,
+            appName: target?.applicationName ?? fallbackBundle ?? "No target app",
+            location: copied ? "Clipboard only" : "", status: copied ? "Copied; paste not delivered" : "Paste not delivered",
+            verified: false, captureID: captureID, deliveryStatus: .notDelivered), at: 0)
+        if recentPastes.count > 50 { recentPastes.removeLast() }
+    }
+
+    private func completeUnavailablePaste(_ text: String, deliveryKind: PasteDeliveryKind, captureID: String?,
+                                          pipelineGeneration: UInt64?, fallbackBundle: String? = nil) {
+        let copied = Self.shouldCopyPasteFallback(deliveryKind: deliveryKind) && pasteFallbackWriter(text)
+        appendUndeliveredPaste(text: text, copied: copied, captureID: captureID,
+                               pipelineGeneration: pipelineGeneration, fallbackBundle: fallbackBundle)
+        log("paste target app not found")
+        updateDeliveryStatus(deliveryKind == .commandRewrite
+            ? "Paste cancelled because the target app is unavailable"
+            : copied ? "Copied — no target app found" : "Transcription ready, but the clipboard could not be updated",
+            kind: .failure, pipelineGeneration: pipelineGeneration)
+    }
+
     private func selectedRunningPasteTarget(
         targetAppBundleIdentifier: String?,
         targetAppPid: pid_t?,
         frontmostPid: pid_t?,
         pipelineGeneration: UInt64?
     ) -> NSRunningApplication? {
-        let myPID = ProcessInfo.processInfo.processIdentifier
         let runningApps = NSWorkspace.shared.runningApplications
-        let candidates = runningApps.map {
+        let candidates = runningApps.filter { !$0.isTerminated }.map {
             PasteTargetCandidate(
                 pid: $0.processIdentifier,
                 bundleIdentifier: $0.bundleIdentifier,
@@ -4856,23 +4935,30 @@ public final class RecordingEngine: ObservableObject {
                 launchDate: $0.launchDate
             )
         }
-        let requiredProcessIdentity = pipelineGeneration.flatMap {
-            pasteTargetProcessIdentityByGeneration[$0]
-        }
-        let selectedTarget = Self.selectPasteTarget(
-            candidates: candidates,
-            currentPid: myPID,
-            targetBundleIdentifier: targetAppBundleIdentifier,
-            targetPid: targetAppPid,
-            frontmostPid: frontmostPid,
-            requiredProcessIdentity: requiredProcessIdentity,
-            requiresProcessIdentity: pipelineGeneration != nil && targetAppPid != nil
+        let selectedTarget = resolvePasteTarget(
+            candidates: candidates, targetBundleIdentifier: targetAppBundleIdentifier,
+            targetPid: targetAppPid, frontmostPid: frontmostPid, pipelineGeneration: pipelineGeneration
         )
         return selectedTarget.flatMap { selected in
             runningApps.first { $0.processIdentifier == selected.pid }
         }
     }
 
+    func resolvePasteTarget(candidates: [PasteTargetCandidate], targetBundleIdentifier: String?,
+                            targetPid: pid_t?, frontmostPid: pid_t?, pipelineGeneration: UInt64?) -> PasteTargetCandidate? {
+        let frozen = pipelineGeneration.flatMap { frozenPasteTargetsByGeneration[$0] }
+        let identity = pipelineGeneration.flatMap { pasteTargetProcessIdentityByGeneration[$0] }
+        if frozen != nil {
+            // No bundle-only or foreground fallback for an explicitly frozen capture.
+            guard let identity, targetPid == identity.pid,
+                  targetBundleIdentifier == identity.bundleIdentifier else { return nil }
+        }
+        return Self.selectPasteTarget(candidates: frozen == nil ? candidates : candidates.filter(\.isRegularApp),
+            currentPid: ProcessInfo.processInfo.processIdentifier, targetBundleIdentifier: targetBundleIdentifier,
+            targetPid: targetPid, frontmostPid: frontmostPid, requiredProcessIdentity: identity,
+            requiresProcessIdentity: frozen != nil || (pipelineGeneration != nil && targetPid != nil))
+    }
+
     nonisolated static func selectPasteTarget(
         candidates: [PasteTargetCandidate],
         currentPid: pid_t,
@@ -5031,12 +5117,15 @@ enum CLIRunner: Sendable {
 
     enum ExecutionError: Error, LocalizedError, Equatable {
         case timedOut(executable: String, seconds: TimeInterval)
+        case deadlineExhausted
         case captureFailed(operation: CaptureOperation, code: Int32)
 
         var errorDescription: String? {
             switch self {
             case let .timedOut(executable, seconds):
                 return "Command timed out after \(seconds.formatted()) seconds: \(executable)"
+            case .deadlineExhausted:
+                return "Command timed out: insufficient time remains to start safely."
             case let .captureFailed(operation, code):
                 return "Failed to capture command output while \(operation.description): \(String(cString: strerror(code)))"
             }
@@ -5065,27 +5154,76 @@ enum CLIRunner: Sendable {
         _ lifecycleObserver: ((ProcessLifecycleEvent) -> Void)?
     ) throws -> Int32
 
+    /// An explicit monotonic deadline can cross queue and preparation boundaries without
+    /// resetting the budget. The clock is injectable for deterministic boundary tests.
+    struct WallClockDeadline: Sendable {
+        private let expiresAt: UInt64
+        private let now: @Sendable () -> UInt64
+
+        init(
+            after seconds: TimeInterval,
+            now: @escaping @Sendable () -> UInt64 = { DispatchTime.now().uptimeNanoseconds }
+        ) {
+            precondition(seconds.isFinite && seconds >= 0)
+            let startedAt = now()
+            let maximumDelay = min(UInt64(Int64.max), UInt64.max - startedAt)
+            let requested = seconds * 1_000_000_000
+            // Truncate fractional nanoseconds: rounding up could extend the configured
+            // budget and reject its own deadline at a subsequent handoff validation.
+            let delay = requested >= Double(maximumDelay)
+                ? maximumDelay : UInt64(requested)
+            expiresAt = startedAt + delay
+            self.now = now
+        }
+
+        func remaining(reserving reserve: TimeInterval = 0) -> TimeInterval {
+            let current = now()
+            guard expiresAt > current else { return 0 }
+            return max(0, Double(expiresAt - current) / 1_000_000_000 - reserve)
+        }
+    }
+
+    private static func requireStartBudget(_ deadline: WallClockDeadline?) throws {
+        if let deadline, deadline.remaining() <= wallClockCleanupReserve {
+            throw ExecutionError.deadlineExhausted
+        }
+    }
+
     static func run(
         _ args: [String],
         home: String,
         timeout: TimeInterval = 120,
         totalWallClockBudget: TimeInterval? = nil,
-        environment suppliedEnvironment: [String: String]? = nil
+        environment suppliedEnvironment: [String: String]? = nil,
+        wallClockDeadline suppliedDeadline: WallClockDeadline? = nil,
+        environmentProvider: (() throws -> [String: String])? = nil
     ) -> String {
-        let command = resolveCommand(home: home)
-        let arguments = command.argumentsPrefix + args
+        if let totalWallClockBudget {
+            precondition(totalWallClockBudget.isFinite && totalWallClockBudget > wallClockCleanupReserve)
+        }
+        precondition(suppliedDeadline == nil || totalWallClockBudget != nil)
+        let deadline = suppliedDeadline ?? totalWallClockBudget.map { WallClockDeadline(after: $0) }
+        if let suppliedDeadline, let totalWallClockBudget {
+            precondition(suppliedDeadline.remaining() <= totalWallClockBudget)
+        }
         do {
-            let environment = try suppliedEnvironment ?? ServiceAPIConfiguration.childEnvironment(
+            try requireStartBudget(deadline)
+            let command = resolveCommand(home: home)
+            let arguments = command.argumentsPrefix + args
+            try requireStartBudget(deadline)
+            let environment = try suppliedEnvironment ?? environmentProvider?() ?? ServiceAPIConfiguration.childEnvironment(
                 base: OpenAIAPIKeyStore.childEnvironment(base: ProcessInfo.processInfo.environment.merging([
                     "PATH": "\(home)/.bun/bin:/opt/homebrew/bin:/usr/local/bin:/usr/bin:/bin"
                 ]) { _, new in new }, homePath: home)
             )
+            try requireStartBudget(deadline)
             let output = try runExecutable(
                 command.executable,
                 arguments: arguments,
                 environment: environment,
                 executionTimeout: timeout,
-                totalWallClockBudget: totalWallClockBudget
+                totalWallClockBudget: totalWallClockBudget,
+                wallClockDeadline: deadline
             )
             if output.terminationStatus != 0 {
                 let details = output.stderr.isEmpty ? output.stdout : output.stderr
@@ -5133,6 +5271,7 @@ enum CLIRunner: Sendable {
         forceKillGracePeriod: TimeInterval = 1,
         pipeDrainTimeout: TimeInterval = 2,
         totalWallClockBudget: TimeInterval? = nil,
+        wallClockDeadline suppliedDeadline: WallClockDeadline? = nil,
         beforeExecutionDeadline: (() -> Void)? = nil,
         lifecycleObserver: ((ProcessLifecycleEvent) -> Void)? = nil,
         leaderReaper: LeaderReaper? = nil,
@@ -5146,23 +5285,24 @@ enum CLIRunner: Sendable {
             precondition(totalWallClockBudget.isFinite && totalWallClockBudget > wallClockCleanupReserve)
         }
 
-        // The budget clock starts before the spawn so setup latency cannot extend the
-        // observable wall time. Every wait below is clamped to what is left of it.
-        let wallClockDeadline = totalWallClockBudget.map { monotonicUptimeDeadline(after: $0) }
+        precondition(suppliedDeadline == nil || totalWallClockBudget != nil)
+        if let suppliedDeadline, let totalWallClockBudget {
+            precondition(suppliedDeadline.remaining() <= totalWallClockBudget)
+        }
+        // A caller that prepared the command supplies its original deadline. Direct
+        // executable callers begin here; neither path resets a previously spent budget.
+        let wallClockDeadline = suppliedDeadline ?? totalWallClockBudget.map { WallClockDeadline(after: $0) }
         func clampedToWallClockBudget(
             _ phaseTimeout: TimeInterval,
             reserving reserve: TimeInterval = 0
         ) -> TimeInterval {
             guard let wallClockDeadline else { return phaseTimeout }
-            let now = DispatchTime.now().uptimeNanoseconds
-            let remaining = wallClockDeadline > now
-                ? Double(wallClockDeadline - now) / 1_000_000_000 - reserve
-                : 0
-            return max(0, min(phaseTimeout, remaining))
+            return min(phaseTimeout, wallClockDeadline.remaining(reserving: reserve))
         }
         let contractualExecutionTimeout = totalWallClockBudget
             .map { min(executionTimeout, $0 - wallClockCleanupReserve) } ?? executionTimeout
 
+        try requireStartBudget(wallClockDeadline)
         let stdoutReader = try PipeCaptureReader(systemCalls: captureSystemCalls)
         let stderrReader: PipeCaptureReader
         do {
@@ -5176,6 +5316,7 @@ enum CLIRunner: Sendable {
 
         let processIdentifier: pid_t
         do {
+            try requireStartBudget(wallClockDeadline)
             processIdentifier = try spawnProcessGroup(
                 executable,
                 arguments: arguments,
@@ -5355,6 +5496,30 @@ enum CLIRunner: Sendable {
             )
         }
 
+        // CLOEXEC_DEFAULT also closes stdin unless it is explicitly inherited. Keep
+        // the existing stdin behavior, including an already closed/CLOEXEC stream;
+        // a capture pipe that reused fd 0 must still be closed by the actions above.
+        if !inheritedDescriptors.contains(STDIN_FILENO) {
+            var inputFlags: Int32
+            repeat {
+                inputFlags = Darwin.fcntl(STDIN_FILENO, F_GETFD)
+            } while inputFlags == -1 && errno == EINTR
+            let inputError = errno
+            if inputFlags == -1 && inputError != EBADF {
+                throw NSError(
+                    domain: NSPOSIXErrorDomain,
+                    code: Int(inputError),
+                    userInfo: [NSLocalizedDescriptionKey: "Failed to inspect command standard input"]
+                )
+            }
+            if inputFlags >= 0 && inputFlags & FD_CLOEXEC == 0 {
+                try checkPOSIX(
+                    posix_spawn_file_actions_addinherit_np(&fileActions, STDIN_FILENO),
+                    operation: "inherit command standard input"
+                )
+            }
+        }
+
         var attributes: posix_spawnattr_t?
         try checkPOSIX(posix_spawnattr_init(&attributes), operation: "initialize spawn attributes")
         defer { posix_spawnattr_destroy(&attributes) }
@@ -5371,7 +5536,10 @@ enum CLIRunner: Sendable {
             posix_spawnattr_setsigmask(&attributes, &unblockedSignals),
             operation: "unblock command signals"
         )
-        let spawnFlags = POSIX_SPAWN_SETPGROUP | POSIX_SPAWN_SETSIGDEF | POSIX_SPAWN_SETSIGMASK
+        // A different reader may still be between pipe() and FD_CLOEXEC setup.
+        // Inherit only our explicit standard streams, never that unrelated pipe.
+        let spawnFlags = POSIX_SPAWN_SETPGROUP | POSIX_SPAWN_SETSIGDEF
+            | POSIX_SPAWN_SETSIGMASK | POSIX_SPAWN_CLOEXEC_DEFAULT
         try checkPOSIX(
             posix_spawnattr_setflags(&attributes, Int16(spawnFlags)),
             operation: "configure command process group"

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

@@ -0,0 +1,114 @@
+import AppKit
+import Foundation
+
+/// An observed app process, not a bundle-ID request to launch or find another instance.
+public struct RecordingPasteTarget: Equatable, Sendable {
+    public let processIdentifier: pid_t
+    public let bundleIdentifier: String
+    public let launchDate: Date
+    public let applicationName: String
+
+    init?(observation: PasteApplicationObservation, currentPID: pid_t) {
+        guard observation.pid > 0, observation.pid != currentPID,
+              observation.isRegular, !observation.isTerminated,
+              let bundle = observation.bundleIdentifier, !bundle.isEmpty,
+              let launchDate = observation.launchDate else { return nil }
+        processIdentifier = observation.pid
+        bundleIdentifier = bundle
+        self.launchDate = launchDate
+        applicationName = observation.name ?? "Application"
+    }
+
+    func matches(_ observation: PasteApplicationObservation) -> Bool {
+        observation.pid == processIdentifier && observation.bundleIdentifier == bundleIdentifier
+            && observation.launchDate == launchDate && observation.isRegular && !observation.isTerminated
+    }
+}
+
+/// Omission preserves the recorder's existing frontmost-app behavior. A frozen nil
+/// explicitly means no destination; it never adopts another app at delivery time.
+public enum RecordingPasteTargetSelection: Equatable, Sendable {
+    case frontmostApplication
+    case frozen(RecordingPasteTarget?)
+}
+
+struct PasteApplicationObservation: Sendable {
+    var pid: pid_t
+    var bundleIdentifier: String?
+    var launchDate: Date?
+    var name: String?
+    var isRegular: Bool
+    var isTerminated: Bool
+
+    init(_ app: NSRunningApplication) {
+        pid = app.processIdentifier; bundleIdentifier = app.bundleIdentifier
+        launchDate = app.launchDate; name = app.localizedName
+        isRegular = app.activationPolicy == .regular; isTerminated = app.isTerminated
+    }
+    init(pid: pid_t, bundleIdentifier: String?, launchDate: Date?, name: String? = nil,
+         isRegular: Bool = true, isTerminated: Bool = false) {
+        self.pid = pid; self.bundleIdentifier = bundleIdentifier; self.launchDate = launchDate
+        self.name = name; self.isRegular = isRegular; self.isTerminated = isTerminated
+    }
+}
+
+/// Keep one tracker for the host application's lifetime, before presenting its UI.
+/// Observes workspace activation only; never installs input handlers, queries AX,
+/// activates apps, reads their documents, or accesses the clipboard.
+@MainActor public final class RecordingPasteTargetTracker {
+    private let currentPID: pid_t
+    private let frontmost: () -> PasteApplicationObservation?
+    private let lookup: (pid_t) -> PasteApplicationObservation?
+    private var lastExternal: RecordingPasteTarget?
+    private var observers: [NSObjectProtocol] = []
+    private var center: NotificationCenter?
+
+    public convenience init() {
+        self.init(currentPID: ProcessInfo.processInfo.processIdentifier,
+                  frontmost: { NSWorkspace.shared.frontmostApplication.map(PasteApplicationObservation.init) },
+                  lookup: { NSRunningApplication(processIdentifier: $0).map(PasteApplicationObservation.init) })
+        let center = NSWorkspace.shared.notificationCenter
+        self.center = center
+        observers.append(center.addObserver(forName: NSWorkspace.didActivateApplicationNotification, object: nil, queue: .main) { [weak self] notification in
+            guard let app = notification.userInfo?[NSWorkspace.applicationUserInfoKey] as? NSRunningApplication else { return }
+            let observation = PasteApplicationObservation(app)
+            MainActor.assumeIsolated { self?.observe(observation) }
+        })
+        observers.append(center.addObserver(forName: NSWorkspace.didTerminateApplicationNotification, object: nil, queue: .main) { [weak self] notification in
+            guard let app = notification.userInfo?[NSWorkspace.applicationUserInfoKey] as? NSRunningApplication else { return }
+            let observation = PasteApplicationObservation(app)
+            MainActor.assumeIsolated { self?.terminated(observation) }
+        })
+    }
+
+    init(currentPID: pid_t, frontmost: @escaping () -> PasteApplicationObservation?,
+         lookup: @escaping (pid_t) -> PasteApplicationObservation?) {
+        self.currentPID = currentPID; self.frontmost = frontmost; self.lookup = lookup
+        if let app = frontmost() { observe(app) }
+    }
+
+    isolated deinit { for observer in observers { center?.removeObserver(observer) } }
+
+    func observe(_ app: PasteApplicationObservation) {
+        guard let target = RecordingPasteTarget(observation: app, currentPID: currentPID) else { return }
+        lastExternal = target
+    }
+
+    func terminated(_ app: PasteApplicationObservation) {
+        guard let target = lastExternal, app.pid == target.processIdentifier,
+              app.bundleIdentifier == target.bundleIdentifier, app.launchDate == target.launchDate else { return }
+        lastExternal = nil
+    }
+
+    /// Revalidate now, then pass this value to startRecording as `.frozen(value)`.
+    /// A terminated or replaced process clears the remembered destination; older
+    /// apps are not searched as a substitute.
+    public func snapshot() -> RecordingPasteTarget? {
+        if let app = frontmost() { observe(app) }
+        guard let target = lastExternal else { return nil }
+        guard let live = lookup(target.processIdentifier), target.matches(live) else {
+            lastExternal = nil; return nil
+        }
+        return target
+    }
+}