fix: preserve transcription failures and audio diagnostics

.github/workflows/release.yml

@@ -20,6 +20,9 @@ jobs:
     runs-on: macos-15
     env:
       VERSION: ${{ inputs.version }}
+      APPLE_ID: ${{ secrets.APPLE_ID }}
+      APPLE_TEAM_ID: ${{ secrets.APPLE_TEAM_ID }}
+      APPLE_APP_PASSWORD: ${{ secrets.APPLE_APP_PASSWORD }}
       SPARKLE_PRIVATE_KEY: ${{ secrets.SPARKLE_PRIVATE_KEY }}
     steps:
       - uses: actions/checkout@v7
@@ -31,7 +34,7 @@ jobs:
           APPLE_CERTIFICATE_P12: ${{ secrets.APPLE_CERTIFICATE_P12 }}
           APPLE_CERTIFICATE_PASSWORD: ${{ secrets.APPLE_CERTIFICATE_PASSWORD }}
         run: |
-          for variable in APPLE_CERTIFICATE_P12 APPLE_CERTIFICATE_PASSWORD SPARKLE_PRIVATE_KEY; do
+          for variable in APPLE_CERTIFICATE_P12 APPLE_CERTIFICATE_PASSWORD APPLE_ID APPLE_TEAM_ID APPLE_APP_PASSWORD SPARKLE_PRIVATE_KEY; do
             if [[ -z "${!variable:-}" ]]; then
               echo "Missing GitHub Actions secret: $variable" >&2
               exit 1
@@ -53,7 +56,7 @@ jobs:
           fi
           echo "SIGNING_IDENTITY=$signing_identity" >> "$GITHUB_ENV"
 
-      - name: Build and sign release
+      - name: Build, sign, and notarize release
         timeout-minutes: 30
         run: scripts/package_release.sh
 
@@ -70,13 +73,16 @@ jobs:
           GH_TOKEN: ${{ github.token }}
         run: |
           tag="v$VERSION"
-          if git rev-parse "$tag" >/dev/null 2>&1; then
-            echo "Tag already exists: $tag" >&2
-            exit 1
+          if gh release view "$tag" >/dev/null 2>&1; then
+            gh release upload "$tag" \
+              "$RUNNER_TEMP/meetingnotes-release/release/Meetingnotes-$VERSION.zip" \
+              "$RUNNER_TEMP/meetingnotes-release/release/appcast.xml" \
+              --clobber
+          else
+            gh release create "$tag" \
+              "$RUNNER_TEMP/meetingnotes-release/release/Meetingnotes-$VERSION.zip" \
+              "$RUNNER_TEMP/meetingnotes-release/release/appcast.xml" \
+              --target "$GITHUB_SHA" \
+              --title "Meetingnotes $VERSION" \
+              --generate-notes
           fi
-          gh release create "$tag" \
-            "$RUNNER_TEMP/meetingnotes-release/release/Meetingnotes-$VERSION.zip" \
-            "$RUNNER_TEMP/meetingnotes-release/release/appcast.xml" \
-            --target "$GITHUB_SHA" \
-            --title "Meetingnotes $VERSION" \
-            --generate-notes

Meetingnotes.xcodeproj/project.pbxproj

@@ -276,7 +276,7 @@
 				CODE_SIGN_IDENTITY = "Apple Development";
 				CODE_SIGN_STYLE = Automatic;
 				COMBINE_HIDPI_IMAGES = YES;
-				CURRENT_PROJECT_VERSION = 19;
+				CURRENT_PROJECT_VERSION = 41;
 				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.7;
+				MARKETING_VERSION = 1.1.29;
 				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 = 19;
+				CURRENT_PROJECT_VERSION = 41;
 				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.7;
+				MARKETING_VERSION = 1.1.29;
 				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/Info.plist

@@ -2,6 +2,8 @@
 <!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
 <plist version="1.0">
 <dict>
+	<key>LSUIElement</key>
+	<true/>
 	<key>NSAppTransportSecurity</key>
 	<dict>
 		<key>NSAllowsLocalNetworking</key>

meetingnotes/Managers/AudioManager.swift

@@ -3,6 +3,43 @@ import Combine
 import Foundation
 import SwiftUI
 
+private enum RecoveryTranscriptionError: LocalizedError {
+    case noAudioFiles
+    case noSpeech
+    case requestFailed(String)
+
+    var errorDescription: String? {
+        switch self {
+        case .noAudioFiles:
+            return "The saved recovery audio could not be found."
+        case .noSpeech:
+            return "No speech was detected in the saved recovery audio."
+        case .requestFailed(let details):
+            return "Retry transcription failed for \(details)"
+        }
+    }
+}
+
+private struct SystemCaptureDiagnostics {
+    var tapAdvertisedFormat = "unavailable"
+    var aggregateInputFormat = "unavailable"
+    var selectedInputFormat = "unavailable"
+    var targetFormat = "unavailable"
+    var selectedInputSampleRate: Double?
+    var targetSampleRate: Double?
+    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 {
@@ -14,50 +51,44 @@ final class AudioManager: NSObject, ObservableObject {
     @Published var errorMessage: String?
     @Published var micAudioLevel: Float = 0
     @Published var systemAudioLevel: Float = 0
+    private(set) var lastRecoveryAudioFolderName: String?
     
     private var audioEngine = AVAudioEngine()
     private var sessionID = UUID()
+    private var meetingID = UUID()
     private var processTap: ProcessTap?
-    private let audioProcessController = AudioProcessController()
     private let permission = AudioRecordingPermission()
     private let tapQueue = DispatchQueue(label: "io.meetingnotes.audiotap", qos: .userInitiated)
     private let audioFileLock = NSLock()
     private var isTapActive = false
-    private var isRestartingSystemTap = false
     private var isAcceptingAudio = false
     private var micRetryCount = 0
     private var pendingMicRestart: DispatchWorkItem?
     private let maxMicRetries = 3
-    private var cancellables = Set<AnyCancellable>()
-    
     private var micAudioFile: AVAudioFile?
     private var systemAudioFile: AVAudioFile?
     private var micAudioURL: URL?
     private var systemAudioURL: URL?
     private var recordingStartedAt = Date()
+    private var systemDiagnostics = SystemCaptureDiagnostics()
 
     private override init() {
         super.init()
         observeAudioEngine()
-        audioProcessController.activate()
-        NSWorkspace.shared.publisher(for: \.runningApplications)
-            .debounce(for: .seconds(1), scheduler: RunLoop.main)
-            .sink { [weak self] _ in
-                guard let self, self.isTapActive else { return }
-                Task { await self.restartSystemAudioTapIfNeeded() }
-            }
-            .store(in: &cancellables)
     }
 
     deinit {
         NotificationCenter.default.removeObserver(self)
     }
 
-    func startRecording() {
+    func startRecording(for meetingID: UUID) {
         errorMessage = nil
+        lastRecoveryAudioFolderName = nil
         cancelCapture(removeFiles: true)
         sessionID = UUID()
+        self.meetingID = meetingID
         recordingStartedAt = Date()
+        systemDiagnostics = SystemCaptureDiagnostics()
         do {
             try prepareAudioFiles()
             startMicrophoneTap()
@@ -69,6 +100,7 @@ final class AudioManager: NSObject, ObservableObject {
     }
 
     func stopRecordingAndTranscribe() async -> [TranscriptChunk] {
+        let completedMeetingID = meetingID
         let completedSessionID = sessionID
         let captureStartedAt = recordingStartedAt
         let files = stopCaptureAndCloseFiles()
@@ -77,13 +109,146 @@ 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)
-        async let systemResult = transcribe(files[1], model: model)
+        async let micResult = transcribe(transcriptionFiles[0], model: model, diarization: false)
+        async let systemResult = transcribe(transcriptionFiles[1], model: model, diarization: true)
         let (micTranscription, systemTranscription) = await (micResult, systemResult)
         let results = [micTranscription, systemTranscription]
 
-        var updated = transcriptChunks.filter(\.isFinal)
+        let (updated, failures) = buildTranscriptChunks(
+            from: results,
+            captureStartedAt: captureStartedAt,
+            existingChunks: transcriptChunks.filter(\.isFinal)
+        )
+        transcriptChunks = updated
+        if !failures.isEmpty {
+            let retentionDays = UserDefaultsManager.shared.audioRetentionDays
+            let retentionUnit = retentionDays == 1 ? "day" : "days"
+            let recoveryMessage = audioFolder == nil
+                ? " The audio remains in the app's temporary folder."
+                : " Audio was kept for \(retentionDays) \(retentionUnit). Use Show Audio Folder in the Meetingnotes menu to find it."
+            errorMessage = "Transcription failed for " + failures.joined(separator: "; ") + recoveryMessage
+        } else if audioFolder == nil, !completedFiles.isEmpty {
+            errorMessage = "The transcript completed, but Meetingnotes could not move the audio into its retention folder."
+        }
+        return updated
+    }
+
+    func transcribeRecoveryAudio(in folder: URL, captureStartedAt: Date) async throws -> [TranscriptChunk] {
+        let recoveryFiles = LocalStorageManager.shared.recoveryAudioFiles(in: folder)
+        guard !recoveryFiles.isEmpty else {
+            throw RecoveryTranscriptionError.noAudioFiles
+        }
+
+        isProcessing = true
+        defer { isProcessing = false }
+        let model = UserDefaultsManager.shared.transcriptionModel
+        let sessions = Dictionary(grouping: recoveryFiles) { recoverySessionKey(for: $0.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 result = buildTranscriptChunks(
+                from: [micTranscription, systemTranscription],
+                captureStartedAt: session.startedAt,
+                existingChunks: chunks
+            )
+            chunks = result.0
+            failures.append(contentsOf: result.1)
+        }
+
+        if !failures.isEmpty {
+            throw RecoveryTranscriptionError.requestFailed(failures.joined(separator: "; "))
+        }
+        guard !chunks.isEmpty else {
+            throw RecoveryTranscriptionError.noSpeech
+        }
+        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
+    }
+
+    private func transcribe(
+        _ fileURL: URL?,
+        model: String,
+        diarization: Bool
+    ) async -> Result<CoderAPIClient.Transcription, Error>? {
+        guard let fileURL else { return nil }
+        do {
+            return .success(try await CoderAPIClient.shared.transcribe(
+                fileURL: fileURL,
+                model: model,
+                diarization: diarization,
+                maxSpeakerCount: 4
+            ))
+        } catch {
+            return .failure(error)
+        }
+    }
+
+    private func buildTranscriptChunks(
+        from results: [Result<CoderAPIClient.Transcription, Error>?],
+        captureStartedAt: Date,
+        existingChunks: [TranscriptChunk]
+    ) -> ([TranscriptChunk], [String]) {
+        var updated = existingChunks
         var failures: [String] = []
         for (source, result) in zip([AudioSource.mic, .system], results) {
             guard let result else { continue }
@@ -101,6 +266,7 @@ final class AudioManager: NSObject, ObservableObject {
                         updated.append(TranscriptChunk(
                             timestamp: captureStartedAt.addingTimeInterval(max(0, segment.start)),
                             source: source,
+                            speaker: source == .system ? segment.speaker : nil,
                             text: text,
                             isFinal: true
                         ))
@@ -114,44 +280,23 @@ final class AudioManager: NSObject, ObservableObject {
             if $0.timestamp != $1.timestamp { return $0.timestamp < $1.timestamp }
             return $0.source.rawValue < $1.source.rawValue
         }
-        transcriptChunks = updated
-        let completedFiles = files.compactMap { $0 }
-        if failures.isEmpty {
-            removeAudioFiles(completedFiles)
-        } else {
-            let recoveryFolder = preserveAudioFiles(completedFiles, sessionID: completedSessionID)
-            let recoveryMessage = recoveryFolder == nil
-                ? " The audio remains in the app's temporary folder."
-                : " Audio was saved in Documents/Meetingnotes-Recovery/\(completedSessionID.uuidString)."
-            errorMessage = "Transcription failed for " + failures.joined(separator: "; ") + recoveryMessage
-        }
-        return updated
-    }
-    
-    func cancelRecording() {
-        cancelCapture(removeFiles: true)
-    }
-        
-    private func transcribe(_ fileURL: URL?, model: String) async -> Result<CoderAPIClient.Transcription, Error>? {
-        guard let fileURL else { return nil }
-        do {
-            return .success(try await CoderAPIClient.shared.transcribe(fileURL: fileURL, model: model))
-        } catch {
-            return .failure(error)
-        }
+        return (updated, failures)
     }
     
     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 systemURL = base.appendingPathComponent("meetingnotes-\(id)-system.m4a")
+        let micURL = base.appendingPathComponent("meetingnotes-\(id)-mic.wav")
+        let systemURL = base.appendingPathComponent("meetingnotes-\(id)-system.wav")
         let newMicAudioFile = try AVAudioFile(
             forWriting: micURL,
             settings: settings,
@@ -239,8 +384,7 @@ final class AudioManager: NSObject, ObservableObject {
             return
         }
         
-        let processIDs = audioProcessController.processes.map(\.objectID)
-        let newTap = ProcessTap(target: .systemAudio(processObjectIDs: processIDs))
+        let newTap = ProcessTap(target: .systemAudio)
         newTap.activate()
         if let tapError = newTap.errorMessage {
             errorMessage = "Failed to activate system audio capture: \(tapError)"
@@ -264,21 +408,8 @@ final class AudioManager: NSObject, ObservableObject {
         }
     }
     
-    private func restartSystemAudioTapIfNeeded() async {
-        let next = Set(audioProcessController.processes.map(\.objectID))
-        let current: Set<AudioObjectID>
-        if case .systemAudio(let processIDs) = processTap?.target {
-            current = Set(processIDs)
-        } else {
-            current = []
-        }
-        if next != current { await restartSystemAudioTap() }
-    }
-
     private func restartSystemAudioTap() async {
         guard isRecording else { return }
-        isRestartingSystemTap = true
-        defer { isRestartingSystemTap = false }
         if isTapActive {
             processTap?.invalidate()
             processTap = nil
@@ -301,43 +432,162 @@ 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?
+        try tap.run(on: tapQueue) { [weak self] inNow, inputData, inInputTime, _, _ in
             guard let self else { return }
+            if inputFormat == nil {
+                inputFormat = self.inputFormat(
+                    for: inputData,
+                    advertisedFormat: advertisedInputFormat
+                )
+                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 }
+            // The tap queue is serial. Reusing the converter preserves its
+            // resampler state instead of discarding audio at every callback.
             self.processAudioBuffer(
-                { AVAudioPCMBuffer(pcmFormat: inputFormat, bufferListNoCopy: inputData, deallocator: nil) },
+                { 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.isRestartingSystemTap, self.isRecording else { return }
+            guard let self, self.isRecording else { return }
             Task { await self.restartSystemAudioTap() }
         }
     }
 
+    private func inputFormat(
+        for inputData: UnsafePointer<AudioBufferList>,
+        advertisedFormat: AVAudioFormat
+    ) -> 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: advertisedFormat.sampleRate,
+            channels: AVAudioChannelCount(channelCount),
+            interleaved: isInterleaved
+        )
+    }
+
+    private func copyAudioBuffer(
+        from inputData: UnsafePointer<AudioBufferList>,
+        format: AVAudioFormat
+    ) -> AVAudioPCMBuffer? {
+        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
+        )
+        guard sourceBuffers.count == destinationBuffers.count else { return nil }
+
+        for index in 0..<sourceBuffers.count {
+            let source = sourceBuffers[index]
+            let destination = destinationBuffers[index]
+            let byteCount = Int(source.mDataByteSize)
+            guard byteCount <= Int(destination.mDataByteSize),
+                  let sourceData = source.mData,
+                  let destinationData = destination.mData else { return nil }
+            memcpy(destinationData, sourceData, byteCount)
+            destinationBuffers[index].mDataByteSize = source.mDataByteSize
+        }
+        return ownedBuffer
+    }
+    
     private func processAudioBuffer(
         _ inputBufferProvider: () -> AVAudioPCMBuffer?,
         converter: AVAudioConverter,
         targetFormat: AVAudioFormat,
-        source: AudioSource
+        source: AudioSource,
+        callbackTimestamp: AudioTimeStamp? = nil,
+        ioTimestamp: AudioTimeStamp? = nil
     ) {
-        // Keep callback-owned buffers alive until conversion finishes. Teardown
-        // takes this same lock before invalidating the Core Audio process tap.
+        // 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,
-              let inputBuffer = inputBufferProvider(),
-              inputBuffer.frameLength > 0 else { return }
+        guard isAcceptingAudio else { return }
+        if source == .system {
+            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
@@ -349,7 +599,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 {
@@ -357,6 +610,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
@@ -427,29 +681,212 @@ final class AudioManager: NSObject, ObservableObject {
         for url in urls { try? FileManager.default.removeItem(at: url) }
     }
 
-    private func preserveAudioFiles(_ urls: [URL], sessionID: UUID) -> URL? {
-        guard !urls.isEmpty,
-              let documents = FileManager.default.urls(for: .documentDirectory, in: .userDomainMask).first else {
-            return nil
+    private func preserveAudioFiles(_ urls: [URL], meetingID: UUID) -> URL? {
+        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
         }
-        let folder = documents
-            .appendingPathComponent("Meetingnotes-Recovery", isDirectory: true)
-            .appendingPathComponent(sessionID.uuidString, isDirectory: true)
+    }
+
+    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 FileManager.default.createDirectory(at: folder, withIntermediateDirectories: true)
+            try halveWAVSampleRate(at: systemURL)
+            return true
         } catch {
-            return nil
+            return false
         }
-        var preservedCount = 0
-        for url in urls {
-            do {
-                try FileManager.default.moveItem(at: url, to: folder.appendingPathComponent(url.lastPathComponent))
-                preservedCount += 1
-            } catch {
-                continue
+    }
+
+    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)
         }
-        return preservedCount > 0 ? folder : nil
+
+        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)",
+            "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() {

meetingnotes/Managers/LocalStorageManager.swift

@@ -2,6 +2,7 @@
 // Handles local storage of meetings and app data
 
 import Foundation
+import AppKit
 
 /// Manages local file storage for meetings and app data
 class LocalStorageManager {
@@ -15,6 +16,7 @@ class LocalStorageManager {
     private let documentsDirectory: URL
     private let meetingsDirectory: URL
     private let templatesDirectory: URL
+    private let recoveryDirectory: URL
     
     private init() {
         // Get the app's documents directory
@@ -27,11 +29,17 @@ class LocalStorageManager {
         // Create templates subdirectory
         templatesDirectory = documentsDirectory.appendingPathComponent("Templates")
 
+        recoveryDirectory = documentsDirectory.appendingPathComponent("Meetingnotes Audio")
+        
         // Ensure directories exist
         try? FileManager.default.createDirectory(at: meetingsDirectory,
                                                withIntermediateDirectories: true)
         try? FileManager.default.createDirectory(at: templatesDirectory,
                                                withIntermediateDirectories: true)
+        try? FileManager.default.createDirectory(at: recoveryDirectory,
+                                               withIntermediateDirectories: true)
+        migrateLegacyRecoveryAudio()
+        purgeExpiredAudioFolders()
     }
     
     // MARK: - Meeting Management
@@ -144,6 +152,233 @@ 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
+                }
+            }
+
+            for audioFile in recoveryAudioFiles(in: continuationFolder) {
+                let destination = previousFolder.appendingPathComponent(audioFile.url.lastPathComponent)
+                if FileManager.default.fileExists(atPath: destination.path) {
+                    guard FileManager.default.contentsEqual(
+                        atPath: audioFile.url.path,
+                        andPath: destination.path
+                    ) else {
+                        rollbackMergedAudio(copiedAudioURLs, removeFolder: createdPreviousFolder ? previousFolder : nil)
+                        return nil
+                    }
+                    continue
+                }
+
+                do {
+                    try FileManager.default.copyItem(at: audioFile.url, 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
+        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? {
+        guard !urls.isEmpty else { return nil }
+        purgeExpiredAudioFolders()
+
+        let folder = recoveryDirectory.appendingPathComponent(meetingID.uuidString, isDirectory: true)
+        do {
+            try FileManager.default.createDirectory(at: folder, withIntermediateDirectories: true)
+        } catch {
+            return nil
+        }
+
+        var preservedCount = 0
+        for url in urls {
+            let destination = folder.appendingPathComponent(url.lastPathComponent)
+            do {
+                if FileManager.default.fileExists(atPath: destination.path) {
+                    try FileManager.default.removeItem(at: destination)
+                }
+                try FileManager.default.moveItem(at: url, to: destination)
+                preservedCount += 1
+            } catch {
+                continue
+            }
+        }
+        return preservedCount > 0 ? folder : nil
+    }
+
+    func purgeExpiredAudioFolders(now: Date = Date()) {
+        guard let folders = try? FileManager.default.contentsOfDirectory(
+            at: recoveryDirectory,
+            includingPropertiesForKeys: [.isDirectoryKey],
+            options: [.skipsHiddenFiles]
+        ) else { return }
+
+        let retentionInterval = TimeInterval(UserDefaultsManager.shared.audioRetentionDays) * 24 * 60 * 60
+        let expirationDate = now.addingTimeInterval(-retentionInterval)
+        for folder in folders {
+            guard (try? folder.resourceValues(forKeys: [.isDirectoryKey]).isDirectory) == true else { continue }
+            let audioFiles = recoveryAudioFiles(in: folder)
+            let newestDate = audioFiles.compactMap { file -> Date? in
+                let values = try? file.url.resourceValues(forKeys: [.contentModificationDateKey, .creationDateKey])
+                return values?.contentModificationDate ?? values?.creationDate
+            }.max()
+
+            guard let newestDate else {
+                try? FileManager.default.removeItem(at: folder)
+                continue
+            }
+            if newestDate < expirationDate {
+                try? FileManager.default.removeItem(at: folder)
+            }
+        }
+    }
+
+    @MainActor
+    func showAudioFolderInFinder(_ folder: URL? = nil) {
+        let target = folder ?? recoveryDirectory
+        try? FileManager.default.createDirectory(at: target, withIntermediateDirectories: true)
+        NSWorkspace.shared.open(target)
+    }
+
+    func recoveryAudioFolder(named name: String) -> URL? {
+        let trimmedName = name.trimmingCharacters(in: .whitespacesAndNewlines)
+        guard !trimmedName.isEmpty,
+              URL(fileURLWithPath: trimmedName).lastPathComponent == trimmedName else {
+            return nil
+        }
+        let folder = recoveryDirectory.appendingPathComponent(trimmedName, isDirectory: true)
+        var isDirectory: ObjCBool = false
+        guard FileManager.default.fileExists(atPath: folder.path, isDirectory: &isDirectory),
+              isDirectory.boolValue,
+              !recoveryAudioFiles(in: folder).isEmpty else {
+            return nil
+        }
+        return folder
+    }
+
+    func recoveryAudioFiles(in folder: URL) -> [(url: URL, source: AudioSource)] {
+        guard let files = try? FileManager.default.contentsOfDirectory(
+            at: folder,
+            includingPropertiesForKeys: [.creationDateKey, .contentModificationDateKey, .isRegularFileKey],
+            options: [.skipsHiddenFiles]
+        ) else {
+            return []
+        }
+
+        return files.compactMap { url in
+            let name = url.lastPathComponent.lowercased()
+            guard ["m4a", "mp3", "wav", "flac", "webm", "mp4"].contains(url.pathExtension.lowercased()) else {
+                return nil
+            }
+            if name.contains("-mic.") {
+                return (url, .mic)
+            }
+            if name.contains("-system.") {
+                return (url, .system)
+            }
+            return nil
+        }
+    }
+
+    func findRecoveryAudioFolder(for meeting: Meeting) -> URL? {
+        let canonicalName = meeting.id.uuidString
+        guard meeting.recoveryAudioFolderName == nil
+                || meeting.recoveryAudioFolderName?.caseInsensitiveCompare(canonicalName) == .orderedSame else {
+            return nil
+        }
+        return recoveryAudioFolder(named: canonicalName)
+    }
+
+    func deleteRecoveryAudioFolder(_ folder: URL) {
+        guard folder.deletingLastPathComponent().standardizedFileURL == recoveryDirectory.standardizedFileURL else {
+            return
+        }
+        try? FileManager.default.removeItem(at: folder)
+    }
+
+    private func migrateLegacyRecoveryAudio() {
+        let legacyDirectory = documentsDirectory.appendingPathComponent("Meetingnotes-Recovery", isDirectory: true)
+        guard let folders = try? FileManager.default.contentsOfDirectory(
+            at: legacyDirectory,
+            includingPropertiesForKeys: [.isDirectoryKey],
+            options: [.skipsHiddenFiles]
+        ) else { return }
+
+        for folder in folders {
+            let destination = recoveryDirectory.appendingPathComponent(folder.lastPathComponent, isDirectory: true)
+            guard !FileManager.default.fileExists(atPath: destination.path) else { continue }
+            try? FileManager.default.moveItem(at: folder, to: destination)
+        }
+        try? FileManager.default.removeItem(at: legacyDirectory)
+    }
+
     /// Imports meeting JSON files from a folder selected by the user.
     func importMeetings(from directory: URL) throws -> MeetingImportResult {
         let didStartAccess = directory.startAccessingSecurityScopedResource()

meetingnotes/Managers/RecordingSessionManager.swift

@@ -81,7 +81,7 @@ class RecordingSessionManager: ObservableObject {
         
         activeMeetingId = meetingId
         recordingStartedAt = Date()
-        audioManager.startRecording()
+        audioManager.startRecording(for: meetingId)
     }
     
     func stopRecording() async -> [TranscriptChunk] {
@@ -96,7 +96,11 @@ class RecordingSessionManager: ObservableObject {
         let chunks = await audioManager.stopRecordingAndTranscribe()
         activeRecordingTranscriptChunks = chunks
         activeRecordingTranscriptChunksUpdated = chunks
-        updateActiveMeetingTranscript(meetingId: meetingId, chunks: chunks)
+        updateActiveMeetingTranscript(
+            meetingId: meetingId,
+            chunks: chunks,
+            transcriptionError: audioManager.errorMessage
+        )
         activeMeetingId = nil
         activeRecordingTranscriptChunks = []
         return chunks
@@ -113,13 +117,25 @@ class RecordingSessionManager: ObservableObject {
         return isRecording && activeMeetingId == meetingId
     }
 
-    private func updateActiveMeetingTranscript(meetingId: UUID, chunks: [TranscriptChunk]) {
+    var lastRecoveryAudioFolderName: String? {
+        audioManager.lastRecoveryAudioFolderName
+    }
+    
+    private func updateActiveMeetingTranscript(
+        meetingId: UUID,
+        chunks: [TranscriptChunk],
+        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 = lastRecoveryAudioFolderName {
+                meetings[index].recoveryAudioFolderName = recoveryAudioFolderName
+            }
+            meetings[index].transcriptionError = transcriptionError
             
             // Save the updated meeting
             let success = LocalStorageManager.shared.saveMeeting(meetings[index])

meetingnotes/Managers/UserDefaultsManager.swift

@@ -23,6 +23,7 @@ class UserDefaultsManager {
         static let transcriptionModel = "transcriptionModel"
         static let muteDeckAPIEnabled = "muteDeckAPIEnabled"
         static let muteDeckAPIPort = "muteDeckAPIPort"
+        static let audioRetentionDays = "audioRetentionDays"
     }
     
     // MARK: - User Blurb
@@ -78,7 +79,7 @@ class UserDefaultsManager {
     }
 
     var transcriptionModel: String {
-        get { userDefaults.string(forKey: Keys.transcriptionModel) ?? "groq/whisper-large-v3-turbo" }
+        get { userDefaults.string(forKey: Keys.transcriptionModel) ?? "local-parakeet/parakeet-tdt-0.6b-v3" }
         set { userDefaults.set(newValue, forKey: Keys.transcriptionModel) }
     }
 
@@ -94,4 +95,12 @@ class UserDefaultsManager {
         }
         set { userDefaults.set(newValue, forKey: Keys.muteDeckAPIPort) }
     }
+
+    var audioRetentionDays: Int {
+        get {
+            guard userDefaults.object(forKey: Keys.audioRetentionDays) != nil else { return 3 }
+            return min(max(userDefaults.integer(forKey: Keys.audioRetentionDays), 1), 365)
+        }
+        set { userDefaults.set(min(max(newValue, 1), 365), forKey: Keys.audioRetentionDays) }
+    }
 }

meetingnotes/MeetingnotesApp.swift

@@ -6,12 +6,14 @@
 //
 
 import SwiftUI
+import AppKit
 import Sparkle
 import PostHog
 
 @main
 struct MeetingnotesApp: App {
     private let updaterController: SPUStandardUpdaterController
+    @StateObject private var recordingSessionManager = RecordingSessionManager.shared
 
     init() {
         updaterController = SPUStandardUpdaterController(updaterDelegate: nil, userDriverDelegate: nil)
@@ -34,17 +36,145 @@ struct MeetingnotesApp: App {
     }
 
     var body: some Scene {
-        WindowGroup {
+        WindowGroup("Meetingnotes", id: "main") {
             ContentView()
                 .frame(minWidth: 700, minHeight: 400)
+                .background(MainWindowConfigurator())
         }
         .windowResizability(.automatic)
         .defaultSize(width: 1000, height: 600)
         .commands {
             CommandGroup(after: .appInfo) {
                 CheckForUpdatesView(updater: updaterController.updater)
+                Divider()
+                Button("Show Audio Folder") {
+                    LocalStorageManager.shared.showAudioFolderInFinder()
+                }
             }
         }
+
+        MenuBarExtra {
+            MeetingnotesMenu(
+                recordingSessionManager: recordingSessionManager,
+                updater: updaterController.updater
+            )
+        } label: {
+            Image(systemName: recordingSessionManager.isRecording ? "record.circle.fill" : "waveform")
+                .accessibilityLabel(recordingSessionManager.isRecording ? "Meetingnotes recording" : "Meetingnotes")
+        }
+    }
+}
+
+private struct MeetingnotesMenu: View {
+    @ObservedObject var recordingSessionManager: RecordingSessionManager
+    let updater: SPUUpdater
+    @Environment(\.openWindow) private var openWindow
+
+    var body: some View {
+        if recordingSessionManager.isRecording {
+            Label("Recording", systemImage: "record.circle.fill")
+        } else if recordingSessionManager.isProcessing {
+            Label("Processing audio", systemImage: "hourglass")
+        }
+
+        Button {
+            MainWindowController.shared.show(using: openWindow)
+        } label: {
+            Label("Open Meetingnotes", systemImage: "macwindow")
+        }
+
+        Button {
+            LocalStorageManager.shared.showAudioFolderInFinder()
+        } label: {
+            Label("Show Audio Folder", systemImage: "folder")
+        }
+
+        Divider()
+
+        Button {
+            updater.checkForUpdates()
+        } label: {
+            Label("Check for Updates...", systemImage: "arrow.triangle.2.circlepath")
+        }
+        .keyboardShortcut("u")
+
+        Button {
+            NSApplication.shared.terminate(nil)
+        } label: {
+            Label("Quit Meetingnotes", systemImage: "power")
+        }
+        .keyboardShortcut("q")
+    }
+}
+
+@MainActor
+private final class MainWindowController: NSObject {
+    static let shared = MainWindowController()
+
+    private weak var window: NSWindow?
+
+    func configure(_ window: NSWindow) {
+        if self.window !== window {
+            if let previousWindow = self.window {
+                NotificationCenter.default.removeObserver(
+                    self,
+                    name: NSWindow.willMiniaturizeNotification,
+                    object: previousWindow
+                )
+            }
+            self.window = window
+            NotificationCenter.default.addObserver(
+                self,
+                selector: #selector(windowWillMiniaturize(_:)),
+                name: NSWindow.willMiniaturizeNotification,
+                object: window
+            )
+        }
+
+        if let minimizeButton = window.standardWindowButton(.miniaturizeButton) {
+            minimizeButton.target = self
+            minimizeButton.action = #selector(hideWindow(_:))
+        }
+    }
+
+    func show(using openWindow: OpenWindowAction) {
+        if let window {
+            window.makeKeyAndOrderFront(nil)
+        } else {
+            openWindow(id: "main")
+        }
+        NSApplication.shared.activate(ignoringOtherApps: true)
+    }
+
+    @objc private func hideWindow(_ sender: NSButton) {
+        sender.window?.orderOut(nil)
+    }
+
+    @objc private func windowWillMiniaturize(_ notification: Notification) {
+        guard let window = notification.object as? NSWindow else { return }
+        DispatchQueue.main.async {
+            window.deminiaturize(nil)
+            window.orderOut(nil)
+        }
+    }
+}
+
+private struct MainWindowConfigurator: NSViewRepresentable {
+    func makeNSView(context: Context) -> NSView {
+        let view = NSView()
+        configureWindow(for: view)
+        return view
+    }
+
+    func updateNSView(_ nsView: NSView, context: Context) {
+        configureWindow(for: nsView)
+    }
+
+    private func configureWindow(for view: NSView) {
+        DispatchQueue.main.async {
+            guard let window = view.window else { return }
+            MainWindowController.shared.configure(window)
+        }
     }
 }
 

meetingnotes/Models/Meeting.swift

@@ -48,30 +48,46 @@ struct TranscriptChunk: Codable, Identifiable, Hashable {
     let id: UUID
     let timestamp: Date
     let source: AudioSource
+    let speaker: Int?
     let text: String
     let isFinal: Bool
     
-    init(id: UUID = UUID(), timestamp: Date = Date(), source: AudioSource, text: String, isFinal: Bool = false) {
+    init(id: UUID = UUID(), timestamp: Date = Date(), source: AudioSource, speaker: Int? = nil, text: String, isFinal: Bool = false) {
         self.id = id
         self.timestamp = timestamp
         self.source = source
+        self.speaker = speaker
         self.text = text
         self.isFinal = isFinal
     }
+
+    var displayName: String {
+        if source == .mic { return "Me" }
+        if let speaker { return "Speaker \(speaker)" }
+        return source.displayName
+    }
 }
 
 struct CollapsedTranscriptChunk: Identifiable {
     let id: UUID
     let timestamp: Date
     let source: AudioSource
+    let speaker: Int?
     let combinedText: String
     
-    init(id: UUID = UUID(), timestamp: Date, source: AudioSource, combinedText: String) {
+    init(id: UUID = UUID(), timestamp: Date, source: AudioSource, speaker: Int? = nil, combinedText: String) {
         self.id = id
         self.timestamp = timestamp
         self.source = source
+        self.speaker = speaker
         self.combinedText = combinedText
     }
+
+    var displayName: String {
+        if source == .mic { return "Me" }
+        if let speaker { return "Speaker \(speaker)" }
+        return source.displayName
+    }
 }
 
 struct Meeting: Codable, Identifiable, Hashable {
@@ -82,6 +98,8 @@ struct Meeting: Codable, Identifiable, Hashable {
     var userNotes: String
     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
@@ -95,6 +113,8 @@ struct Meeting: Codable, Identifiable, Hashable {
          userNotes: String = "",
          generatedNotes: String = "",
          templateId: UUID? = nil,
+         recoveryAudioFolderName: String? = nil,
+         transcriptionError: String? = nil,
          dataVersion: Int = Meeting.currentDataVersion) {
         self.id = id
         self.date = date
@@ -103,6 +123,8 @@ struct Meeting: Codable, Identifiable, Hashable {
         self.userNotes = userNotes
         self.generatedNotes = generatedNotes
         self.templateId = templateId
+        self.recoveryAudioFolderName = recoveryAudioFolderName
+        self.transcriptionError = transcriptionError
         self.dataVersion = dataVersion
     }
     
@@ -112,7 +134,7 @@ struct Meeting: Codable, Identifiable, Hashable {
     var transcript: String {
         return transcriptChunks
             .filter { $0.isFinal }
-            .map { "[\($0.source.rawValue)] \($0.text)" }
+            .map { "[\($0.displayName)] \($0.text)" }
             .joined(separator: " ")
     }
     
@@ -121,7 +143,7 @@ struct Meeting: Codable, Identifiable, Hashable {
         let finalChunks = transcriptChunks.filter { $0.isFinal }
 
         return finalChunks.map { chunk in
-            "[\(TranscriptTimestampFormatter.string(from: chunk.timestamp))] \(chunk.source.copyPrefix): \(chunk.text)"
+            "[\(TranscriptTimestampFormatter.string(from: chunk.timestamp))] \(chunk.displayName): \(chunk.text)"
         }.joined(separator: "\n")
     }
     
@@ -132,6 +154,7 @@ struct Meeting: Codable, Identifiable, Hashable {
                 id: chunk.id,
                 timestamp: chunk.timestamp,
                 source: chunk.source,
+                speaker: chunk.speaker,
                 combinedText: chunk.text
             )
         }

meetingnotes/Models/Settings.swift

@@ -54,6 +54,11 @@ struct Settings: Codable {
         set { UserDefaultsManager.shared.muteDeckAPIPort = newValue }
     }
 
+    var audioRetentionDays: Int {
+        get { UserDefaultsManager.shared.audioRetentionDays }
+        set { UserDefaultsManager.shared.audioRetentionDays = newValue }
+    }
+
     // System prompt default loading
     static func defaultSystemPrompt() -> String {
         guard let path = Bundle.main.path(forResource: "DefaultSystemPrompt", ofType: "txt"),

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

@@ -5,7 +5,7 @@ import AVFoundation
 
 enum TapTarget {
     case singleProcess(AudioProcess)
-    case systemAudio(processObjectIDs: [AudioObjectID])
+    case systemAudio
 
     var displayName: String {
         switch self {
@@ -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
@@ -137,12 +141,12 @@ final class ProcessTap {
         case .singleProcess(let process):
             tapDescription = CATapDescription(stereoMixdownOfProcesses: [process.objectID])
             logger.debug("Configuring tap for single process objectID: \(process.objectID)")
-        case .systemAudio(let processObjectIDs):
-            if processObjectIDs.isEmpty {
-                logger.warning("System audio tap configured with an empty list of processObjectIDs. This might not capture any audio or behave unexpectedly.")
-            }
-            tapDescription = CATapDescription(monoMixdownOfProcesses: processObjectIDs)
-            logger.debug("Configuring tap for system audio output using \(processObjectIDs.count) explicit processes.")
+        case .systemAudio:
+            // The transcription file is mono, so ask Core Audio for a mono
+            // mixdown at the source. This avoids interpreting a stereo HAL
+            // buffer as half as many frames before the 16 kHz conversion.
+            tapDescription = CATapDescription(monoGlobalTapButExcludeProcesses: [])
+            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()
-            logger.debug("Successfully read tap stream description: \(String(describing: self.tapStreamDescription))")
+            let advertisedDescription = try tapID.readAudioTapStreamBasicDescription()
+            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

@@ -1,3 +1,4 @@
+import AVFoundation
 import Foundation
 
 struct CoderModel: Codable, Identifiable, Hashable {
@@ -20,6 +21,7 @@ struct CoderModel: Codable, Identifiable, Hashable {
 
     var supportsChat: Bool { capabilities.isEmpty || capabilities.contains("chat") }
     var supportsTranscription: Bool { capabilities.contains("audio_transcription") }
+    var supportsSpeakerDiarization: Bool { capabilities.contains("speaker_diarization") }
 }
 
 enum CoderAPIError: LocalizedError {
@@ -53,6 +55,7 @@ final class CoderAPIClient {
             let start: TimeInterval
             let end: TimeInterval
             let text: String
+            let speaker: Int?
         }
 
         let text: String
@@ -69,10 +72,25 @@ final class CoderAPIClient {
     }
 
     private struct TranscriptionResponse: Decodable {
+        struct Word: Decodable {
+            let word: String
+            let start: TimeInterval
+            let end: TimeInterval
+            let speaker: Int?
+        }
+
         let text: String
         let segments: [Transcription.Segment]?
+        let words: [Word]?
     }
 
+    private struct AudioChunk {
+        let url: URL
+        let offset: TimeInterval
+        let isTemporary: Bool
+    }
+
+    private let transcriptionChunkDuration: TimeInterval = 3 * 60
     private let transcriptionSession: URLSession
 
     private init() {
@@ -97,7 +115,11 @@ final class CoderAPIClient {
         )
     }
 
-    func streamChat(systemPrompt: String, model: String) -> AsyncThrowingStream<String, Error> {
+    func streamChat(
+        systemPrompt: String,
+        userPrompt: String = "Create the meeting notes now.",
+        model: String
+    ) -> AsyncThrowingStream<String, Error> {
         AsyncThrowingStream { continuation in
             Task {
                 do {
@@ -113,7 +135,7 @@ final class CoderAPIClient {
                         "model": selectedModel,
                         "messages": [
                             ["role": "system", "content": systemPrompt],
-                            ["role": "user", "content": "Create the meeting notes now."]
+                            ["role": "user", "content": userPrompt]
                         ],
                         "stream": true
                     ])
@@ -147,15 +169,85 @@ final class CoderAPIClient {
         }
     }
 
-    func transcribe(fileURL: URL, model: String, language: String = "en") async throws -> Transcription {
+    func transcribe(
+        fileURL: URL,
+        model: String,
+        language: String = "en",
+        diarization: Bool = false,
+        maxSpeakerCount: Int = 4
+    ) async throws -> Transcription {
         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)
+        defer {
+            for chunk in chunks where chunk.isTemporary {
+                try? FileManager.default.removeItem(at: chunk.url)
+            }
+        }
+
+        var textParts: [String] = []
+        var segments: [Transcription.Segment] = []
+        var lastNormalizedText = ""
+        var consecutiveDuplicateCount = 0
+
+        for chunk in chunks {
+            let transcription = try await transcribeChunk(
+                chunk.url,
+                model: selectedModel,
+                language: language,
+                apiKey: apiKey,
+                diarization: diarization,
+                maxSpeakerCount: maxSpeakerCount
+            )
+            if transcription.segments.isEmpty {
+                let text = transcription.text.trimmingCharacters(in: .whitespacesAndNewlines)
+                if !text.isEmpty {
+                    textParts.append(text)
+                    segments.append(.init(start: chunk.offset, end: chunk.offset, text: text, speaker: nil))
+                }
+                continue
+            }
+
+            for segment in transcription.segments {
+                let text = segment.text.trimmingCharacters(in: .whitespacesAndNewlines)
+                guard !text.isEmpty else { continue }
+                let normalized = text.lowercased()
+                if normalized == lastNormalizedText {
+                    consecutiveDuplicateCount += 1
+                } else {
+                    lastNormalizedText = normalized
+                    consecutiveDuplicateCount = 1
+                }
+                guard consecutiveDuplicateCount <= 2 else { continue }
+                textParts.append(text)
+                segments.append(.init(
+                    start: segment.start + chunk.offset,
+                    end: segment.end + chunk.offset,
+                    text: text,
+                    speaker: segment.speaker
+                ))
+            }
+        }
+
+        return Transcription(text: textParts.joined(separator: "\n"), segments: segments)
+    }
+
+    private func transcribeChunk(
+        _ fileURL: URL,
+        model: String,
+        language: String,
+        apiKey: String,
+        diarization: Bool,
+        maxSpeakerCount: Int
+    ) async throws -> Transcription {
         let boundary = "Meetingnotes-\(UUID().uuidString)"
         let bodyURL = try makeMultipartBody(
             audioURL: fileURL,
-            model: selectedModel,
+            model: model,
             language: language,
+            diarization: diarization,
+            maxSpeakerCount: maxSpeakerCount,
             boundary: boundary
         )
         defer { try? FileManager.default.removeItem(at: bodyURL) }
@@ -171,7 +263,132 @@ final class CoderAPIClient {
         let (data, response) = try await transcriptionSession.upload(for: request, fromFile: bodyURL)
         try validate(response: response, data: data)
         let decoded = try JSONDecoder().decode(TranscriptionResponse.self, from: data)
-        return Transcription(text: decoded.text, segments: decoded.segments ?? [])
+        let segments = decoded.segments ?? segments(from: decoded.words ?? [])
+        return Transcription(text: decoded.text, segments: segments)
+    }
+
+    private func makeAudioChunks(from fileURL: URL, preserveSpeakerIdentity: Bool) throws -> [AudioChunk] {
+        let input = try AVAudioFile(forReading: fileURL)
+        let format = input.processingFormat
+        guard format.sampleRate > 0 else { throw CoderAPIError.invalidResponse }
+
+        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
+
+        do {
+            while frameOffset < input.length {
+                let frameCount = min(framesPerChunk, input.length - frameOffset)
+                let chunkURL = FileManager.default.temporaryDirectory
+                    .appendingPathComponent("meetingnotes-transcription-\(UUID().uuidString).wav")
+                try writeAudioChunk(
+                    from: input,
+                    frameCount: frameCount,
+                    format: format,
+                    to: chunkURL
+                )
+                chunks.append(AudioChunk(
+                    url: chunkURL,
+                    offset: Double(frameOffset) / format.sampleRate,
+                    isTemporary: true
+                ))
+                frameOffset += frameCount
+            }
+            return chunks
+        } catch {
+            for chunk in chunks {
+                try? FileManager.default.removeItem(at: chunk.url)
+            }
+            throw error
+        }
+    }
+
+    private func writeAudioChunk(
+        from input: AVAudioFile,
+        frameCount: AVAudioFramePosition,
+        format: AVAudioFormat,
+        to outputURL: URL
+    ) throws {
+        let settings: [String: Any] = [
+            AVFormatIDKey: kAudioFormatLinearPCM,
+            AVSampleRateKey: format.sampleRate,
+            AVNumberOfChannelsKey: format.channelCount,
+            AVLinearPCMBitDepthKey: 16,
+            AVLinearPCMIsFloatKey: false,
+            AVLinearPCMIsBigEndianKey: false,
+            AVLinearPCMIsNonInterleaved: false
+        ]
+        let output = try AVAudioFile(
+            forWriting: outputURL,
+            settings: settings,
+            commonFormat: format.commonFormat,
+            interleaved: format.isInterleaved
+        )
+        var remaining = frameCount
+        while remaining > 0 {
+            let requestedFrames = AVAudioFrameCount(min(remaining, 8_192))
+            guard let buffer = AVAudioPCMBuffer(pcmFormat: format, frameCapacity: requestedFrames) else {
+                throw CoderAPIError.invalidResponse
+            }
+            try input.read(into: buffer, frameCount: requestedFrames)
+            guard buffer.frameLength > 0 else { break }
+            try output.write(from: buffer)
+            remaining -= AVAudioFramePosition(buffer.frameLength)
+        }
+    }
+
+    private func segments(from words: [TranscriptionResponse.Word]) -> [Transcription.Segment] {
+        var result: [Transcription.Segment] = []
+        var currentWords: [String] = []
+        var currentStart: TimeInterval?
+        var currentEnd: TimeInterval = 0
+        var currentSpeaker: Int?
+
+        func flush() {
+            guard let start = currentStart, !currentWords.isEmpty else { return }
+            result.append(.init(
+                start: start,
+                end: currentEnd,
+                text: currentWords.joined(separator: " "),
+                speaker: currentSpeaker
+            ))
+            currentWords.removeAll(keepingCapacity: true)
+            currentStart = nil
+            currentEnd = 0
+            currentSpeaker = nil
+        }
+
+        for word in words {
+            let text = word.word.trimmingCharacters(in: .whitespacesAndNewlines)
+            guard !text.isEmpty else { continue }
+            let speakerChanged = currentStart != nil && word.speaker != currentSpeaker
+            let longPause = currentStart != nil && word.start - currentEnd > 1.5
+            if speakerChanged || longPause { flush() }
+
+            if currentStart == nil {
+                currentStart = word.start
+                currentSpeaker = word.speaker
+            }
+            currentWords.append(text)
+            currentEnd = word.end
+
+            let sentenceEnded = text.last.map { ".!?".contains($0) } ?? false
+            let duration = currentEnd - (currentStart ?? currentEnd)
+            if currentWords.count >= 40 || (sentenceEnded && (currentWords.count >= 12 || duration >= 8)) {
+                flush()
+            }
+        }
+        flush()
+        return result
     }
 
     private func endpoint(baseURL: String, path: String) throws -> URL {
@@ -203,7 +420,14 @@ final class CoderAPIClient {
         }
     }
 
-    private func makeMultipartBody(audioURL: URL, model: String, language: String, boundary: String) throws -> URL {
+    private func makeMultipartBody(
+        audioURL: URL,
+        model: String,
+        language: String,
+        diarization: Bool,
+        maxSpeakerCount: Int,
+        boundary: String
+    ) throws -> URL {
         let bodyURL = FileManager.default.temporaryDirectory.appendingPathComponent("meetingnotes-upload-\(UUID().uuidString).body")
         _ = FileManager.default.createFile(atPath: bodyURL.path, contents: nil)
         let output = try FileHandle(forWritingTo: bodyURL)
@@ -215,7 +439,11 @@ final class CoderAPIClient {
         try write("--\(boundary)\r\nContent-Disposition: form-data; name=\"model\"\r\n\r\n\(model)\r\n")
         try write("--\(boundary)\r\nContent-Disposition: form-data; name=\"language\"\r\n\r\n\(language)\r\n")
         try write("--\(boundary)\r\nContent-Disposition: form-data; name=\"response_format\"\r\n\r\nverbose_json\r\n")
-        try write("--\(boundary)\r\nContent-Disposition: form-data; name=\"file\"; filename=\"\(audioURL.lastPathComponent)\"\r\nContent-Type: audio/mp4\r\n\r\n")
+        if diarization {
+            try write("--\(boundary)\r\nContent-Disposition: form-data; name=\"diarization\"\r\n\r\ntrue\r\n")
+            try write("--\(boundary)\r\nContent-Disposition: form-data; name=\"max_speaker_count\"\r\n\r\n\(maxSpeakerCount)\r\n")
+        }
+        try write("--\(boundary)\r\nContent-Disposition: form-data; name=\"file\"; filename=\"\(audioURL.lastPathComponent)\"\r\nContent-Type: audio/wav\r\n\r\n")
         let input = try FileHandle(forReadingFrom: audioURL)
         defer { try? input.close() }
         while let chunk = try input.read(upToCount: 1 << 20), !chunk.isEmpty {

meetingnotes/Services/LocalAPIServer.swift

@@ -200,7 +200,9 @@ 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() {}
 
@@ -237,6 +239,12 @@ private final class LocalRecordingController {
     }
 
     func startRecording() throws -> [String: Any] {
+        if let pendingStopTask {
+            pendingStopTask.cancel()
+            self.pendingStopTask = nil
+            isStopping = false
+            return statusPayload()
+        }
         if isStopping || recordingManager.isProcessing {
             throw LocalRecordingError.processing
         }
@@ -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,6 +293,7 @@ private final class LocalRecordingController {
     }
 
     private func finishRecording() async {
+        pendingStopTask = nil
         let meetingID = recordingManager.activeMeetingId
         let chunks = await recordingManager.stopRecording()
         guard let meetingID,
@@ -286,6 +303,7 @@ private final class LocalRecordingController {
         }
 
         meeting.transcriptChunks = chunks
+        meeting.recoveryAudioFolderName = recordingManager.lastRecoveryAudioFolderName
         let templates = LocalStorageManager.shared.loadTemplates()
         if meeting.templateId == nil {
             meeting.templateId = LocalStorageManager.shared.preferredTemplateID(in: templates)
@@ -309,8 +327,27 @@ private final class LocalRecordingController {
                     generatedNotes = ""
                 }
             }
+            var meetingChanged = false
             if !generatedNotes.isEmpty {
                 meeting.generatedNotes = generatedNotes
+                meetingChanged = true
+            }
+            if meeting.title.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty {
+                do {
+                    if let title = try await NotesGenerator.shared.generateMeetingTitle(
+                        meeting: meeting,
+                        generatedNotes: generatedNotes,
+                        templateId: meeting.templateId
+                    ) {
+                        meeting.title = title
+                        meetingChanged = true
+                    }
+                } catch {
+                    // The recording and generated notes remain valid without a generated title.
+                    print("Meeting title generation failed: \(error)")
+                }
+            }
+            if meetingChanged {
                 _ = LocalStorageManager.shared.saveMeeting(meeting)
                 NotificationCenter.default.post(name: .meetingSaved, object: meeting)
             }

meetingnotes/Services/NotesGenerator.swift

@@ -106,6 +106,88 @@ class NotesGenerator {
         }
     }
 
+    /// Generates a short title after meeting notes have been created.
+    func generateMeetingTitle(
+        meeting: Meeting,
+        generatedNotes: String,
+        templateId: UUID?
+    ) async throws -> String? {
+        let templates = LocalStorageManager.shared.loadTemplates()
+        let template = templateId.flatMap { id in
+            templates.first(where: { $0.id == id })
+        }
+        let meetingContext: String
+        if let template {
+            meetingContext = "\(template.title): \(template.context)"
+        } else {
+            meetingContext = "General meeting"
+        }
+
+        let trimmedNotes = generatedNotes.trimmingCharacters(in: .whitespacesAndNewlines)
+        let meetingContent = trimmedNotes.isEmpty ? meeting.formattedTranscript : trimmedNotes
+        guard !meetingContent.isEmpty else { return nil }
+
+        let systemPrompt = """
+        Create a concise, descriptive title for a recorded meeting from its context and content.
+        Return only the title in 3 to 8 words. Do not use quotation marks, Markdown, or a trailing period.
+        Avoid generic titles such as Meeting, Discussion, Meeting Notes, or Untitled Meeting.
+        """
+        let userPrompt = """
+        Meeting context:
+        \(meetingContext)
+
+        Meeting content:
+        \(meetingContent)
+        """
+
+        var generatedTitle = ""
+        let stream = CoderAPIClient.shared.streamChat(
+            systemPrompt: systemPrompt,
+            userPrompt: userPrompt,
+            model: UserDefaultsManager.shared.notesModel
+        )
+        for try await content in stream {
+            generatedTitle += content
+        }
+
+        return normalizedTitle(generatedTitle)
+    }
+
+    private func normalizedTitle(_ value: String) -> String? {
+        guard var title = value
+            .split(whereSeparator: \Character.isNewline)
+            .map(String.init)
+            .first(where: { !$0.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty })?
+            .trimmingCharacters(in: .whitespacesAndNewlines) else {
+            return nil
+        }
+
+        while title.hasPrefix("#") {
+            title.removeFirst()
+            title = title.trimmingCharacters(in: .whitespaces)
+        }
+        if title.lowercased().hasPrefix("title:") {
+            title = String(title.dropFirst("title:".count))
+                .trimmingCharacters(in: .whitespacesAndNewlines)
+        }
+        title = title.trimmingCharacters(in: CharacterSet(charactersIn: "\"'"))
+        if title.hasSuffix(".") {
+            title.removeLast()
+        }
+
+        if title.count > 80 {
+            let prefix = String(title.prefix(80))
+            if let lastSpace = prefix.lastIndex(of: " ") {
+                title = String(prefix[..<lastSpace])
+            } else {
+                title = prefix
+            }
+        }
+
+        title = title.trimmingCharacters(in: .whitespacesAndNewlines)
+        return title.isEmpty ? nil : title
+    }
+    
     /// Validates if the Coder service token is configured
     /// - Returns: True if API key exists, false otherwise
     func isConfigured() -> Bool {

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

@@ -12,7 +12,7 @@ extension Notification.Name {
 enum MeetingViewTab: String, CaseIterable {
     case myNotes = "My Notes"
     case transcript = "Transcript"
-    case enhancedNotes = "Enhanced Notes"
+    case enhancedNotes = "Meeting Notes"
 }
 
 
@@ -25,6 +25,8 @@ class MeetingViewModel: ObservableObject {
     @Published private var recordingStateChanged = false // Trigger SwiftUI updates
     @Published var isValidatingKey = false // Indicates API key validation in progress
     @Published var isStartingRecording = false // Indicates recording start in progress
+    @Published var isRetryingTranscription = false
+    @Published private(set) var recoveryAudioFolderURL: URL?
     
     // Computed property to determine if Generate button should animate
     var shouldAnimateGenerateButton: Bool {
@@ -44,7 +46,13 @@ class MeetingViewModel: ObservableObject {
     }
 
     var isProcessing: Bool {
-        return recordingSessionManager.isProcessing && recordingSessionManager.activeMeetingId == meeting.id
+        return isRetryingTranscription ||
+            (recordingSessionManager.isProcessing && recordingSessionManager.activeMeetingId == meeting.id)
+    }
+
+    var canRetryTranscription: Bool {
+        recoveryAudioFolderURL != nil &&
+            !isRecording && !isProcessing && !isStartingRecording && !isValidatingKey
     }
     @Published var selectedTab: MeetingViewTab = .transcript  // Default to transcript tab
 
@@ -54,15 +62,6 @@ class MeetingViewModel: ObservableObject {
     
     private let recordingSessionManager = RecordingSessionManager.shared
     private var cancellables = Set<AnyCancellable>()
-    private var isNewMeeting = false
-    
-    // Computed property to check if meeting is empty
-    var isEmpty: Bool {
-        return meeting.transcriptChunks.isEmpty && 
-               meeting.userNotes.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty && 
-               meeting.generatedNotes.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty &&
-               meeting.title.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty
-    }
     
     init(meeting: Meeting = Meeting()) {
         // Load the latest version of the meeting from storage if it exists
@@ -76,9 +75,6 @@ class MeetingViewModel: ObservableObject {
         
 
         
-        // Detect if this is a new meeting based on content, not storage existence
-        isNewMeeting = isEmpty
-        
         // Set initial tab based on notes existence
         if !self.meeting.generatedNotes.isEmpty {
             selectedTab = .enhancedNotes
@@ -88,6 +84,7 @@ class MeetingViewModel: ObservableObject {
         
         // Load templates and selected template
         loadTemplates()
+        refreshRecoveryAudioFolder()
         // Observe template selection: save to meeting and regenerate notes on changes (skip initial)
         $selectedTemplateId
             .dropFirst()
@@ -145,13 +142,24 @@ class MeetingViewModel: ObservableObject {
             .dropFirst()
             .sink { [weak self] updatedChunks in
                 guard let self = self else { return }
-                // Only update if this meeting is the active recording
-                if recordingSessionManager.isRecordingMeeting(self.meeting.id) {
+                // Stop publishes the final chunks after capture has ended but
+                // before the active meeting is cleared.
+                if recordingSessionManager.activeMeetingId == 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
@@ -217,6 +225,9 @@ class MeetingViewModel: ObservableObject {
         Task {
             let chunks = await recordingSessionManager.stopRecording()
             meeting.transcriptChunks = chunks
+            meeting.recoveryAudioFolderName = recordingSessionManager.lastRecoveryAudioFolderName
+            meeting.transcriptionError = recordingSessionManager.errorMessage
+            refreshRecoveryAudioFolder()
             saveMeeting()
             if !meeting.formattedTranscript.isEmpty {
                 await generateNotes()
@@ -225,6 +236,47 @@ class MeetingViewModel: ObservableObject {
         }
     }
 
+    func retryTranscription() {
+        guard let recoveryAudioFolderURL, canRetryTranscription else { return }
+
+        isRetryingTranscription = true
+        errorMessage = nil
+        Task {
+            defer { isRetryingTranscription = false }
+            do {
+                let chunks = try await AudioManager.shared.transcribeRecoveryAudio(
+                    in: recoveryAudioFolderURL,
+                    captureStartedAt: meeting.date
+                )
+                meeting.transcriptChunks = chunks
+                meeting.recoveryAudioFolderName = recoveryAudioFolderURL.lastPathComponent
+                meeting.transcriptionError = nil
+                selectedTab = .transcript
+
+                guard saveMeeting() else {
+                    throw CocoaError(.fileWriteUnknown)
+                }
+
+                await generateNotes()
+            } catch {
+                errorMessage = error.localizedDescription
+                meeting.transcriptionError = error.localizedDescription
+                _ = saveMeeting()
+                print("Retry transcription failed: \(error)")
+            }
+        }
+    }
+
+    private func refreshRecoveryAudioFolder() {
+        recoveryAudioFolderURL = LocalStorageManager.shared.findRecoveryAudioFolder(for: meeting)
+        meeting.recoveryAudioFolderName = recoveryAudioFolderURL?.lastPathComponent
+    }
+
+    func showAudioInFinder() {
+        guard let recoveryAudioFolderURL else { return }
+        LocalStorageManager.shared.showAudioFolderInFinder(recoveryAudioFolderURL)
+    }
+    
     func loadTemplates() {
         templates = LocalStorageManager.shared.loadTemplates()
 
@@ -272,20 +324,40 @@ class MeetingViewModel: ObservableObject {
         
         // Only save if there was no error
         if !hasError {
+            await generateTitleIfNeeded()
             saveMeeting()
         }
         
         isGeneratingNotes = false
     }
 
-    func saveMeeting() {
-        if isDeleted { return }
+    private func generateTitleIfNeeded() async {
+        guard meeting.title.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty else { return }
+
+        do {
+            if let title = try await NotesGenerator.shared.generateMeetingTitle(
+                meeting: meeting,
+                generatedNotes: meeting.generatedNotes,
+                templateId: selectedTemplateId
+            ) {
+                meeting.title = title
+            }
+        } catch {
+            // A title is helpful but should never prevent completed notes from being saved.
+            print("Meeting title generation failed: \(error)")
+        }
+    }
+    
+    @discardableResult
+    func saveMeeting() -> Bool {
+        if isDeleted { return false }
         print("💾 Saving meeting: \(meeting.id)")
         let success = LocalStorageManager.shared.saveMeeting(meeting)
         print("💾 Save result: \(success ? "SUCCESS" : "FAILED")")
         if success {
             NotificationCenter.default.post(name: .meetingSaved, object: meeting)
         }
+        return success
     }
     
     func copyCurrentTabContent() {
@@ -333,12 +405,4 @@ class MeetingViewModel: ObservableObject {
         }
     }
     
-    func deleteIfEmpty() {
-        if isEmpty && !isRecording && !isProcessing {
-            print("🗑️ Auto-deleting empty meeting")
-            deleteMeeting()
-        } else {
-            saveMeeting()
-        }
-    }
 }

meetingnotes/ViewModels/SettingsViewModel.swift

@@ -71,6 +71,7 @@ class SettingsViewModel: ObservableObject {
         // via computed properties when they're modified
         let coderSaved = KeychainHelper.shared.saveCoderAPIKey(settings.coderAPIKey)
         LocalAPIServer.shared.applyConfiguration()
+        LocalStorageManager.shared.purgeExpiredAudioFolders()
 
         if showMessage {
             if coderSaved {

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: {
-                        // When a meeting is deleted from the detail view, clear the selection
-                        self.selectedMeeting = nil
-                    })
+                    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)
             }
@@ -208,12 +266,12 @@ struct CollapsedTranscriptChunkView: View {
                     .font(.caption)
                     .foregroundColor(chunk.source == .mic ? .blue : .orange)
                 
-                Text(chunk.source.displayName)
+                Text(chunk.displayName)
                     .font(.caption)
                     .fontWeight(.medium)
                     .foregroundColor(chunk.source == .mic ? .blue : .orange)
             }
-            .frame(width: 50, alignment: .leading)
+            .frame(width: 78, alignment: .leading)
             
             // Transcript text
             Text(chunk.combinedText)
@@ -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
     }
     
@@ -259,6 +327,34 @@ struct MeetingDetailContentView: View {
                     
                     // Ellipsis menu
                     Menu {
+                        if viewModel.recoveryAudioFolderURL != nil {
+                            Button {
+                                viewModel.retryTranscription()
+                            } label: {
+                                Label("Retry Transcription", systemImage: "arrow.clockwise")
+                            }
+                            .disabled(!viewModel.canRetryTranscription)
+
+                            Button {
+                                viewModel.showAudioInFinder()
+                            } label: {
+                                Label("Show Audio in Finder", systemImage: "folder")
+                            }
+
+                            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
                         }
@@ -327,7 +423,7 @@ struct MeetingDetailContentView: View {
                         }
                         .buttonStyle(.plain)
                         .disabled(viewModel.meeting.transcript.isEmpty || viewModel.isGeneratingNotes || viewModel.isRecording || viewModel.isProcessing || viewModel.isStartingRecording)
-                        .help("Generate enhanced notes using a template")
+                        .help("Generate meeting notes using a template")
                         
                         // Recording Button
                         Button(action: {
@@ -374,7 +470,7 @@ struct MeetingDetailContentView: View {
                     
                     Spacer()
                     
-                    // Edit/Preview button (for My Notes and Enhanced Notes)
+                    // Edit/Preview button (for My Notes and Meeting Notes)
                     if viewModel.selectedTab == .myNotes || viewModel.selectedTab == .enhancedNotes {
                         Button(action: {
                             isEditing.toggle()
@@ -444,9 +540,27 @@ 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 {
-            // Auto-delete empty meetings when leaving, otherwise save
-            viewModel.deleteIfEmpty()
+            // A failed recording may still be empty. Keep it until the user
+            // explicitly deletes it so app updates cannot erase history.
+            viewModel.saveMeeting()
         }
     }
     
@@ -477,24 +591,52 @@ struct MeetingDetailContentView: View {
     }
     
     private var transcriptView: some View {
-        ScrollView {
-            if viewModel.meeting.collapsedTranscriptChunks.isEmpty {
-                Text("Transcript will appear here...")
-                    .frame(maxWidth: .infinity, alignment: .leading)
-                    .padding()
-                    .foregroundColor(.secondary)
-            } else {
-                LazyVStack(alignment: .leading, spacing: 4) {
-                    ForEach(viewModel.meeting.collapsedTranscriptChunks) { chunk in
-                        CollapsedTranscriptChunkView(chunk: chunk)
+        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(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)
+                } else {
+                    LazyVStack(alignment: .leading, spacing: 4) {
+                        ForEach(viewModel.meeting.collapsedTranscriptChunks) { chunk in
+                            CollapsedTranscriptChunkView(chunk: chunk)
+                        }
+                    }
+                    .padding()
+                }
+            }
+            .frame(maxHeight: .infinity)
+            .background(Color.gray.opacity(0.05))
+            .cornerRadius(8)
         }
-        .frame(maxHeight: .infinity)
-        .background(Color.gray.opacity(0.05))
-        .cornerRadius(8)
     }
     
     private var enhancedNotesView: some View {

meetingnotes/Views/SettingsView.swift

@@ -58,6 +58,18 @@ struct SettingsView: View {
                                 Text(model.displayName).tag(model.id)
                             }
                         }
+
+                        if let selectedModel = viewModel.coderModels.first(where: { $0.id == viewModel.settings.transcriptionModel }) {
+                            if selectedModel.supportsSpeakerDiarization {
+                                Label("Remote participants are labeled Speaker 1–4; your microphone is labeled Me.", systemImage: "person.2.wave.2")
+                                    .font(.caption)
+                                    .foregroundColor(.secondary)
+                            } else {
+                                Label("Remote participants are labeled Them; your microphone is labeled Me.", systemImage: "person.2")
+                                    .font(.caption)
+                                    .foregroundColor(.secondary)
+                            }
+                        }
                     }
 
                     Text("The token is stored locally in Keychain. Audio and note generation are sent only to this Coder service.")
@@ -128,6 +140,23 @@ struct SettingsView: View {
                     Text("Meeting Storage")
                         .font(.headline)
 
+                    LabeledContent("Audio retention") {
+                        Stepper(
+                            value: $viewModel.settings.audioRetentionDays,
+                            in: 1...365
+                        ) {
+                            Text("\(viewModel.settings.audioRetentionDays) \(viewModel.settings.audioRetentionDays == 1 ? "day" : "days")")
+                                .monospacedDigit()
+                                .frame(minWidth: 70, alignment: .trailing)
+                        }
+                    }
+
+                    Button {
+                        LocalStorageManager.shared.showAudioFolderInFinder()
+                    } label: {
+                        Label("Show Audio Folder", systemImage: "folder")
+                    }
+
                     Button {
                         showingMeetingImporter = true
                     } label: {

scripts/package_release.sh

@@ -14,6 +14,9 @@ APP_PATH="$DERIVED_DATA/Build/Products/Release/$APP_NAME.app"
 required_variables=(
   VERSION
   SIGNING_IDENTITY
+  APPLE_ID
+  APPLE_TEAM_ID
+  APPLE_APP_PASSWORD
   SPARKLE_PRIVATE_KEY
   GITHUB_REPOSITORY
 )
@@ -80,6 +83,33 @@ ARCHIVE_NAME="$APP_NAME-$VERSION.zip"
 ARCHIVE_PATH="$RELEASE_DIR/$ARCHIVE_NAME"
 ditto -c -k --sequesterRsrc --keepParent "$APP_PATH" "$ARCHIVE_PATH"
 
+NOTARY_RESULT="$BUILD_ROOT/notary-result.json"
+xcrun notarytool submit "$ARCHIVE_PATH" \
+  --apple-id "$APPLE_ID" \
+  --team-id "$APPLE_TEAM_ID" \
+  --password "$APPLE_APP_PASSWORD" \
+  --wait \
+  --timeout 20m \
+  --output-format json > "$NOTARY_RESULT"
+
+NOTARY_STATUS=$(plutil -extract status raw -o - "$NOTARY_RESULT")
+if [[ "$NOTARY_STATUS" != "Accepted" ]]; then
+  submission_id=$(plutil -extract id raw -o - "$NOTARY_RESULT")
+  xcrun notarytool log "$submission_id" \
+    --apple-id "$APPLE_ID" \
+    --team-id "$APPLE_TEAM_ID" \
+    --password "$APPLE_APP_PASSWORD" || true
+  echo "Apple notarization failed with status: $NOTARY_STATUS" >&2
+  exit 1
+fi
+
+xcrun stapler staple "$APP_PATH"
+xcrun stapler validate "$APP_PATH"
+spctl --assess --type execute --verbose=2 "$APP_PATH"
+
+rm -f "$ARCHIVE_PATH"
+ditto -c -k --sequesterRsrc --keepParent "$APP_PATH" "$ARCHIVE_PATH"
+
 GENERATE_APPCAST=$(find "$DERIVED_DATA/SourcePackages/artifacts" -type f -name generate_appcast -print -quit)
 if [[ -z "$GENERATE_APPCAST" ]]; then
   echo "Sparkle generate_appcast tool was not found" >&2
@@ -97,8 +127,8 @@ grep -q "$DOWNLOAD_URL$ARCHIVE_NAME" "$RELEASE_DIR/appcast.xml"
 grep -q 'sparkle:edSignature=' "$RELEASE_DIR/appcast.xml"
 
 if [[ -n "${GITHUB_STEP_SUMMARY:-}" ]]; then
-  printf 'Built and Developer ID-signed Meetingnotes %s. The GitHub release is ready to publish.\n' \
+  printf 'Built, Developer ID-signed, notarized, and stapled Meetingnotes %s. The GitHub release is ready to publish.\n' \
     "$VERSION" >> "$GITHUB_STEP_SUMMARY"
 fi
 
-echo "Signed release artifacts are ready in $RELEASE_DIR"
+echo "Signed and notarized release artifacts are ready in $RELEASE_DIR"