fix: count Core Audio callback frames explicitly

.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 = 31;
+				CURRENT_PROJECT_VERSION = 40;
 				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.19;
+				MARKETING_VERSION = 1.1.28;
 				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 = 31;
+				CURRENT_PROJECT_VERSION = 40;
 				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.19;
+				MARKETING_VERSION = 1.1.28;
 				ONLY_ACTIVE_ARCH = YES;
 				OTHER_SWIFT_FLAGS = "$(inherited) -D ENABLE_TCC_SPI";
 				PRODUCT_BUNDLE_IDENTIFIER = net.jamesbone.meetingnotes;

README.md

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

meetingnotes/Managers/AudioManager.swift

@@ -86,9 +86,22 @@ final class AudioManager: NSObject, ObservableObject {
             isProcessing = false
         }
 
+        repairHalfDurationSystemWAVIfNeeded(in: files)
+        let completedFiles = files.compactMap { $0 }
+        let audioFolder = preserveAudioFiles(completedFiles, meetingID: completedMeetingID)
+        let transcriptionFiles = preservedAudioFiles(files, in: audioFolder)
+        lastRecoveryAudioFolderName = audioFolder?.lastPathComponent
+        if let mismatch = captureDurationMismatch(in: transcriptionFiles) {
+            let recoveryMessage = audioFolder == nil
+                ? " The audio remains in the app's temporary folder."
+                : " Audio was kept so it can be recovered."
+            errorMessage = "System audio timing was invalid (\(mismatch)). Transcription was stopped to avoid an out-of-order result." + recoveryMessage
+            return transcriptChunks.filter(\.isFinal)
+        }
+
         let model = UserDefaultsManager.shared.transcriptionModel
-        async let micResult = transcribe(files[0], model: model, diarization: false)
-        async let systemResult = transcribe(files[1], model: model, diarization: true)
+        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]
 
@@ -98,9 +111,6 @@ final class AudioManager: NSObject, ObservableObject {
             existingChunks: transcriptChunks.filter(\.isFinal)
         )
         transcriptChunks = updated
-        let completedFiles = files.compactMap { $0 }
-        let audioFolder = preserveAudioFiles(completedFiles, meetingID: completedMeetingID)
-        lastRecoveryAudioFolderName = audioFolder?.lastPathComponent
         if !failures.isEmpty {
             let retentionDays = UserDefaultsManager.shared.audioRetentionDays
             let retentionUnit = retentionDays == 1 ? "day" : "days"
@@ -123,17 +133,29 @@ final class AudioManager: NSObject, ObservableObject {
         isProcessing = true
         defer { isProcessing = false }
         let model = UserDefaultsManager.shared.transcriptionModel
-        let micURL = recoveryFiles.first(where: { $0.source == .mic })?.url
-        let systemURL = recoveryFiles.first(where: { $0.source == .system })?.url
-        async let micResult = transcribe(micURL, model: model, diarization: false)
-        async let systemResult = transcribe(systemURL, model: model, diarization: true)
-        let (micTranscription, systemTranscription) = await (micResult, systemResult)
-        let results = [micTranscription, systemTranscription]
-        let (chunks, failures) = buildTranscriptChunks(
-            from: results,
-            captureStartedAt: captureStartedAt,
-            existingChunks: []
-        )
+        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: "; "))
@@ -144,6 +166,28 @@ final class AudioManager: NSObject, ObservableObject {
         return chunks
     }
 
+    private func recoverySessionKey(for url: URL) -> String {
+        let name = url.deletingPathExtension().lastPathComponent
+        if name.hasSuffix("-mic") { return String(name.dropLast(4)) }
+        if name.hasSuffix("-system") { return String(name.dropLast(7)) }
+        return name
+    }
+
+    private func recoveryCaptureStartedAt(
+        for files: [(url: URL, source: AudioSource)],
+        fallback: Date
+    ) -> Date {
+        let estimatedStarts = files.compactMap { file -> Date? in
+            guard let duration = audioDuration(at: file.url),
+                  let values = try? file.url.resourceValues(forKeys: [.contentModificationDateKey, .creationDateKey]),
+                  let finishedAt = values.contentModificationDate ?? values.creationDate else {
+                return nil
+            }
+            return finishedAt.addingTimeInterval(-duration)
+        }
+        return estimatedStarts.min() ?? fallback
+    }
+
     func cancelRecording() {
         cancelCapture(removeFiles: true)
         lastRecoveryAudioFolderName = nil
@@ -209,15 +253,18 @@ final class AudioManager: NSObject, ObservableObject {
     
     private func prepareAudioFiles() throws {
         let settings: [String: Any] = [
-            AVFormatIDKey: kAudioFormatMPEG4AAC,
+            AVFormatIDKey: kAudioFormatLinearPCM,
             AVSampleRateKey: 16_000,
             AVNumberOfChannelsKey: 1,
-            AVEncoderBitRateKey: 48_000
+            AVLinearPCMBitDepthKey: 16,
+            AVLinearPCMIsFloatKey: false,
+            AVLinearPCMIsBigEndianKey: false,
+            AVLinearPCMIsNonInterleaved: false
         ]
         let base = FileManager.default.temporaryDirectory
         let id = sessionID.uuidString
-        let micURL = base.appendingPathComponent("meetingnotes-\(id)-mic.m4a")
-        let 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,
@@ -353,13 +400,25 @@ 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"])
         }
+        var inputFormat: AVAudioFormat?
+        var converter: AVAudioConverter?
         try tap.run(on: tapQueue) { [weak self] _, inputData, _, _, _ in
             guard let self else { return }
+            if inputFormat == nil {
+                inputFormat = self.inputFormat(
+                    for: inputData,
+                    advertisedFormat: advertisedInputFormat
+                )
+                if let inputFormat {
+                    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(
@@ -374,24 +433,56 @@ final class AudioManager: NSObject, ObservableObject {
         }
     }
 
+    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? {
-        guard let borrowedBuffer = AVAudioPCMBuffer(
-            pcmFormat: format,
-            bufferListNoCopy: inputData,
-            deallocator: nil
-        ), borrowedBuffer.frameLength > 0,
-        let ownedBuffer = AVAudioPCMBuffer(
-            pcmFormat: format,
-            frameCapacity: borrowedBuffer.frameLength
-        ) else { return nil }
-
-        ownedBuffer.frameLength = borrowedBuffer.frameLength
         let sourceBuffers = UnsafeMutableAudioBufferListPointer(
             UnsafeMutablePointer(mutating: inputData)
         )
+        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
         )
@@ -520,6 +611,99 @@ final class AudioManager: NSObject, ObservableObject {
     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
+        }
+    }
+
+    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?]) {
+        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 }
+        try? halveWAVSampleRate(at: systemURL)
+    }
+
+    private func halveWAVSampleRate(at url: URL) throws {
+        let handle = try FileHandle(forUpdating: url)
+        defer { try? handle.close() }
+
+        try handle.seek(toOffset: 0)
+        guard let riffHeader = try handle.read(upToCount: 12),
+              riffHeader.count == 12,
+              String(data: riffHeader[0..<4], encoding: .ascii) == "RIFF",
+              String(data: riffHeader[8..<12], encoding: .ascii) == "WAVE" else {
+            throw NSError(domain: "AudioManager", code: -2, userInfo: [NSLocalizedDescriptionKey: "Invalid WAV header"])
+        }
+
+        var offset: UInt64 = 12
+        while true {
+            try handle.seek(toOffset: offset)
+            guard let chunkHeader = try handle.read(upToCount: 8), chunkHeader.count == 8 else { break }
+            let chunkID = String(data: chunkHeader[0..<4], encoding: .ascii)
+            let chunkSize = UInt32(chunkHeader[4])
+                | (UInt32(chunkHeader[5]) << 8)
+                | (UInt32(chunkHeader[6]) << 16)
+                | (UInt32(chunkHeader[7]) << 24)
+            let chunkDataOffset = offset + 8
+
+            if chunkID == "fmt ", chunkSize >= 16 {
+                try handle.seek(toOffset: chunkDataOffset)
+                guard let format = try handle.read(upToCount: 16), format.count == 16 else { break }
+                let audioFormat = UInt16(format[0]) | (UInt16(format[1]) << 8)
+                let blockAlign = UInt16(format[12]) | (UInt16(format[13]) << 8)
+                let sampleRate = UInt32(format[4])
+                    | (UInt32(format[5]) << 8)
+                    | (UInt32(format[6]) << 16)
+                    | (UInt32(format[7]) << 24)
+                guard audioFormat == 1, sampleRate >= 16_000, sampleRate.isMultiple(of: 2) else {
+                    throw NSError(domain: "AudioManager", code: -3, userInfo: [NSLocalizedDescriptionKey: "Unsupported WAV format"])
+                }
+
+                let correctedSampleRate = sampleRate / 2
+                let correctedByteRate = correctedSampleRate * UInt32(blockAlign)
+                try handle.seek(toOffset: chunkDataOffset + 4)
+                try handle.write(contentsOf: littleEndianData(correctedSampleRate))
+                try handle.write(contentsOf: littleEndianData(correctedByteRate))
+                try handle.synchronize()
+                return
+            }
+
+            offset = chunkDataOffset + UInt64(chunkSize) + UInt64(chunkSize % 2)
+        }
+
+        throw NSError(domain: "AudioManager", code: -4, userInfo: [NSLocalizedDescriptionKey: "WAV format chunk was not found"])
+    }
+
+    private func littleEndianData(_ value: UInt32) -> Data {
+        var littleEndianValue = value.littleEndian
+        return withUnsafeBytes(of: &littleEndianValue) { Data($0) }
+    }
+
+    private func audioDuration(at url: URL?) -> TimeInterval? {
+        guard let url,
+              let file = try? AVAudioFile(forReading: url),
+              file.processingFormat.sampleRate > 0 else { return nil }
+        return Double(file.length) / file.processingFormat.sampleRate
+    }
         
     private func resetAudioLevels() {
         micAudioLevel = 0

meetingnotes/Managers/LocalStorageManager.swift

@@ -152,6 +152,98 @@ 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? {
@@ -256,50 +348,12 @@ class LocalStorageManager {
     }
 
     func findRecoveryAudioFolder(for meeting: Meeting) -> URL? {
-        if let name = meeting.recoveryAudioFolderName,
-           let folder = recoveryAudioFolder(named: name) {
-            return folder
-        }
-
-        let claimedFolderNames = Set(
-            loadMeetings()
-                .filter { $0.id != meeting.id }
-                .compactMap(\.recoveryAudioFolderName)
-        )
-        guard let folders = try? FileManager.default.contentsOfDirectory(
-            at: recoveryDirectory,
-            includingPropertiesForKeys: [.isDirectoryKey, .creationDateKey, .contentModificationDateKey],
-            options: [.skipsHiddenFiles]
-        ) else {
+        let canonicalName = meeting.id.uuidString
+        guard meeting.recoveryAudioFolderName == nil
+                || meeting.recoveryAudioFolderName?.caseInsensitiveCompare(canonicalName) == .orderedSame else {
             return nil
         }
-
-        let candidates = folders.compactMap { folder -> (url: URL, distance: TimeInterval)? in
-            let folderValues = try? folder.resourceValues(
-                forKeys: [.isDirectoryKey, .creationDateKey, .contentModificationDateKey]
-            )
-            let files = recoveryAudioFiles(in: folder)
-            guard folderValues?.isDirectory == true,
-                  !claimedFolderNames.contains(folder.lastPathComponent),
-                  !files.isEmpty else {
-                return nil
-            }
-            let dates = files.compactMap { file -> Date? in
-                let values = try? file.url.resourceValues(forKeys: [.creationDateKey, .contentModificationDateKey])
-                return values?.creationDate ?? values?.contentModificationDate
-            }
-            let referenceDate = dates.min()
-                ?? folderValues?.creationDate
-                ?? folderValues?.contentModificationDate
-            guard let referenceDate else { return nil }
-            return (folder, abs(referenceDate.timeIntervalSince(meeting.date)))
-        }
-
-        // This fallback links recovery files created by older app versions.
-        return candidates
-            .filter { $0.distance <= 12 * 60 * 60 }
-            .min(by: { $0.distance < $1.distance })?
-            .url
+        return recoveryAudioFolder(named: canonicalName)
     }
 
     func deleteRecoveryAudioFolder(_ folder: URL) {

meetingnotes/Managers/RecordingSessionManager.swift

@@ -124,6 +124,9 @@ class RecordingSessionManager: ObservableObject {
         // 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
+            }
             
             // Save the updated meeting
             let success = LocalStorageManager.shared.saveMeeting(meetings[index])

meetingnotes/Managers/UserDefaultsManager.swift

@@ -79,13 +79,7 @@ class UserDefaultsManager {
     }
 
     var transcriptionModel: String {
-        get {
-            let stored = userDefaults.string(forKey: Keys.transcriptionModel)
-            if stored == "local-whisper/whisper-large-v3-turbo" {
-                return "local-parakeet/parakeet-tdt-0.6b-v3"
-            }
-            return stored ?? "local-parakeet/parakeet-tdt-0.6b-v3"
-        }
+        get { userDefaults.string(forKey: Keys.transcriptionModel) ?? "local-parakeet/parakeet-tdt-0.6b-v3" }
         set { userDefaults.set(newValue, forKey: Keys.transcriptionModel) }
     }
 

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." }
     }
@@ -307,4 +348,4 @@ extension AudioObjectID {
     func getDeviceName() throws -> String {
         return try readString(kAudioDevicePropertyDeviceNameCFString)
     }
-} 
+}

meetingnotes/ProcessTap/ProcessTap.swift

@@ -138,11 +138,11 @@ final class ProcessTap {
             tapDescription = CATapDescription(stereoMixdownOfProcesses: [process.objectID])
             logger.debug("Configuring tap for single process objectID: \(process.objectID)")
         case .systemAudio:
-            // Keep the HAL tap's buffer layout consistent with the default
-            // output stream. AudioManager performs the stereo-to-mono mix when
-            // it converts the captured audio to the 16 kHz transcription file.
-            tapDescription = CATapDescription(stereoGlobalTapButExcludeProcesses: [])
-            logger.debug("Configuring a stereo global system audio tap.")
+            // 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 +248,20 @@ 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()
+
+            // 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 {
+                self.tapStreamDescription = try aggregateDeviceID.readInputStreamBasicDescription()
+                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

@@ -275,6 +275,13 @@ final class CoderAPIClient {
         let framesPerChunk = preserveSpeakerIdentity
             ? max(1, input.length)
             : AVAudioFramePosition(format.sampleRate * transcriptionChunkDuration)
+
+        if fileURL.pathExtension.caseInsensitiveCompare("wav") == .orderedSame,
+           input.fileFormat.streamDescription.pointee.mFormatID == kAudioFormatLinearPCM,
+           input.length <= framesPerChunk {
+            return [AudioChunk(url: fileURL, offset: 0, isTemporary: false)]
+        }
+
         var chunks: [AudioChunk] = []
         var frameOffset: AVAudioFramePosition = 0
 

meetingnotes/Services/LocalAPIServer.swift

@@ -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,

meetingnotes/ViewModels/MeetingListViewModel.swift

@@ -66,6 +66,28 @@ class MeetingListViewModel: ObservableObject {
         meetings.removeAll { $0.id == meeting.id }
         _ = 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())

meetingnotes/ViewModels/MeetingViewModel.swift

@@ -254,9 +254,7 @@ class MeetingViewModel: ObservableObject {
 
     private func refreshRecoveryAudioFolder() {
         recoveryAudioFolderURL = LocalStorageManager.shared.findRecoveryAudioFolder(for: meeting)
-        if let recoveryAudioFolderURL {
-            meeting.recoveryAudioFolderName = recoveryAudioFolderURL.lastPathComponent
-        }
+        meeting.recoveryAudioFolderName = recoveryAudioFolderURL?.lastPathComponent
     }
 
     func showAudioInFinder() {

meetingnotes/Views/MeetingListView.swift

@@ -83,10 +83,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(
@@ -229,12 +238,22 @@ struct MeetingDetailContentView: View {
     @StateObject private var viewModel: MeetingViewModel
     @StateObject private var recordingSessionManager = RecordingSessionManager.shared
     @State private var showDeleteAlert = false
+    @State private var showMergeAlert = false
     @State private var isEditing = false
     @State private var showCopyConfirmation = false
+    let mergeCandidate: Meeting?
+    let onMerge: (Meeting) -> Bool
     let onDelete: () -> Void
     
-    init(meeting: Meeting, onDelete: @escaping () -> Void) {
+    init(
+        meeting: Meeting,
+        mergeCandidate: Meeting?,
+        onMerge: @escaping (Meeting) -> Bool,
+        onDelete: @escaping () -> Void
+    ) {
         self._viewModel = StateObject(wrappedValue: MeetingViewModel(meeting: meeting))
+        self.mergeCandidate = mergeCandidate
+        self.onMerge = onMerge
         self.onDelete = onDelete
     }
     
@@ -276,6 +295,17 @@ struct MeetingDetailContentView: View {
                             Divider()
                         }
 
+                        if mergeCandidate != nil {
+                            Button {
+                                showMergeAlert = true
+                            } label: {
+                                Label("Merge into Previous Meeting", systemImage: "arrow.triangle.merge")
+                            }
+                            .disabled(recordingSessionManager.isRecording || recordingSessionManager.isProcessing)
+
+                            Divider()
+                        }
+
                         Button("Delete Meeting", role: .destructive) {
                             showDeleteAlert = true
                         }
@@ -461,6 +491,23 @@ struct MeetingDetailContentView: View {
         } message: {
             Text("Are you sure you want to delete this meeting? This action cannot be undone.")
         }
+        .alert("Merge into Previous Meeting?", isPresented: $showMergeAlert) {
+            Button("Merge", role: .destructive) {
+                // Prevent the disappearing detail view from auto-saving the
+                // continuation after the storage layer removes it.
+                viewModel.isDeleted = true
+                if !onMerge(viewModel.meeting) {
+                    viewModel.isDeleted = false
+                    viewModel.errorMessage = "The meetings could not be merged. Their original records and audio were kept."
+                }
+            }
+            Button("Cancel", role: .cancel) { }
+        } message: {
+            let previousTitle = mergeCandidate?.title.isEmpty == false
+                ? mergeCandidate?.title ?? "the previous meeting"
+                : "the previous meeting"
+            Text("This combines this meeting's transcript, notes, and saved audio into \"\(previousTitle)\", keeps the earlier meeting's title and time, then removes this continuation.")
+        }
         .onDisappear {
             // A failed recording may still be empty. Keep it until the user
             // explicitly deletes it so app updates cannot erase history.

meetingnotes/Views/SettingsView.swift

@@ -59,10 +59,16 @@ struct SettingsView: View {
                             }
                         }
 
-                        if viewModel.coderModels.first(where: { $0.id == viewModel.settings.transcriptionModel })?.supportsSpeakerDiarization == true {
-                            Label("Remote participants are labeled Speaker 1–4; your microphone is labeled Me.", systemImage: "person.2.wave.2")
-                                .font(.caption)
-                                .foregroundColor(.secondary)
+                        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)
+                            }
                         }
                     }
 

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"