fix: allow recording while meetings process

Meetingnotes.xcodeproj/project.pbxproj

@@ -276,7 +276,7 @@
 				CODE_SIGN_IDENTITY = "Apple Development";
 				CODE_SIGN_STYLE = Automatic;
 				COMBINE_HIDPI_IMAGES = YES;
-				CURRENT_PROJECT_VERSION = 32;
+				CURRENT_PROJECT_VERSION = 44;
 				DEVELOPMENT_ASSET_PATHS = "\"meetingnotes/Preview Content\"";
 				DEVELOPMENT_TEAM = G9LVHZAJNX;
 				ENABLE_HARDENED_RUNTIME = YES;
@@ -290,7 +290,7 @@
 					"@executable_path/../Frameworks",
 				);
 				MACOSX_DEPLOYMENT_TARGET = 15.0;
-				MARKETING_VERSION = 1.1.20;
+				MARKETING_VERSION = 1.1.32;
 				ONLY_ACTIVE_ARCH = NO;
 				OTHER_SWIFT_FLAGS = "$(inherited) -D ENABLE_TCC_SPI";
 				PRODUCT_BUNDLE_IDENTIFIER = net.jamesbone.meetingnotes;
@@ -312,7 +312,7 @@
 				CODE_SIGN_IDENTITY = "Apple Development";
 				CODE_SIGN_STYLE = Automatic;
 				COMBINE_HIDPI_IMAGES = YES;
-				CURRENT_PROJECT_VERSION = 32;
+				CURRENT_PROJECT_VERSION = 44;
 				DEVELOPMENT_ASSET_PATHS = "\"meetingnotes/Preview Content\"";
 				DEVELOPMENT_TEAM = G9LVHZAJNX;
 				ENABLE_HARDENED_RUNTIME = YES;
@@ -326,7 +326,7 @@
 					"@executable_path/../Frameworks",
 				);
 				MACOSX_DEPLOYMENT_TARGET = 15.0;
-				MARKETING_VERSION = 1.1.20;
+				MARKETING_VERSION = 1.1.32;
 				ONLY_ACTIVE_ARCH = YES;
 				OTHER_SWIFT_FLAGS = "$(inherited) -D ENABLE_TCC_SPI";
 				PRODUCT_BUNDLE_IDENTIFIER = net.jamesbone.meetingnotes;

README.md

@@ -22,7 +22,8 @@ Implemented:
 - Meeting search functionality
 - Abilty to edit system prompt
 - Select any compatible Coder model for transcription and note generation
-- Automatic start and stop from MuteDeck through a compatible local API
+- Automatic start and stop from MuteDeck through a compatible local API, with a 10-second reconnect grace period
+- Merge an automatically split continuation back into its previous meeting
 - Auto updates
 - Text formatting
 - Different note templates

meetingnotes/Managers/AudioManager.swift

@@ -20,6 +20,27 @@ private enum RecoveryTranscriptionError: LocalizedError {
     }
 }
 
+private struct SystemCaptureDiagnostics {
+    var tapAdvertisedFormat = "unavailable"
+    var aggregateInputFormat = "unavailable"
+    var selectedInputFormat = "unavailable"
+    var targetFormat = "unavailable"
+    var selectedInputSampleRate: Double?
+    var targetSampleRate: Double?
+    var inputRateInference = "unavailable"
+    var firstBufferLayout: String?
+    var callbackCount: UInt64 = 0
+    var inputFrameCount: UInt64 = 0
+    var outputFrameCount: UInt64 = 0
+    var discardedCallbackCount: UInt64 = 0
+    var firstSampleTime: Double?
+    var lastSampleTime: Double?
+    var firstHostTime: UInt64?
+    var lastHostTime: UInt64?
+    var firstCallbackAt: Date?
+    var lastCallbackAt: Date?
+}
+
 /// Captures microphone and system audio locally, then sends completed files to Coder.
 @MainActor
 final class AudioManager: NSObject, ObservableObject {
@@ -50,8 +71,9 @@ final class AudioManager: NSObject, ObservableObject {
     private var micAudioURL: URL?
     private var systemAudioURL: URL?
     private var recordingStartedAt = Date()
+    private var systemDiagnostics = SystemCaptureDiagnostics()
 
-    private override init() {
+    override init() {
         super.init()
         observeAudioEngine()
     }
@@ -67,6 +89,7 @@ final class AudioManager: NSObject, ObservableObject {
         sessionID = UUID()
         self.meetingID = meetingID
         recordingStartedAt = Date()
+        systemDiagnostics = SystemCaptureDiagnostics()
         do {
             try prepareAudioFiles()
             startMicrophoneTap()
@@ -79,6 +102,7 @@ final class AudioManager: NSObject, ObservableObject {
 
     func stopRecordingAndTranscribe() async -> [TranscriptChunk] {
         let completedMeetingID = meetingID
+        let completedSessionID = sessionID
         let captureStartedAt = recordingStartedAt
         let files = stopCaptureAndCloseFiles()
         isProcessing = true
@@ -86,9 +110,31 @@ final class AudioManager: NSObject, ObservableObject {
             isProcessing = false
         }
 
+        let preRepairFileSummaries = files.map(audioFileSummary)
+        let repairApplied = repairHalfDurationSystemWAVIfNeeded(in: files)
+        let completedFiles = files.compactMap { $0 }
+        let audioFolder = preserveAudioFiles(completedFiles, meetingID: completedMeetingID)
+        let transcriptionFiles = preservedAudioFiles(files, in: audioFolder)
+        lastRecoveryAudioFolderName = audioFolder?.lastPathComponent
+        writeCaptureDiagnostics(
+            sessionID: completedSessionID,
+            captureStartedAt: captureStartedAt,
+            preRepairFileSummaries: preRepairFileSummaries,
+            repairedFiles: transcriptionFiles,
+            repairApplied: repairApplied,
+            audioFolder: audioFolder
+        )
+        if let mismatch = captureDurationMismatch(in: transcriptionFiles) {
+            let recoveryMessage = audioFolder == nil
+                ? " The audio remains in the app's temporary folder."
+                : " Audio was kept so it can be recovered."
+            errorMessage = "System audio timing was invalid (\(mismatch)). Transcription was stopped to avoid an out-of-order result." + recoveryMessage
+            return transcriptChunks.filter(\.isFinal)
+        }
+
         let model = UserDefaultsManager.shared.transcriptionModel
-        async let micResult = transcribe(files[0], model: model, diarization: false)
+        async let micResult = transcribe(transcriptionFiles[0], model: model, diarization: false)
-        async let systemResult = transcribe(files[1], model: model, diarization: true)
+        async let systemResult = transcribe(transcriptionFiles[1], model: model, diarization: true)
         let (micTranscription, systemTranscription) = await (micResult, systemResult)
         let results = [micTranscription, systemTranscription]
 
@@ -98,9 +144,6 @@ final class AudioManager: NSObject, ObservableObject {
             existingChunks: transcriptChunks.filter(\.isFinal)
         )
         transcriptChunks = updated
-        let completedFiles = files.compactMap { $0 }
-        let audioFolder = preserveAudioFiles(completedFiles, meetingID: completedMeetingID)
-        lastRecoveryAudioFolderName = audioFolder?.lastPathComponent
         if !failures.isEmpty {
             let retentionDays = UserDefaultsManager.shared.audioRetentionDays
             let retentionUnit = retentionDays == 1 ? "day" : "days"
@@ -123,17 +166,29 @@ final class AudioManager: NSObject, ObservableObject {
         isProcessing = true
         defer { isProcessing = false }
         let model = UserDefaultsManager.shared.transcriptionModel
-        let micURL = recoveryFiles.first(where: { $0.source == .mic })?.url
+        let sessions = Dictionary(grouping: recoveryFiles) { recoverySessionKey(for: $0.url) }
-        let systemURL = recoveryFiles.first(where: { $0.source == .system })?.url
+            .values
+            .map { files in
+                (files: files, startedAt: recoveryCaptureStartedAt(for: files, fallback: captureStartedAt))
+            }
+            .sorted { $0.startedAt < $1.startedAt }
+
+        var chunks: [TranscriptChunk] = []
+        var failures: [String] = []
+        for session in sessions {
+            let micURL = session.files.first(where: { $0.source == .mic })?.url
+            let systemURL = session.files.first(where: { $0.source == .system })?.url
             async let micResult = transcribe(micURL, model: model, diarization: false)
             async let systemResult = transcribe(systemURL, model: model, diarization: true)
             let (micTranscription, systemTranscription) = await (micResult, systemResult)
-        let results = [micTranscription, systemTranscription]
+            let result = buildTranscriptChunks(
-        let (chunks, failures) = buildTranscriptChunks(
+                from: [micTranscription, systemTranscription],
-            from: results,
+                captureStartedAt: session.startedAt,
-            captureStartedAt: captureStartedAt,
+                existingChunks: chunks
-            existingChunks: []
             )
+            chunks = result.0
+            failures.append(contentsOf: result.1)
+        }
 
         if !failures.isEmpty {
             throw RecoveryTranscriptionError.requestFailed(failures.joined(separator: "; "))
@@ -144,6 +199,28 @@ final class AudioManager: NSObject, ObservableObject {
         return chunks
     }
 
+    private func recoverySessionKey(for url: URL) -> String {
+        let name = url.deletingPathExtension().lastPathComponent
+        if name.hasSuffix("-mic") { return String(name.dropLast(4)) }
+        if name.hasSuffix("-system") { return String(name.dropLast(7)) }
+        return name
+    }
+
+    private func recoveryCaptureStartedAt(
+        for files: [(url: URL, source: AudioSource)],
+        fallback: Date
+    ) -> Date {
+        let estimatedStarts = files.compactMap { file -> Date? in
+            guard let duration = audioDuration(at: file.url),
+                  let values = try? file.url.resourceValues(forKeys: [.contentModificationDateKey, .creationDateKey]),
+                  let finishedAt = values.contentModificationDate ?? values.creationDate else {
+                return nil
+            }
+            return finishedAt.addingTimeInterval(-duration)
+        }
+        return estimatedStarts.min() ?? fallback
+    }
+
     func cancelRecording() {
         cancelCapture(removeFiles: true)
         lastRecoveryAudioFolderName = nil
@@ -209,15 +286,18 @@ final class AudioManager: NSObject, ObservableObject {
     
     private func prepareAudioFiles() throws {
         let settings: [String: Any] = [
-            AVFormatIDKey: kAudioFormatMPEG4AAC,
+            AVFormatIDKey: kAudioFormatLinearPCM,
             AVSampleRateKey: 16_000,
             AVNumberOfChannelsKey: 1,
-            AVEncoderBitRateKey: 48_000
+            AVLinearPCMBitDepthKey: 16,
+            AVLinearPCMIsFloatKey: false,
+            AVLinearPCMIsBigEndianKey: false,
+            AVLinearPCMIsNonInterleaved: false
         ]
         let base = FileManager.default.temporaryDirectory
         let id = sessionID.uuidString
-        let micURL = base.appendingPathComponent("meetingnotes-\(id)-mic.m4a")
+        let micURL = base.appendingPathComponent("meetingnotes-\(id)-mic.wav")
-        let systemURL = base.appendingPathComponent("meetingnotes-\(id)-system.m4a")
+        let systemURL = base.appendingPathComponent("meetingnotes-\(id)-system.wav")
         let newMicAudioFile = try AVAudioFile(
             forWriting: micURL,
             settings: settings,
@@ -353,20 +433,92 @@ final class AudioManager: NSObject, ObservableObject {
     
     private func startTapIO(_ tap: ProcessTap) throws {
         guard var description = tap.tapStreamDescription,
-              let inputFormat = AVAudioFormat(streamDescription: &description),
+              let advertisedInputFormat = AVAudioFormat(streamDescription: &description),
               let targetFormat = systemAudioFile?.processingFormat,
-              let converter = AVAudioConverter(from: inputFormat, to: targetFormat) else {
+              advertisedInputFormat.sampleRate > 0 else {
             throw NSError(domain: "AudioManager", code: -1, userInfo: [NSLocalizedDescriptionKey: "Unsupported system audio format"])
         }
-        try tap.run(on: tapQueue) { [weak self] _, inputData, _, _, _ in
+        systemDiagnostics.tapAdvertisedFormat = streamDescriptionSummary(tap.tapAdvertisedStreamDescription)
+        systemDiagnostics.aggregateInputFormat = streamDescriptionSummary(tap.aggregateInputStreamDescription)
+        systemDiagnostics.targetFormat = audioFormatSummary(targetFormat)
+        systemDiagnostics.targetSampleRate = targetFormat.sampleRate
+        var inputFormat: AVAudioFormat?
+        var converter: AVAudioConverter?
+        var pendingBuffer: AVAudioPCMBuffer?
+        var pendingInputTime: AudioTimeStamp?
+        var pendingNow: AudioTimeStamp?
+        try tap.run(on: tapQueue) { [weak self] inNow, inputData, inInputTime, _, _ in
             guard let self else { return }
+            if inputFormat == nil {
+                guard let callbackFormat = self.inputFormat(
+                    for: inputData,
+                    sampleRate: advertisedInputFormat.sampleRate
+                ),
+                let currentBuffer = self.copyAudioBuffer(from: inputData, format: callbackFormat) else {
+                    self.systemDiagnostics.discardedCallbackCount += 1
+                    return
+                }
+
+                guard let previousBuffer = pendingBuffer,
+                      let previousInputTime = pendingInputTime,
+                      let previousNow = pendingNow else {
+                    pendingBuffer = currentBuffer
+                    pendingInputTime = inInputTime.pointee
+                    pendingNow = inNow.pointee
+                    return
+                }
+
+                let selectedSampleRate = self.effectiveInputSampleRate(
+                    advertisedSampleRate: advertisedInputFormat.sampleRate,
+                    previousFrameLength: previousBuffer.frameLength,
+                    previousTimestamp: previousInputTime,
+                    currentTimestamp: inInputTime.pointee,
+                    previousHostTimestamp: previousNow,
+                    currentHostTimestamp: inNow.pointee
+                )
+                inputFormat = self.inputFormat(
+                    for: inputData,
+                    sampleRate: selectedSampleRate
+                )
+                if let inputFormat {
+                    self.systemDiagnostics.selectedInputFormat = self.audioFormatSummary(inputFormat)
+                    self.systemDiagnostics.selectedInputSampleRate = inputFormat.sampleRate
+                    converter = AVAudioConverter(from: inputFormat, to: targetFormat)
+                }
+
+                guard let inputFormat, let converter else { return }
+                self.processAudioBuffer(
+                    { self.copyAudioBuffer(from: previousBuffer.audioBufferList, format: inputFormat) },
+                    converter: converter,
+                    targetFormat: targetFormat,
+                    source: .system,
+                    callbackTimestamp: previousInputTime,
+                    ioTimestamp: pendingNow
+                )
+                pendingBuffer = nil
+                pendingInputTime = nil
+                pendingNow = nil
+
+                self.processAudioBuffer(
+                    { self.copyAudioBuffer(from: currentBuffer.audioBufferList, format: inputFormat) },
+                    converter: converter,
+                    targetFormat: targetFormat,
+                    source: .system,
+                    callbackTimestamp: inInputTime.pointee,
+                    ioTimestamp: inNow.pointee
+                )
+                return
+            }
+            guard let inputFormat, let converter else { return }
             // The tap queue is serial. Reusing the converter preserves its
             // resampler state instead of discarding audio at every callback.
             self.processAudioBuffer(
                 { self.copyAudioBuffer(from: inputData, format: inputFormat) },
                 converter: converter,
                 targetFormat: targetFormat,
-                source: .system
+                source: .system,
+                callbackTimestamp: inInputTime.pointee,
+                ioTimestamp: inNow.pointee
             )
         } invalidationHandler: { [weak self] _ in
             guard let self, self.isRecording else { return }
@@ -374,24 +526,116 @@ final class AudioManager: NSObject, ObservableObject {
         }
     }
 
+    private func inputFormat(
+        for inputData: UnsafePointer<AudioBufferList>,
+        sampleRate: Double
+    ) -> AVAudioFormat? {
+        let buffers = UnsafeMutableAudioBufferListPointer(
+            UnsafeMutablePointer(mutating: inputData)
+        )
+        let channelCount = buffers.reduce(UInt32(0)) { $0 + $1.mNumberChannels }
+        guard channelCount > 0 else { return nil }
+
+        // HAL I/O proc samples use the canonical Float32 representation. The
+        // tap's stream description can advertise a different common format;
+        // using that to interpret the callback bytes can halve the frame count
+        // (for example, treating four-byte Float32 samples as eight-byte
+        // Float64 samples). The callback's AudioBufferList is authoritative for
+        // its channel layout, while its sample rate comes from the input stream.
+        let isInterleaved = buffers.count == 1 && channelCount > 1
+        return AVAudioFormat(
+            commonFormat: .pcmFormatFloat32,
+            sampleRate: sampleRate,
+            channels: AVAudioChannelCount(channelCount),
+            interleaved: isInterleaved
+        )
+    }
+
+    private func effectiveInputSampleRate(
+        advertisedSampleRate: Double,
+        previousFrameLength: AVAudioFrameCount,
+        previousTimestamp: AudioTimeStamp,
+        currentTimestamp: AudioTimeStamp,
+        previousHostTimestamp: AudioTimeStamp,
+        currentHostTimestamp: AudioTimeStamp
+    ) -> Double {
+        let sampleTimeDelta = currentTimestamp.mSampleTime - previousTimestamp.mSampleTime
+        guard advertisedSampleRate > 0, previousFrameLength > 0 else {
+            systemDiagnostics.inputRateInference = "advertised (invalid advertised rate or frame count)"
+            return advertisedSampleRate
+        }
+
+        guard currentHostTimestamp.mHostTime > previousHostTimestamp.mHostTime else {
+            systemDiagnostics.inputRateInference = "advertised (host timestamps unavailable)"
+            return advertisedSampleRate
+        }
+        let hostTimeDelta = currentHostTimestamp.mHostTime - previousHostTimestamp.mHostTime
+        let hostNanoseconds = AudioConvertHostTimeToNanos(hostTimeDelta)
+        guard hostNanoseconds > 0 else {
+            systemDiagnostics.inputRateInference = "advertised (host-time conversion failed)"
+            return advertisedSampleRate
+        }
+
+        let inferredSampleRate = Double(previousFrameLength) * 1_000_000_000 / Double(hostNanoseconds)
+        let plausibleRange = (advertisedSampleRate * 0.25)...(advertisedSampleRate * 1.25)
+        guard inferredSampleRate.isFinite, plausibleRange.contains(inferredSampleRate) else {
+            systemDiagnostics.inputRateInference = String(
+                format: "advertised (invalid host inference %.3f from %u frames / %llu ns; sampleTimeDelta=%.3f)",
+                inferredSampleRate,
+                previousFrameLength,
+                hostNanoseconds,
+                sampleTimeDelta
+            )
+            return advertisedSampleRate
+        }
+
+        let commonSampleRates: [Double] = [8_000, 11_025, 12_000, 16_000, 22_050, 24_000, 32_000, 44_100, 48_000, 88_200, 96_000]
+        let selectedSampleRate = commonSampleRates
+            .min(by: { abs($0 - inferredSampleRate) < abs($1 - inferredSampleRate) })
+            .flatMap { abs($0 - inferredSampleRate) / $0 <= 0.01 ? $0 : nil }
+            ?? inferredSampleRate
+        systemDiagnostics.inputRateInference = String(
+            format: "source=hostTime,advertised=%.3f,inferred=%.3f,selected=%.3f,previousFrames=%u,hostNanoseconds=%llu,sampleTimeDelta=%.3f",
+            advertisedSampleRate,
+            inferredSampleRate,
+            selectedSampleRate,
+            previousFrameLength,
+            hostNanoseconds,
+            sampleTimeDelta
+        )
+        return selectedSampleRate
+    }
+
     private func copyAudioBuffer(
         from inputData: UnsafePointer<AudioBufferList>,
         format: AVAudioFormat
     ) -> AVAudioPCMBuffer? {
-        guard let borrowedBuffer = AVAudioPCMBuffer(
-            pcmFormat: format,
-            bufferListNoCopy: inputData,
-            deallocator: nil
-        ), borrowedBuffer.frameLength > 0,
-        let ownedBuffer = AVAudioPCMBuffer(
-            pcmFormat: format,
-            frameCapacity: borrowedBuffer.frameLength
-        ) else { return nil }
-
-        ownedBuffer.frameLength = borrowedBuffer.frameLength
         let sourceBuffers = UnsafeMutableAudioBufferListPointer(
             UnsafeMutablePointer(mutating: inputData)
         )
+        if systemDiagnostics.firstBufferLayout == nil {
+            systemDiagnostics.firstBufferLayout = sourceBuffers.enumerated().map { index, buffer in
+                "buffer\(index):channels=\(buffer.mNumberChannels),bytes=\(buffer.mDataByteSize)"
+            }.joined(separator: "; ")
+        }
+        let frameLengths = sourceBuffers.compactMap { source -> AVAudioFrameCount? in
+            let bytesPerFrame = Int(source.mNumberChannels) * MemoryLayout<Float32>.size
+            guard bytesPerFrame > 0,
+                  Int(source.mDataByteSize).isMultiple(of: bytesPerFrame) else { return nil }
+            return AVAudioFrameCount(Int(source.mDataByteSize) / bytesPerFrame)
+        }
+        guard frameLengths.count == sourceBuffers.count,
+              let frameLength = frameLengths.first,
+              frameLength > 0,
+              frameLengths.allSatisfy({ $0 == frameLength }),
+              let ownedBuffer = AVAudioPCMBuffer(
+                pcmFormat: format,
+                frameCapacity: frameLength
+              ) else { return nil }
+
+        // Set the frame count explicitly instead of asking AVAudioPCMBuffer to
+        // infer it from potentially inconsistent tap metadata.
+        ownedBuffer.frameLength = frameLength
         let destinationBuffers = UnsafeMutableAudioBufferListPointer(
             ownedBuffer.mutableAudioBufferList
         )
@@ -414,20 +658,44 @@ final class AudioManager: NSObject, ObservableObject {
         _ inputBufferProvider: () -> AVAudioPCMBuffer?,
         converter: AVAudioConverter,
         targetFormat: AVAudioFormat,
-        source: AudioSource
+        source: AudioSource,
+        callbackTimestamp: AudioTimeStamp? = nil,
+        ioTimestamp: AudioTimeStamp? = nil
     ) {
         // The system callback copies its borrowed Core Audio memory while this
         // lock prevents teardown, then conversion operates on the owned copy.
         audioFileLock.lock()
         defer { audioFileLock.unlock() }
-        guard isAcceptingAudio,
+        guard isAcceptingAudio else { return }
-              let inputBuffer = inputBufferProvider(),
+        if source == .system {
-              inputBuffer.frameLength > 0 else { return }
+            systemDiagnostics.callbackCount += 1
+            let callbackAt = Date()
+            if systemDiagnostics.firstCallbackAt == nil { systemDiagnostics.firstCallbackAt = callbackAt }
+            systemDiagnostics.lastCallbackAt = callbackAt
+            if let callbackTimestamp {
+                if systemDiagnostics.firstSampleTime == nil { systemDiagnostics.firstSampleTime = callbackTimestamp.mSampleTime }
+                systemDiagnostics.lastSampleTime = callbackTimestamp.mSampleTime
+            }
+            if let ioTimestamp {
+                if systemDiagnostics.firstHostTime == nil { systemDiagnostics.firstHostTime = ioTimestamp.mHostTime }
+                systemDiagnostics.lastHostTime = ioTimestamp.mHostTime
+            }
+        }
+        guard let inputBuffer = inputBufferProvider(), inputBuffer.frameLength > 0 else {
+            if source == .system { systemDiagnostics.discardedCallbackCount += 1 }
+            return
+        }
+        if source == .system {
+            systemDiagnostics.inputFrameCount += UInt64(inputBuffer.frameLength)
+        }
 
         updateAudioLevel(inputBuffer, source: source)
         let ratio = targetFormat.sampleRate / inputBuffer.format.sampleRate
         let capacity = max(1, AVAudioFrameCount(ceil(Double(inputBuffer.frameLength) * ratio)))
-        guard let outputBuffer = AVAudioPCMBuffer(pcmFormat: targetFormat, frameCapacity: capacity) else { return }
+        guard let outputBuffer = AVAudioPCMBuffer(pcmFormat: targetFormat, frameCapacity: capacity) else {
+            if source == .system { systemDiagnostics.discardedCallbackCount += 1 }
+            return
+        }
         var suppliedInput = false
         var conversionError: NSError?
         let status = converter.convert(to: outputBuffer, error: &conversionError) { _, outputStatus in
@@ -439,7 +707,10 @@ final class AudioManager: NSObject, ObservableObject {
             outputStatus.pointee = .haveData
             return inputBuffer
         }
-        guard status != .error, conversionError == nil, outputBuffer.frameLength > 0 else { return }
+        guard status != .error, conversionError == nil, outputBuffer.frameLength > 0 else {
+            if source == .system { systemDiagnostics.discardedCallbackCount += 1 }
+            return
+        }
 
         do {
             switch source {
@@ -447,6 +718,7 @@ final class AudioManager: NSObject, ObservableObject {
                 try micAudioFile?.write(from: outputBuffer)
             case .system:
                 try systemAudioFile?.write(from: outputBuffer)
+                systemDiagnostics.outputFrameCount += UInt64(outputBuffer.frameLength)
             }
         } catch {
             DispatchQueue.main.async { [weak self] in
@@ -521,6 +793,211 @@ final class AudioManager: NSObject, ObservableObject {
         LocalStorageManager.shared.preserveAudioFiles(urls, for: meetingID)
     }
 
+    private func preservedAudioFiles(_ urls: [URL?], in folder: URL?) -> [URL?] {
+        urls.map { sourceURL in
+            guard let sourceURL else { return nil }
+            guard let folder else { return sourceURL }
+            let preservedURL = folder.appendingPathComponent(sourceURL.lastPathComponent)
+            return FileManager.default.fileExists(atPath: preservedURL.path) ? preservedURL : sourceURL
+        }
+    }
+
+    private func captureDurationMismatch(in files: [URL?]) -> String? {
+        guard files.count >= 2,
+              let micDuration = audioDuration(at: files[0]),
+              let systemDuration = audioDuration(at: files[1]),
+              micDuration >= 60 else { return nil }
+        let ratio = systemDuration / micDuration
+        guard (0.45...0.55).contains(ratio) || (1.8...2.2).contains(ratio) else { return nil }
+        return String(format: "mic %.1fs, system %.1fs", micDuration, systemDuration)
+    }
+
+    private func repairHalfDurationSystemWAVIfNeeded(in files: [URL?]) -> Bool {
+        guard files.count >= 2,
+              let micDuration = audioDuration(at: files[0]),
+              let systemURL = files[1],
+              let systemDuration = audioDuration(at: systemURL),
+              micDuration >= 60,
+              systemURL.pathExtension.caseInsensitiveCompare("wav") == .orderedSame,
+              (0.48...0.52).contains(systemDuration / micDuration) else { return false }
+        do {
+            try halveWAVSampleRate(at: systemURL)
+            return true
+        } catch {
+            return false
+        }
+    }
+
+    private func halveWAVSampleRate(at url: URL) throws {
+        let handle = try FileHandle(forUpdating: url)
+        defer { try? handle.close() }
+
+        try handle.seek(toOffset: 0)
+        guard let riffHeader = try handle.read(upToCount: 12),
+              riffHeader.count == 12,
+              String(data: riffHeader[0..<4], encoding: .ascii) == "RIFF",
+              String(data: riffHeader[8..<12], encoding: .ascii) == "WAVE" else {
+            throw NSError(domain: "AudioManager", code: -2, userInfo: [NSLocalizedDescriptionKey: "Invalid WAV header"])
+        }
+
+        var offset: UInt64 = 12
+        while true {
+            try handle.seek(toOffset: offset)
+            guard let chunkHeader = try handle.read(upToCount: 8), chunkHeader.count == 8 else { break }
+            let chunkID = String(data: chunkHeader[0..<4], encoding: .ascii)
+            let chunkSize = UInt32(chunkHeader[4])
+                | (UInt32(chunkHeader[5]) << 8)
+                | (UInt32(chunkHeader[6]) << 16)
+                | (UInt32(chunkHeader[7]) << 24)
+            let chunkDataOffset = offset + 8
+
+            if chunkID == "fmt ", chunkSize >= 16 {
+                try handle.seek(toOffset: chunkDataOffset)
+                guard let format = try handle.read(upToCount: 16), format.count == 16 else { break }
+                let audioFormat = UInt16(format[0]) | (UInt16(format[1]) << 8)
+                let blockAlign = UInt16(format[12]) | (UInt16(format[13]) << 8)
+                let sampleRate = UInt32(format[4])
+                    | (UInt32(format[5]) << 8)
+                    | (UInt32(format[6]) << 16)
+                    | (UInt32(format[7]) << 24)
+                guard audioFormat == 1, sampleRate >= 16_000, sampleRate.isMultiple(of: 2) else {
+                    throw NSError(domain: "AudioManager", code: -3, userInfo: [NSLocalizedDescriptionKey: "Unsupported WAV format"])
+                }
+
+                let correctedSampleRate = sampleRate / 2
+                let correctedByteRate = correctedSampleRate * UInt32(blockAlign)
+                try handle.seek(toOffset: chunkDataOffset + 4)
+                try handle.write(contentsOf: littleEndianData(correctedSampleRate))
+                try handle.write(contentsOf: littleEndianData(correctedByteRate))
+                try handle.synchronize()
+                return
+            }
+
+            offset = chunkDataOffset + UInt64(chunkSize) + UInt64(chunkSize % 2)
+        }
+
+        throw NSError(domain: "AudioManager", code: -4, userInfo: [NSLocalizedDescriptionKey: "WAV format chunk was not found"])
+    }
+
+    private func littleEndianData(_ value: UInt32) -> Data {
+        var littleEndianValue = value.littleEndian
+        return withUnsafeBytes(of: &littleEndianValue) { Data($0) }
+    }
+
+    private func audioDuration(at url: URL?) -> TimeInterval? {
+        guard let url,
+              let file = try? AVAudioFile(forReading: url),
+              file.processingFormat.sampleRate > 0 else { return nil }
+        return Double(file.length) / file.processingFormat.sampleRate
+    }
+
+    private func streamDescriptionSummary(_ description: AudioStreamBasicDescription?) -> String {
+        guard let description else { return "unavailable" }
+        return String(
+            format: "sampleRate=%.3f,formatID=%u,flags=%u,bytesPerPacket=%u,framesPerPacket=%u,bytesPerFrame=%u,channels=%u,bitsPerChannel=%u",
+            description.mSampleRate,
+            description.mFormatID,
+            description.mFormatFlags,
+            description.mBytesPerPacket,
+            description.mFramesPerPacket,
+            description.mBytesPerFrame,
+            description.mChannelsPerFrame,
+            description.mBitsPerChannel
+        )
+    }
+
+    private func audioFormatSummary(_ format: AVAudioFormat) -> String {
+        "sampleRate=\(format.sampleRate),channels=\(format.channelCount),commonFormat=\(format.commonFormat.rawValue),interleaved=\(format.isInterleaved)"
+    }
+
+    private func audioFileSummary(_ url: URL?) -> String {
+        guard let url else { return "missing" }
+        guard let file = try? AVAudioFile(forReading: url), file.processingFormat.sampleRate > 0 else {
+            return "\(url.lastPathComponent):unreadable"
+        }
+        let duration = Double(file.length) / file.processingFormat.sampleRate
+        return String(
+            format: "%@:sampleRate=%.3f,channels=%u,frames=%lld,duration=%.6f",
+            url.lastPathComponent,
+            file.processingFormat.sampleRate,
+            file.processingFormat.channelCount,
+            file.length,
+            duration
+        )
+    }
+
+    private func writeCaptureDiagnostics(
+        sessionID: UUID,
+        captureStartedAt: Date,
+        preRepairFileSummaries: [String],
+        repairedFiles: [URL?],
+        repairApplied: Bool,
+        audioFolder: URL?
+    ) {
+        guard let audioFolder else { return }
+        let callbackDuration = systemDiagnostics.firstCallbackAt.flatMap { first in
+            systemDiagnostics.lastCallbackAt.map { $0.timeIntervalSince(first) }
+        }
+        let sampleTimeDelta = systemDiagnostics.firstSampleTime.flatMap { first in
+            systemDiagnostics.lastSampleTime.map { $0 - first }
+        }
+        let hostTimeDelta = systemDiagnostics.firstHostTime.flatMap { first in
+            systemDiagnostics.lastHostTime.map { $0 >= first ? $0 - first : 0 }
+        }
+        let inputFrameDuration = systemDiagnostics.selectedInputSampleRate.flatMap { sampleRate in
+            sampleRate > 0 ? Double(systemDiagnostics.inputFrameCount) / sampleRate : nil
+        }
+        let outputFrameDuration = systemDiagnostics.targetSampleRate.flatMap { sampleRate in
+            sampleRate > 0 ? Double(systemDiagnostics.outputFrameCount) / sampleRate : nil
+        }
+        let observedInputRate = callbackDuration.flatMap { duration in
+            duration > 0 ? Double(systemDiagnostics.inputFrameCount) / duration : nil
+        }
+        let preRepairMic = preRepairFileSummaries.indices.contains(0) ? preRepairFileSummaries[0] : "missing"
+        let preRepairSystem = preRepairFileSummaries.indices.contains(1) ? preRepairFileSummaries[1] : "missing"
+        let postRepairMic = repairedFiles.indices.contains(0) ? audioFileSummary(repairedFiles[0]) : "missing"
+        let postRepairSystem = repairedFiles.indices.contains(1) ? audioFileSummary(repairedFiles[1]) : "missing"
+        let callbackDurationLine = callbackDuration.map { String(format: "callbackWallDuration=%.6f", $0) } ?? "callbackWallDuration=unavailable"
+        let inputFrameDurationLine = inputFrameDuration.map { String(format: "inputFrameDurationAtSelectedRate=%.6f", $0) } ?? "inputFrameDurationAtSelectedRate=unavailable"
+        let outputFrameDurationLine = outputFrameDuration.map { String(format: "outputFrameDurationAtTargetRate=%.6f", $0) } ?? "outputFrameDurationAtTargetRate=unavailable"
+        let observedInputRateLine = observedInputRate.map { String(format: "observedInputFramesPerSecond=%.3f", $0) } ?? "observedInputFramesPerSecond=unavailable"
+        let sampleTimeDeltaLine = sampleTimeDelta.map { String(format: "sampleTimeDelta=%.6f", $0) } ?? "sampleTimeDelta=unavailable"
+        let hostTimeDeltaLine = hostTimeDelta.map { "hostTimeDelta=\($0)" } ?? "hostTimeDelta=unavailable"
+        let lines: [String] = [
+            "Meetingnotes system capture diagnostics",
+            "sessionID=\(sessionID.uuidString)",
+            "createdAt=\(ISO8601DateFormatter().string(from: Date()))",
+            String(format: "captureWallDuration=%.6f", Date().timeIntervalSince(captureStartedAt)),
+            "tapAdvertisedFormat=\(systemDiagnostics.tapAdvertisedFormat)",
+            "aggregateInputFormat=\(systemDiagnostics.aggregateInputFormat)",
+            "selectedInputFormat=\(systemDiagnostics.selectedInputFormat)",
+            "inputRateInference=\(systemDiagnostics.inputRateInference)",
+            "targetFormat=\(systemDiagnostics.targetFormat)",
+            "firstBufferLayout=\(systemDiagnostics.firstBufferLayout ?? "unavailable")",
+            "callbackCount=\(systemDiagnostics.callbackCount)",
+            "inputFrameCount=\(systemDiagnostics.inputFrameCount)",
+            "outputFrameCount=\(systemDiagnostics.outputFrameCount)",
+            "discardedCallbackCount=\(systemDiagnostics.discardedCallbackCount)",
+            callbackDurationLine,
+            inputFrameDurationLine,
+            outputFrameDurationLine,
+            observedInputRateLine,
+            sampleTimeDeltaLine,
+            hostTimeDeltaLine,
+            "repairApplied=\(repairApplied)",
+            "preRepairMic=\(preRepairMic)",
+            "preRepairSystem=\(preRepairSystem)",
+            "postRepairMic=\(postRepairMic)",
+            "postRepairSystem=\(postRepairSystem)"
+        ]
+        let diagnosticsURL = audioFolder.appendingPathComponent("audio-diagnostics-\(sessionID.uuidString).txt")
+        try? lines.joined(separator: "\n").appending("\n").write(
+            to: diagnosticsURL,
+            atomically: true,
+            encoding: .utf8
+        )
+    }
+        
     private func resetAudioLevels() {
         micAudioLevel = 0
         systemAudioLevel = 0

meetingnotes/Managers/LocalStorageManager.swift

@@ -152,6 +152,101 @@ class LocalStorageManager {
         }
     }
 
+    func mergeMeeting(_ continuation: Meeting, into previous: Meeting) -> Meeting? {
+        guard continuation.id != previous.id, continuation.date >= previous.date else { return nil }
+
+        let previousFolder = recoveryDirectory.appendingPathComponent(previous.id.uuidString, isDirectory: true)
+        let continuationFolder = recoveryAudioFolder(named: continuation.id.uuidString)
+        var copiedAudioURLs: [URL] = []
+        var createdPreviousFolder = false
+
+        if let continuationFolder {
+            if !FileManager.default.fileExists(atPath: previousFolder.path) {
+                do {
+                    try FileManager.default.createDirectory(at: previousFolder, withIntermediateDirectories: true)
+                    createdPreviousFolder = true
+                } catch {
+                    return nil
+                }
+            }
+
+            let recoveryFiles = recoveryAudioFiles(in: continuationFolder).map(\.url)
+                + recoveryDiagnosticFiles(in: continuationFolder)
+            for recoveryFile in recoveryFiles {
+                let destination = previousFolder.appendingPathComponent(recoveryFile.lastPathComponent)
+                if FileManager.default.fileExists(atPath: destination.path) {
+                    guard FileManager.default.contentsEqual(
+                        atPath: recoveryFile.path,
+                        andPath: destination.path
+                    ) else {
+                        rollbackMergedAudio(copiedAudioURLs, removeFolder: createdPreviousFolder ? previousFolder : nil)
+                        return nil
+                    }
+                    continue
+                }
+
+                do {
+                    try FileManager.default.copyItem(at: recoveryFile, to: destination)
+                    copiedAudioURLs.append(destination)
+                } catch {
+                    rollbackMergedAudio(copiedAudioURLs, removeFolder: createdPreviousFolder ? previousFolder : nil)
+                    return nil
+                }
+            }
+        }
+
+        var merged = previous
+        var seenChunkIDs = Set<UUID>()
+        merged.transcriptChunks = (previous.transcriptChunks + continuation.transcriptChunks)
+            .filter { seenChunkIDs.insert($0.id).inserted }
+            .sorted {
+                if $0.timestamp == $1.timestamp {
+                    return $0.id.uuidString < $1.id.uuidString
+                }
+                return $0.timestamp < $1.timestamp
+            }
+        merged.userNotes = mergedText(previous.userNotes, continuation.userNotes)
+        merged.generatedNotes = mergedText(previous.generatedNotes, continuation.generatedNotes)
+        merged.templateId = previous.templateId ?? continuation.templateId
+        merged.transcriptionError = previous.transcriptionError ?? continuation.transcriptionError
+        if !recoveryAudioFiles(in: previousFolder).isEmpty {
+            merged.recoveryAudioFolderName = previous.id.uuidString
+        }
+
+        guard saveMeeting(merged) else {
+            rollbackMergedAudio(copiedAudioURLs, removeFolder: createdPreviousFolder ? previousFolder : nil)
+            return nil
+        }
+
+        guard deleteMeeting(continuation) else {
+            _ = saveMeeting(previous)
+            rollbackMergedAudio(copiedAudioURLs, removeFolder: createdPreviousFolder ? previousFolder : nil)
+            return nil
+        }
+
+        if let continuationFolder {
+            try? FileManager.default.removeItem(at: continuationFolder)
+        }
+        return merged
+    }
+
+    private func mergedText(_ first: String, _ second: String) -> String {
+        let first = first.trimmingCharacters(in: .whitespacesAndNewlines)
+        let second = second.trimmingCharacters(in: .whitespacesAndNewlines)
+        guard !first.isEmpty else { return second }
+        guard !second.isEmpty, second != first else { return first }
+        return first + "\n\n---\n\n" + second
+    }
+
+    private func rollbackMergedAudio(_ copiedURLs: [URL], removeFolder folder: URL?) {
+        for url in copiedURLs {
+            try? FileManager.default.removeItem(at: url)
+        }
+        if let folder, recoveryAudioFiles(in: folder).isEmpty {
+            try? FileManager.default.removeItem(at: folder)
+        }
+    }
+
     // MARK: - Recovery Audio
 
     func preserveAudioFiles(_ urls: [URL], for meetingID: UUID) -> URL? {
@@ -255,51 +350,30 @@ class LocalStorageManager {
         }
     }
 
-    func findRecoveryAudioFolder(for meeting: Meeting) -> URL? {
+    private func recoveryDiagnosticFiles(in folder: URL) -> [URL] {
-        if let name = meeting.recoveryAudioFolderName,
+        guard let files = try? FileManager.default.contentsOfDirectory(
-           let folder = recoveryAudioFolder(named: name) {
+            at: folder,
-            return folder
+            includingPropertiesForKeys: [.isRegularFileKey],
-        }
-
-        let claimedFolderNames = Set(
-            loadMeetings()
-                .filter { $0.id != meeting.id }
-                .compactMap(\.recoveryAudioFolderName)
-        )
-        guard let folders = try? FileManager.default.contentsOfDirectory(
-            at: recoveryDirectory,
-            includingPropertiesForKeys: [.isDirectoryKey, .creationDateKey, .contentModificationDateKey],
             options: [.skipsHiddenFiles]
         ) else {
-            return nil
+            return []
         }
 
-        let candidates = folders.compactMap { folder -> (url: URL, distance: TimeInterval)? in
+        return files.filter { url in
-            let folderValues = try? folder.resourceValues(
+            let values = try? url.resourceValues(forKeys: [.isRegularFileKey])
-                forKeys: [.isDirectoryKey, .creationDateKey, .contentModificationDateKey]
+            return values?.isRegularFile == true
-            )
+                && url.pathExtension.caseInsensitiveCompare("txt") == .orderedSame
-            let files = recoveryAudioFiles(in: folder)
+                && url.lastPathComponent.lowercased().hasPrefix("audio-diagnostics-")
-            guard folderValues?.isDirectory == true,
-                  !claimedFolderNames.contains(folder.lastPathComponent),
-                  !files.isEmpty else {
-                return nil
         }
-            let dates = files.compactMap { file -> Date? in
-                let values = try? file.url.resourceValues(forKeys: [.creationDateKey, .contentModificationDateKey])
-                return values?.creationDate ?? values?.contentModificationDate
-            }
-            let referenceDate = dates.min()
-                ?? folderValues?.creationDate
-                ?? folderValues?.contentModificationDate
-            guard let referenceDate else { return nil }
-            return (folder, abs(referenceDate.timeIntervalSince(meeting.date)))
     }
 
-        // This fallback links recovery files created by older app versions.
+    func findRecoveryAudioFolder(for meeting: Meeting) -> URL? {
-        return candidates
+        let canonicalName = meeting.id.uuidString
-            .filter { $0.distance <= 12 * 60 * 60 }
+        guard meeting.recoveryAudioFolderName == nil
-            .min(by: { $0.distance < $1.distance })?
+                || meeting.recoveryAudioFolderName?.caseInsensitiveCompare(canonicalName) == .orderedSame else {
-            .url
+            return nil
+        }
+        return recoveryAudioFolder(named: canonicalName)
     }
 
     func deleteRecoveryAudioFolder(_ folder: URL) {

meetingnotes/Managers/RecordingSessionManager.swift

@@ -2,6 +2,12 @@ import Foundation
 import SwiftUI
 import Combine
 
+struct RecordingCompletion {
+    let chunks: [TranscriptChunk]
+    let recoveryAudioFolderName: String?
+    let transcriptionError: String?
+}
+
 /// Manages recording sessions at the app level to persist across navigation
 @MainActor
 class RecordingSessionManager: ObservableObject {
@@ -14,9 +20,11 @@ class RecordingSessionManager: ObservableObject {
     @Published var errorMessage: String?
     @Published var activeRecordingTranscriptChunksUpdated: [TranscriptChunk] = []
     
-    private let audioManager = AudioManager.shared
+    private var audioManager = AudioManager.shared
     private var cancellables = Set<AnyCancellable>()
+    private var audioManagerCancellables = Set<AnyCancellable>()
     private let transcriptUpdateSubject = PassthroughSubject<[TranscriptChunk], Never>()
+    private var processingMeetingIds = Set<UUID>()
     
     // Store transcript chunks for the active recording session
     private var activeRecordingTranscriptChunks: [TranscriptChunk] = []
@@ -27,24 +35,19 @@ class RecordingSessionManager: ObservableObject {
     }
     
     private func setupAudioManagerBindings() {
+        audioManagerCancellables.removeAll()
         // Bind to audio manager state
         audioManager.$isRecording
             .sink { [weak self] isRecording in
                 self?.isRecording = isRecording
             }
-            .store(in: &cancellables)
+            .store(in: &audioManagerCancellables)
-        
-        audioManager.$isProcessing
-            .sink { [weak self] isProcessing in
-                self?.isProcessing = isProcessing
-            }
-            .store(in: &cancellables)
 
         audioManager.$errorMessage
             .sink { [weak self] errorMessage in
                 self?.errorMessage = errorMessage
             }
-            .store(in: &cancellables)
+            .store(in: &audioManagerCancellables)
         
         // When transcript chunks change, store them for the active recording and send to debouncer
         audioManager.$transcriptChunks
@@ -55,7 +58,7 @@ class RecordingSessionManager: ObservableObject {
                 
                 self.transcriptUpdateSubject.send(newChunks)
             }
-            .store(in: &cancellables)
+            .store(in: &audioManagerCancellables)
     }
     
     private func setupDebouncedSaving() {
@@ -84,22 +87,40 @@ class RecordingSessionManager: ObservableObject {
         audioManager.startRecording(for: meetingId)
     }
     
-    func stopRecording() async -> [TranscriptChunk] {
+    func stopRecording() async -> RecordingCompletion {
         print("🛑 Stopping recording for meeting: \(activeMeetingId?.uuidString ?? "unknown")")
         
         guard let meetingId = activeMeetingId else {
             audioManager.cancelRecording()
             recordingStartedAt = nil
-            return []
+            return RecordingCompletion(chunks: [], recoveryAudioFolderName: nil, transcriptionError: nil)
         }
-        recordingStartedAt = nil
+
-        let chunks = await audioManager.stopRecordingAndTranscribe()
+        let completedAudioManager = audioManager
-        activeRecordingTranscriptChunks = chunks
+        audioManager = AudioManager()
-        activeRecordingTranscriptChunksUpdated = chunks
+        setupAudioManagerBindings()
-        updateActiveMeetingTranscript(meetingId: meetingId, chunks: chunks)
         activeMeetingId = nil
-        activeRecordingTranscriptChunks = []
+        recordingStartedAt = nil
-        return chunks
+        processingMeetingIds.insert(meetingId)
+        isProcessing = true
+        defer {
+            processingMeetingIds.remove(meetingId)
+            isProcessing = !processingMeetingIds.isEmpty
+        }
+
+        let chunks = await completedAudioManager.stopRecordingAndTranscribe()
+        let completion = RecordingCompletion(
+            chunks: chunks,
+            recoveryAudioFolderName: completedAudioManager.lastRecoveryAudioFolderName,
+            transcriptionError: completedAudioManager.errorMessage
+        )
+        updateActiveMeetingTranscript(
+            meetingId: meetingId,
+            chunks: chunks,
+            recoveryAudioFolderName: completion.recoveryAudioFolderName,
+            transcriptionError: completion.transcriptionError
+        )
+        return completion
     }
         
     func cancelRecording() {
@@ -113,17 +134,26 @@ class RecordingSessionManager: ObservableObject {
         return isRecording && activeMeetingId == meetingId
     }
 
-    var lastRecoveryAudioFolderName: String? {
+    func isProcessingMeeting(_ meetingId: UUID) -> Bool {
-        audioManager.lastRecoveryAudioFolderName
+        processingMeetingIds.contains(meetingId)
     }
 
-    private func updateActiveMeetingTranscript(meetingId: UUID, chunks: [TranscriptChunk]) {
+    private func updateActiveMeetingTranscript(
+        meetingId: UUID,
+        chunks: [TranscriptChunk],
+        recoveryAudioFolderName: String? = nil,
+        transcriptionError: String? = nil
+    ) {
         // Load all meetings
         var meetings = LocalStorageManager.shared.loadMeetings()
         
         // Find and update the active meeting
         if let index = meetings.firstIndex(where: { $0.id == meetingId }) {
             meetings[index].transcriptChunks = chunks
+            if let recoveryAudioFolderName {
+                meetings[index].recoveryAudioFolderName = recoveryAudioFolderName
+            }
+            meetings[index].transcriptionError = transcriptionError
             
             // Save the updated meeting
             let success = LocalStorageManager.shared.saveMeeting(meetings[index])

meetingnotes/Models/Meeting.swift

@@ -99,6 +99,7 @@ struct Meeting: Codable, Identifiable, Hashable {
     var generatedNotes: String
     var templateId: UUID?  // Add property to track per-meeting template
     var recoveryAudioFolderName: String?
+    var transcriptionError: String?
     // MARK: - Data versioning
     /// Version of this Meeting record on disk. Useful for migration.
     var dataVersion: Int
@@ -113,6 +114,7 @@ struct Meeting: Codable, Identifiable, Hashable {
          generatedNotes: String = "",
          templateId: UUID? = nil,
          recoveryAudioFolderName: String? = nil,
+         transcriptionError: String? = nil,
          dataVersion: Int = Meeting.currentDataVersion) {
         self.id = id
         self.date = date
@@ -122,6 +124,7 @@ struct Meeting: Codable, Identifiable, Hashable {
         self.generatedNotes = generatedNotes
         self.templateId = templateId
         self.recoveryAudioFolderName = recoveryAudioFolderName
+        self.transcriptionError = transcriptionError
         self.dataVersion = dataVersion
     }
     

meetingnotes/ProcessTap/CoreAudioUtils.swift

@@ -116,6 +116,47 @@ extension AudioObjectID {
         try read(kAudioTapPropertyFormat, defaultValue: AudioStreamBasicDescription())
     }
 
+    /// Reads the virtual format of the first input stream exposed by this device.
+    ///
+    /// An aggregate device can adapt a tap to the active output hardware. Its
+    /// input stream format is therefore the format delivered to the I/O proc,
+    /// which can differ from the tap object's originally advertised format.
+    func readInputStreamBasicDescription() throws -> AudioStreamBasicDescription {
+        var streamsAddress = AudioObjectPropertyAddress(
+            mSelector: kAudioDevicePropertyStreams,
+            mScope: kAudioObjectPropertyScopeGlobal,
+            mElement: kAudioObjectPropertyElementMain
+        )
+        var dataSize: UInt32 = 0
+        var status = AudioObjectGetPropertyDataSize(self, &streamsAddress, 0, nil, &dataSize)
+        guard status == noErr else {
+            throw "Error reading device stream list size: \(status)"
+        }
+
+        var streamIDs = [AudioObjectID](
+            repeating: .unknown,
+            count: Int(dataSize) / MemoryLayout<AudioObjectID>.size
+        )
+        status = AudioObjectGetPropertyData(self, &streamsAddress, 0, nil, &dataSize, &streamIDs)
+        guard status == noErr else {
+            throw "Error reading device stream list: \(status)"
+        }
+
+        for streamID in streamIDs {
+            let direction: UInt32 = try streamID.read(
+                kAudioStreamPropertyDirection,
+                defaultValue: 0
+            )
+            guard direction == 1 else { continue }
+            return try streamID.read(
+                kAudioStreamPropertyVirtualFormat,
+                defaultValue: AudioStreamBasicDescription()
+            )
+        }
+
+        throw "Device has no input stream."
+    }
+
     private func requireSystemObject() throws {
         if self != .system { throw "Only supported for the system object." }
     }

meetingnotes/ProcessTap/ProcessTap.swift

@@ -63,6 +63,10 @@ final class ProcessTap {
     @ObservationIgnored
     private(set) var tapStreamDescription: AudioStreamBasicDescription?
     @ObservationIgnored
+    private(set) var tapAdvertisedStreamDescription: AudioStreamBasicDescription?
+    @ObservationIgnored
+    private(set) var aggregateInputStreamDescription: AudioStreamBasicDescription?
+    @ObservationIgnored
     private var invalidationHandler: InvalidationHandler?
 
     @ObservationIgnored
@@ -138,11 +142,11 @@ final class ProcessTap {
             tapDescription = CATapDescription(stereoMixdownOfProcesses: [process.objectID])
             logger.debug("Configuring tap for single process objectID: \(process.objectID)")
         case .systemAudio:
-            // Keep the HAL tap's buffer layout consistent with the default
+            // The transcription file is mono, so ask Core Audio for a mono
-            // output stream. AudioManager performs the stereo-to-mono mix when
+            // mixdown at the source. This avoids interpreting a stereo HAL
-            // it converts the captured audio to the 16 kHz transcription file.
+            // buffer as half as many frames before the 16 kHz conversion.
-            tapDescription = CATapDescription(stereoGlobalTapButExcludeProcesses: [])
+            tapDescription = CATapDescription(monoGlobalTapButExcludeProcesses: [])
-            logger.debug("Configuring a stereo global system audio tap.")
+            logger.info("Configuring a mono global system audio tap.")
         }
         
         tapDescription.uuid = UUID()
@@ -248,8 +252,23 @@ final class ProcessTap {
 
         do {
             logger.debug("Attempting to read audio tap stream basic description for tapID #\(tapID)...")
-            self.tapStreamDescription = try tapID.readAudioTapStreamBasicDescription()
+            let advertisedDescription = try tapID.readAudioTapStreamBasicDescription()
-            logger.debug("Successfully read tap stream description: \(String(describing: self.tapStreamDescription))")
+            self.tapAdvertisedStreamDescription = advertisedDescription
+
+            // The aggregate device may adapt the tap to the active hardware's
+            // sample rate. Its input stream is the format actually delivered
+            // to the I/O proc, so use that rather than the tap's pre-aggregate
+            // advertisement. Using the latter can halve the written duration
+            // when, for example, a 48 kHz tap is delivered at 24 kHz.
+            do {
+                let aggregateDescription = try aggregateDeviceID.readInputStreamBasicDescription()
+                self.aggregateInputStreamDescription = aggregateDescription
+                self.tapStreamDescription = aggregateDescription
+                logger.info("Using aggregate input stream description: \(String(describing: self.tapStreamDescription), privacy: .public); tap advertised: \(String(describing: advertisedDescription), privacy: .public)")
+            } catch {
+                self.tapStreamDescription = advertisedDescription
+                logger.warning("Could not read aggregate input stream format; using tap format: \(error, privacy: .public)")
+            }
         } catch {
             logger.error("Failed to read audio tap stream basic description for tapID #\(tapID): \(error)")
             throw error // Propagate error

meetingnotes/Services/CoderAPIClient.swift

@@ -30,6 +30,7 @@ enum CoderAPIError: LocalizedError {
     case missingModel(String)
     case invalidResponse
     case serviceError(Int, String)
+    case audioPreparationFailed(String, String)
 
     var errorDescription: String? {
         switch self {
@@ -43,6 +44,8 @@ enum CoderAPIError: LocalizedError {
             return "Coder returned an invalid response."
         case .serviceError(let status, let message):
             return "Coder request failed (\(status)): \(message)"
+        case .audioPreparationFailed(let filename, let message):
+            return "Could not prepare \(filename) for transcription: \(message)"
         }
     }
 }
@@ -179,7 +182,12 @@ final class CoderAPIClient {
         let selectedModel = model.trimmingCharacters(in: .whitespacesAndNewlines)
         guard !selectedModel.isEmpty else { throw CoderAPIError.missingModel("transcription") }
         let apiKey = try requiredAPIKey(KeychainHelper.shared.getCoderAPIKey() ?? "")
-        let chunks = try makeAudioChunks(from: fileURL, preserveSpeakerIdentity: diarization)
+        let chunks: [AudioChunk]
+        do {
+            chunks = try makeAudioChunks(from: fileURL, preserveSpeakerIdentity: diarization)
+        } catch {
+            throw CoderAPIError.audioPreparationFailed(fileURL.lastPathComponent, error.localizedDescription)
+        }
         defer {
             for chunk in chunks where chunk.isTemporary {
                 try? FileManager.default.removeItem(at: chunk.url)
@@ -260,13 +268,38 @@ final class CoderAPIClient {
            let size = attributes[.size] as? NSNumber {
             request.setValue(size.stringValue, forHTTPHeaderField: "Content-Length")
         }
-        let (data, response) = try await transcriptionSession.upload(for: request, fromFile: bodyURL)
+        let (data, response) = try await uploadTranscription(request: request, bodyURL: bodyURL)
         try validate(response: response, data: data)
         let decoded = try JSONDecoder().decode(TranscriptionResponse.self, from: data)
         let segments = decoded.segments ?? segments(from: decoded.words ?? [])
         return Transcription(text: decoded.text, segments: segments)
     }
 
+    private func uploadTranscription(request: URLRequest, bodyURL: URL) async throws -> (Data, URLResponse) {
+        let retryDelays: [UInt64] = [3, 10]
+        for attempt in 0...retryDelays.count {
+            do {
+                return try await transcriptionSession.upload(for: request, fromFile: bodyURL)
+            } catch {
+                guard attempt < retryDelays.count, isRetryableTranscriptionError(error) else {
+                    throw error
+                }
+                try await Task.sleep(nanoseconds: retryDelays[attempt] * 1_000_000_000)
+            }
+        }
+        throw CoderAPIError.invalidResponse
+    }
+
+    private func isRetryableTranscriptionError(_ error: Error) -> Bool {
+        guard let urlError = error as? URLError else { return false }
+        switch urlError.code {
+        case .networkConnectionLost, .cannotConnectToHost, .timedOut:
+            return true
+        default:
+            return false
+        }
+    }
+
     private func makeAudioChunks(from fileURL: URL, preserveSpeakerIdentity: Bool) throws -> [AudioChunk] {
         let input = try AVAudioFile(forReading: fileURL)
         let format = input.processingFormat
@@ -275,6 +308,13 @@ final class CoderAPIClient {
         let framesPerChunk = preserveSpeakerIdentity
             ? max(1, input.length)
             : AVAudioFramePosition(format.sampleRate * transcriptionChunkDuration)
+
+        if fileURL.pathExtension.caseInsensitiveCompare("wav") == .orderedSame,
+           input.fileFormat.streamDescription.pointee.mFormatID == kAudioFormatLinearPCM,
+           input.length <= framesPerChunk {
+            return [AudioChunk(url: fileURL, offset: 0, isTemporary: false)]
+        }
+
         var chunks: [AudioChunk] = []
         var frameOffset: AVAudioFramePosition = 0
 

meetingnotes/Services/LocalAPIServer.swift

@@ -182,13 +182,13 @@ private enum LocalAPIRouter {
 }
 
 private enum LocalRecordingError: LocalizedError {
-    case processing
+    case stopping
     case saveFailed
 
     var errorDescription: String? {
         switch self {
-        case .processing:
+        case .stopping:
-            return "The previous meeting is still processing."
+            return "The current recording is still stopping."
         case .saveFailed:
             return "Could not create a meeting for this recording."
         }
@@ -200,18 +200,20 @@ private final class LocalRecordingController {
     static let shared = LocalRecordingController()
 
     private let recordingManager = RecordingSessionManager.shared
+    private let stopGraceNanoseconds: UInt64 = 10_000_000_000
     private var isStopping = false
+    private var pendingStopTask: Task<Void, Never>?
 
     private init() {}
 
     func statusPayload() -> [String: Any] {
         let state: String
-        if isStopping || recordingManager.isProcessing {
+        if recordingManager.isRecording {
-            state = "processing"
-        } else if recordingManager.isRecording {
             state = "recording"
         } else if recordingManager.activeMeetingId != nil {
             state = "starting"
+        } else if isStopping || recordingManager.isProcessing {
+            state = "processing"
         } else {
             state = "idle"
         }
@@ -237,8 +239,14 @@ private final class LocalRecordingController {
     }
 
     func startRecording() throws -> [String: Any] {
-        if isStopping || recordingManager.isProcessing {
+        if let pendingStopTask {
-            throw LocalRecordingError.processing
+            pendingStopTask.cancel()
+            self.pendingStopTask = nil
+            isStopping = false
+            return statusPayload()
+        }
+        if isStopping {
+            throw LocalRecordingError.stopping
         }
         if recordingManager.activeMeetingId != nil {
             return statusPayload()
@@ -258,14 +266,22 @@ private final class LocalRecordingController {
             return statusPayload()
         }
         isStopping = true
-        Task { [weak self] in
+        pendingStopTask = Task { [weak self] in
+            try? await Task.sleep(nanoseconds: self?.stopGraceNanoseconds ?? 0)
+            guard !Task.isCancelled else { return }
             await self?.finishRecording()
         }
         return statusPayload()
     }
 
     func cancelRecording() -> [String: Any] {
-        guard !isStopping else { return statusPayload() }
+        if let pendingStopTask {
+            pendingStopTask.cancel()
+            self.pendingStopTask = nil
+            isStopping = false
+        } else if isStopping {
+            return statusPayload()
+        }
         let meetingID = recordingManager.activeMeetingId
         recordingManager.cancelRecording()
         if let meetingID,
@@ -277,16 +293,18 @@ private final class LocalRecordingController {
     }
 
     private func finishRecording() async {
+        pendingStopTask = nil
         let meetingID = recordingManager.activeMeetingId
-        let chunks = await recordingManager.stopRecording()
+        isStopping = false
+        let completion = await recordingManager.stopRecording()
         guard let meetingID,
               var meeting = LocalStorageManager.shared.loadMeetings().first(where: { $0.id == meetingID }) else {
-            isStopping = false
             return
         }
 
-        meeting.transcriptChunks = chunks
+        meeting.transcriptChunks = completion.chunks
-        meeting.recoveryAudioFolderName = recordingManager.lastRecoveryAudioFolderName
+        meeting.recoveryAudioFolderName = completion.recoveryAudioFolderName
+        meeting.transcriptionError = completion.transcriptionError
         let templates = LocalStorageManager.shared.loadTemplates()
         if meeting.templateId == nil {
             meeting.templateId = LocalStorageManager.shared.preferredTemplateID(in: templates)
@@ -335,7 +353,6 @@ private final class LocalRecordingController {
                 NotificationCenter.default.post(name: .meetingSaved, object: meeting)
             }
         }
-        isStopping = false
     }
 }
 

meetingnotes/ViewModels/MeetingListViewModel.swift

@@ -67,6 +67,28 @@ class MeetingListViewModel: ObservableObject {
         _ = LocalStorageManager.shared.deleteMeeting(meeting)
     }
 
+    func previousMeeting(for meeting: Meeting) -> Meeting? {
+        meetings
+            .filter { $0.id != meeting.id && $0.date < meeting.date }
+            .max { $0.date < $1.date }
+    }
+
+    func mergeIntoPrevious(_ meeting: Meeting) -> Meeting? {
+        guard let previous = previousMeeting(for: meeting),
+              let merged = LocalStorageManager.shared.mergeMeeting(meeting, into: previous) else {
+            errorMessage = "The meetings could not be merged. Their original records and audio were kept."
+            return nil
+        }
+
+        meetings.removeAll { $0.id == meeting.id || $0.id == previous.id }
+        meetings.append(merged)
+        meetings.sort { $0.date > $1.date }
+        NotificationCenter.default.post(name: .meetingSaved, object: merged)
+        NotificationCenter.default.post(name: .meetingDeleted, object: meeting)
+        PostHogSDK.shared.capture("meetings_merged")
+        return merged
+    }
+    
     func createNewMeeting() -> Meeting {
         let newMeeting = Meeting(templateId: LocalStorageManager.shared.preferredTemplateID())
         meetings.insert(newMeeting, at: 0)

meetingnotes/ViewModels/MeetingViewModel.swift

@@ -47,7 +47,7 @@ class MeetingViewModel: ObservableObject {
 
     var isProcessing: Bool {
         return isRetryingTranscription ||
-            (recordingSessionManager.isProcessing && recordingSessionManager.activeMeetingId == meeting.id)
+            recordingSessionManager.isProcessingMeeting(meeting.id)
     }
 
     var canRetryTranscription: Bool {
@@ -137,18 +137,27 @@ class MeetingViewModel: ObservableObject {
             self.meeting.transcriptChunks = recordingSessionManager.getTranscriptChunks(for: meeting.id)
         }
 
-        // Listen for final transcript updates for this meeting.
+        // Listen for transcript updates emitted while this meeting is recording.
         recordingSessionManager.$activeRecordingTranscriptChunksUpdated
             .dropFirst()
             .sink { [weak self] updatedChunks in
                 guard let self = self else { return }
-                // Only update if this meeting is the active recording
+                if recordingSessionManager.activeMeetingId == self.meeting.id {
-                if recordingSessionManager.isRecordingMeeting(self.meeting.id) {
                     self.meeting.transcriptChunks = updatedChunks
                 }
             }
             .store(in: &cancellables)
 
+        NotificationCenter.default.publisher(for: .meetingSaved)
+            .compactMap { $0.object as? Meeting }
+            .filter { [weak self] in $0.id == self?.meeting.id }
+            .sink { [weak self] savedMeeting in
+                guard let self, !self.isDeleted, self.meeting != savedMeeting else { return }
+                self.meeting = savedMeeting
+                self.refreshRecoveryAudioFolder()
+            }
+            .store(in: &cancellables)
+        
 
         
         // Auto-save when meeting properties change
@@ -212,9 +221,11 @@ class MeetingViewModel: ObservableObject {
     func stopRecording() {
         isStartingRecording = true
         Task {
-            let chunks = await recordingSessionManager.stopRecording()
+            let completion = await recordingSessionManager.stopRecording()
-            meeting.transcriptChunks = chunks
+            meeting.transcriptChunks = completion.chunks
-            meeting.recoveryAudioFolderName = recordingSessionManager.lastRecoveryAudioFolderName
+            meeting.recoveryAudioFolderName = completion.recoveryAudioFolderName
+            meeting.transcriptionError = completion.transcriptionError
+            errorMessage = completion.transcriptionError
             refreshRecoveryAudioFolder()
             saveMeeting()
             if !meeting.formattedTranscript.isEmpty {
@@ -238,6 +249,7 @@ class MeetingViewModel: ObservableObject {
                 )
                 meeting.transcriptChunks = chunks
                 meeting.recoveryAudioFolderName = recoveryAudioFolderURL.lastPathComponent
+                meeting.transcriptionError = nil
                 selectedTab = .transcript
 
                 guard saveMeeting() else {
@@ -247,6 +259,8 @@ class MeetingViewModel: ObservableObject {
                 await generateNotes()
             } catch {
                 errorMessage = error.localizedDescription
+                meeting.transcriptionError = error.localizedDescription
+                _ = saveMeeting()
                 print("Retry transcription failed: \(error)")
             }
         }
@@ -254,9 +268,7 @@ class MeetingViewModel: ObservableObject {
 
     private func refreshRecoveryAudioFolder() {
         recoveryAudioFolderURL = LocalStorageManager.shared.findRecoveryAudioFolder(for: meeting)
-        if let recoveryAudioFolderURL {
+        meeting.recoveryAudioFolderName = recoveryAudioFolderURL?.lastPathComponent
-            meeting.recoveryAudioFolderName = recoveryAudioFolderURL.lastPathComponent
-        }
     }
 
     func showAudioInFinder() {

meetingnotes/Views/MeetingListView.swift

@@ -6,6 +6,8 @@ struct MeetingListView: View {
     @StateObject private var recordingSessionManager = RecordingSessionManager.shared
     @State private var selectedMeeting: Meeting?
     @State private var navigationPath = NavigationPath()
+    @State private var recordingFailureMessage: String?
+    @State private var failedMeetingID: UUID?
     
     var body: some View {
         NavigationSplitView {
@@ -23,6 +25,38 @@ struct MeetingListView: View {
                     .background(Color.clear)
             }
         }
+        .onReceive(recordingSessionManager.$activeMeetingId.compactMap { $0 }) { meetingID in
+            if let meeting = LocalStorageManager.shared.loadMeetings().first(where: { $0.id == meetingID }) {
+                selectedMeeting = meeting
+            }
+        }
+        .onReceive(NotificationCenter.default.publisher(for: .meetingSaved)) { notification in
+            guard let savedMeeting = notification.object as? Meeting,
+                  selectedMeeting?.id == savedMeeting.id else { return }
+            selectedMeeting = savedMeeting
+        }
+        .onReceive(recordingSessionManager.$errorMessage.compactMap { $0 }) { message in
+            failedMeetingID = recordingSessionManager.activeMeetingId
+            recordingFailureMessage = message
+        }
+        .alert("Transcription Failed", isPresented: Binding(
+            get: { recordingFailureMessage != nil },
+            set: { if !$0 { recordingFailureMessage = nil } }
+        )) {
+            if failedMeetingID != nil {
+                Button("View Meeting") {
+                    selectFailedMeeting()
+                    recordingFailureMessage = nil
+                    recordingSessionManager.errorMessage = nil
+                }
+            }
+            Button("OK") {
+                recordingFailureMessage = nil
+                recordingSessionManager.errorMessage = nil
+            }
+        } message: {
+            Text(recordingFailureMessage ?? "")
+        }
     }
     
     private var sidebarContent: some View {
@@ -83,10 +117,19 @@ struct MeetingListView: View {
         NavigationStack(path: $navigationPath) {
             Group {
                 if let selectedMeeting = selectedMeeting {
-                    MeetingDetailContentView(meeting: selectedMeeting, onDelete: {
+                    MeetingDetailContentView(
+                        meeting: selectedMeeting,
+                        mergeCandidate: viewModel.previousMeeting(for: selectedMeeting),
+                        onMerge: { meeting in
+                            guard let merged = viewModel.mergeIntoPrevious(meeting) else { return false }
+                            self.selectedMeeting = merged
+                            return true
+                        },
+                        onDelete: {
                             // When a meeting is deleted from the detail view, clear the selection
                             self.selectedMeeting = nil
-                    })
+                        }
+                    )
                     .id(selectedMeeting.id) // Force recreation when selection changes
                 } else {
                     ContentUnavailableView(
@@ -152,6 +195,14 @@ struct MeetingListView: View {
             return DayGroup(day: dayString, date: date, meetings: meetings.sorted { $0.date > $1.date })
         }.sorted { $0.date > $1.date }
     }
+
+    private func selectFailedMeeting() {
+        guard let failedMeetingID,
+              let meeting = LocalStorageManager.shared.loadMeetings().first(where: { $0.id == failedMeetingID }) else {
+            return
+        }
+        selectedMeeting = meeting
+    }
 }
 
 struct DayGroup {
@@ -173,7 +224,14 @@ struct MeetingRowView: View {
                         .foregroundColor(.red)
                         .font(.headline)
                 }
-                Text(meeting.title.isEmpty ? "Untitled meeting" : meeting.title)
+                if meeting.transcriptionError != nil {
+                    Image(systemName: "exclamationmark.triangle.fill")
+                        .foregroundColor(.orange)
+                        .accessibilityLabel("Transcription failed")
+                }
+                Text(meeting.title.isEmpty
+                     ? (meeting.transcriptionError == nil ? "Untitled meeting" : "Transcription failed")
+                     : meeting.title)
                     .font(.headline)
                     .lineLimit(1)
             }
@@ -229,12 +287,22 @@ struct MeetingDetailContentView: View {
     @StateObject private var viewModel: MeetingViewModel
     @StateObject private var recordingSessionManager = RecordingSessionManager.shared
     @State private var showDeleteAlert = false
+    @State private var showMergeAlert = false
     @State private var isEditing = false
     @State private var showCopyConfirmation = false
+    let mergeCandidate: Meeting?
+    let onMerge: (Meeting) -> Bool
     let onDelete: () -> Void
     
-    init(meeting: Meeting, onDelete: @escaping () -> Void) {
+    init(
+        meeting: Meeting,
+        mergeCandidate: Meeting?,
+        onMerge: @escaping (Meeting) -> Bool,
+        onDelete: @escaping () -> Void
+    ) {
         self._viewModel = StateObject(wrappedValue: MeetingViewModel(meeting: meeting))
+        self.mergeCandidate = mergeCandidate
+        self.onMerge = onMerge
         self.onDelete = onDelete
     }
     
@@ -276,6 +344,17 @@ struct MeetingDetailContentView: View {
                             Divider()
                         }
 
+                        if mergeCandidate != nil {
+                            Button {
+                                showMergeAlert = true
+                            } label: {
+                                Label("Merge into Previous Meeting", systemImage: "arrow.triangle.merge")
+                            }
+                            .disabled(recordingSessionManager.isRecording || recordingSessionManager.isProcessing)
+
+                            Divider()
+                        }
+
                         Button("Delete Meeting", role: .destructive) {
                             showDeleteAlert = true
                         }
@@ -461,6 +540,23 @@ struct MeetingDetailContentView: View {
         } message: {
             Text("Are you sure you want to delete this meeting? This action cannot be undone.")
         }
+        .alert("Merge into Previous Meeting?", isPresented: $showMergeAlert) {
+            Button("Merge", role: .destructive) {
+                // Prevent the disappearing detail view from auto-saving the
+                // continuation after the storage layer removes it.
+                viewModel.isDeleted = true
+                if !onMerge(viewModel.meeting) {
+                    viewModel.isDeleted = false
+                    viewModel.errorMessage = "The meetings could not be merged. Their original records and audio were kept."
+                }
+            }
+            Button("Cancel", role: .cancel) { }
+        } message: {
+            let previousTitle = mergeCandidate?.title.isEmpty == false
+                ? mergeCandidate?.title ?? "the previous meeting"
+                : "the previous meeting"
+            Text("This combines this meeting's transcript, notes, and saved audio into \"\(previousTitle)\", keeps the earlier meeting's title and time, then removes this continuation.")
+        }
         .onDisappear {
             // A failed recording may still be empty. Keep it until the user
             // explicitly deletes it so app updates cannot erase history.
@@ -495,9 +591,36 @@ struct MeetingDetailContentView: View {
     }
     
     private var transcriptView: some View {
+        VStack(alignment: .leading, spacing: 10) {
+            if let transcriptionError = viewModel.meeting.transcriptionError {
+                HStack(alignment: .top, spacing: 10) {
+                    Image(systemName: "exclamationmark.triangle.fill")
+                        .foregroundColor(.orange)
+                    VStack(alignment: .leading, spacing: 4) {
+                        Text("Transcription failed")
+                            .font(.headline)
+                        Text(transcriptionError)
+                            .font(.caption)
+                            .foregroundColor(.secondary)
+                    }
+                    Spacer()
+                    if viewModel.recoveryAudioFolderURL != nil {
+                        Button("Retry") {
+                            viewModel.retryTranscription()
+                        }
+                        .disabled(!viewModel.canRetryTranscription)
+                    }
+                }
+                .padding()
+                .background(Color.orange.opacity(0.08))
+                .cornerRadius(8)
+            }
+
             ScrollView {
                 if viewModel.meeting.collapsedTranscriptChunks.isEmpty {
-                Text("Transcript will appear here...")
+                    Text(viewModel.meeting.transcriptionError == nil
+                         ? "Transcript will appear here..."
+                         : "No transcript was produced. The recording was kept and can be retried.")
                         .frame(maxWidth: .infinity, alignment: .leading)
                         .padding()
                         .foregroundColor(.secondary)
@@ -514,6 +637,7 @@ struct MeetingDetailContentView: View {
             .background(Color.gray.opacity(0.05))
             .cornerRadius(8)
         }
+    }
     
     private var enhancedNotesView: some View {
         VStack(alignment: .leading, spacing: 0) {