fix: preserve system audio duration

fix: transcribe long recordings in chunks
fix: preserve system audio resampler state
2026-07-29 16:06:44 +02:00 · 2026-07-23 14:48:25 +02:00 · 2026-07-23 14:29:04 +02:00 · 2026-07-22 16:31:01 +02:00 · 2026-07-22 16:24:08 +02:00 · 2026-07-22 16:14:33 +02:00
17 changed files with 813 additions and 105 deletions
@@ -276,7 +276,7 @@
 				CODE_SIGN_IDENTITY = "Apple Development";
 				CODE_SIGN_STYLE = Automatic;
 				COMBINE_HIDPI_IMAGES = YES;
-				CURRENT_PROJECT_VERSION = 21;
+				CURRENT_PROJECT_VERSION = 30;
 				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.9;
+				MARKETING_VERSION = 1.1.18;
 				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 = 21;
+				CURRENT_PROJECT_VERSION = 30;
 				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.9;
+				MARKETING_VERSION = 1.1.18;
 				ONLY_ACTIVE_ARCH = YES;
 				OTHER_SWIFT_FLAGS = "$(inherited) -D ENABLE_TCC_SPI";
 				PRODUCT_BUNDLE_IDENTIFIER = net.jamesbone.meetingnotes;
@@ -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>
@@ -3,6 +3,23 @@ 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)"
+        }
+    }
+}
+
 /// Captures microphone and system audio locally, then sends completed files to Coder.
@MainActor
 final class AudioManager: NSObject, ObservableObject {
@@ -14,22 +31,20 @@ 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?
@@ -39,24 +54,18 @@ final class AudioManager: NSObject, ObservableObject {
    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()
        do {
            try prepareAudioFiles()
@@ -69,7 +78,7 @@ final class AudioManager: NSObject, ObservableObject {
    }

    func stopRecordingAndTranscribe() async -> [TranscriptChunk] {
-        let completedSessionID = sessionID
+        let completedMeetingID = meetingID
        let captureStartedAt = recordingStartedAt
        let files = stopCaptureAndCloseFiles()
        isProcessing = true
@@ -83,7 +92,78 @@ final class AudioManager: NSObject, ObservableObject {
        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
+        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"
+            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 micURL = recoveryFiles.first(where: { $0.source == .mic })?.url
+        let systemURL = recoveryFiles.first(where: { $0.source == .system })?.url
+        async let micResult = transcribe(micURL, model: model)
+        async let systemResult = transcribe(systemURL, model: model)
+        let (micTranscription, systemTranscription) = await (micResult, systemResult)
+        let results = [micTranscription, systemTranscription]
+        let (chunks, failures) = buildTranscriptChunks(
+            from: results,
+            captureStartedAt: captureStartedAt,
+            existingChunks: []
+        )
+
+        if !failures.isEmpty {
+            throw RecoveryTranscriptionError.requestFailed(failures.joined(separator: "; "))
+        }
+        guard !chunks.isEmpty else {
+            throw RecoveryTranscriptionError.noSpeech
+        }
+        return chunks
+    }
+
+    func cancelRecording() {
+        cancelCapture(removeFiles: true)
+        lastRecoveryAudioFolderName = nil
+    }
+
+    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)
+        }
+    }
+
+    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 }
@@ -114,31 +194,7 @@ 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 {
@@ -239,8 +295,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 +319,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
@@ -302,12 +344,14 @@ final class AudioManager: NSObject, ObservableObject {
    private func startTapIO(_ tap: ProcessTap) throws {
        guard var description = tap.tapStreamDescription,
              let inputFormat = AVAudioFormat(streamDescription: &description),
-              let targetFormat = systemAudioFile?.processingFormat else {
+              let targetFormat = systemAudioFile?.processingFormat,
+              let converter = AVAudioConverter(from: inputFormat, to: targetFormat) else {
            throw NSError(domain: "AudioManager", code: -1, userInfo: [NSLocalizedDescriptionKey: "Unsupported system audio format"])
        }
        try tap.run(on: tapQueue) { [weak self] _, inputData, _, _, _ in
-            guard let self,
-                  let converter = AVAudioConverter(from: inputFormat, to: targetFormat) else { return }
+            guard let self else { return }
+            // The tap queue is serial. Reusing the converter preserves its
+            // resampler state instead of discarding audio at every callback.
            self.processAudioBuffer(
                { self.copyAudioBuffer(from: inputData, format: inputFormat) },
                converter: converter,
@@ -315,7 +359,7 @@ final class AudioManager: NSObject, ObservableObject {
                source: .system
            )
        } invalidationHandler: { [weak self] _ in
-            guard let self, !self.isRestartingSystemTap, self.isRecording else { return }
+            guard let self, self.isRecording else { return }
            Task { await self.restartSystemAudioTap() }
        }
    }
@@ -463,29 +507,8 @@ 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
-        }
-        let folder = documents
-            .appendingPathComponent("Meetingnotes-Recovery", isDirectory: true)
-            .appendingPathComponent(sessionID.uuidString, isDirectory: true)
-        do {
-            try FileManager.default.createDirectory(at: folder, withIntermediateDirectories: true)
-        } catch {
-            return nil
-        }
-        var preservedCount = 0
-        for url in urls {
-            do {
-                try FileManager.default.moveItem(at: url, to: folder.appendingPathComponent(url.lastPathComponent))
-                preservedCount += 1
-            } catch {
-                continue
-            }
-        }
-        return preservedCount > 0 ? folder : nil
+    private func preserveAudioFiles(_ urls: [URL], meetingID: UUID) -> URL? {
+        LocalStorageManager.shared.preserveAudioFiles(urls, for: meetingID)
    }
        
    private func resetAudioLevels() {
@@ -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
@@ -26,12 +28,18 @@ 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,179 @@ class LocalStorageManager {
        }
    }

+    // 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? {
+        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 {
+            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
+    }
+
+    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()
@@ -81,7 +81,7 @@ class RecordingSessionManager: ObservableObject {
        
        activeMeetingId = meetingId
        recordingStartedAt = Date()
-        audioManager.startRecording()
+        audioManager.startRecording(for: meetingId)
    }
    
    func stopRecording() async -> [TranscriptChunk] {
@@ -112,6 +112,10 @@ class RecordingSessionManager: ObservableObject {
    func isRecordingMeeting(_ meetingId: UUID) -> Bool {
        return isRecording && activeMeetingId == meetingId
    }
+
+    var lastRecoveryAudioFolderName: String? {
+        audioManager.lastRecoveryAudioFolderName
+    }
    
    private func updateActiveMeetingTranscript(meetingId: UUID, chunks: [TranscriptChunk]) {
        // Load all meetings
@@ -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
@@ -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) }
+    }
 }
@@ -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)
+        }
    }
 }

@@ -82,6 +82,7 @@ struct Meeting: Codable, Identifiable, Hashable {
    var userNotes: String
    var generatedNotes: String
    var templateId: UUID?  // Add property to track per-meeting template
+    var recoveryAudioFolderName: String?
    // MARK: - Data versioning
    /// Version of this Meeting record on disk. Useful for migration.
    var dataVersion: Int
@@ -95,6 +96,7 @@ struct Meeting: Codable, Identifiable, Hashable {
         userNotes: String = "",
         generatedNotes: String = "",
         templateId: UUID? = nil,
+         recoveryAudioFolderName: String? = nil,
         dataVersion: Int = Meeting.currentDataVersion) {
        self.id = id
        self.date = date
@@ -103,6 +105,7 @@ struct Meeting: Codable, Identifiable, Hashable {
        self.userNotes = userNotes
        self.generatedNotes = generatedNotes
        self.templateId = templateId
+        self.recoveryAudioFolderName = recoveryAudioFolderName
        self.dataVersion = dataVersion
    }
    
@@ -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"),
@@ -5,7 +5,7 @@ import AVFoundation

 enum TapTarget {
    case singleProcess(AudioProcess)
-    case systemAudio(processObjectIDs: [AudioObjectID])
+    case systemAudio

    var displayName: String {
        switch self {
@@ -137,12 +137,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:
+            // 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.")
        }
        
        tapDescription.uuid = UUID()
@@ -1,3 +1,4 @@
+import AVFoundation
 import Foundation

 struct CoderModel: Codable, Identifiable, Hashable {
@@ -73,6 +74,13 @@ final class CoderAPIClient {
        let segments: [Transcription.Segment]?
    }

+    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 +105,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 +125,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
                    ])
@@ -151,10 +163,67 @@ final class CoderAPIClient {
        let selectedModel = model.trimmingCharacters(in: .whitespacesAndNewlines)
        guard !selectedModel.isEmpty else { throw CoderAPIError.missingModel("transcription") }
        let apiKey = try requiredAPIKey(KeychainHelper.shared.getCoderAPIKey() ?? "")
+        let chunks = try makeAudioChunks(from: fileURL)
+        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
+            )
+            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))
+                }
+                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
+                ))
+            }
+        }
+
+        return Transcription(text: textParts.joined(separator: "\n"), segments: segments)
+    }
+
+    private func transcribeChunk(
+        _ fileURL: URL,
+        model: String,
+        language: String,
+        apiKey: String
+    ) async throws -> Transcription {
        let boundary = "Meetingnotes-\(UUID().uuidString)"
        let bodyURL = try makeMultipartBody(
            audioURL: fileURL,
-            model: selectedModel,
+            model: model,
            language: language,
            boundary: boundary
        )
@@ -174,6 +243,80 @@ final class CoderAPIClient {
        return Transcription(text: decoded.text, segments: decoded.segments ?? [])
    }

+    private func makeAudioChunks(from fileURL: URL) throws -> [AudioChunk] {
+        let input = try AVAudioFile(forReading: fileURL)
+        let format = input.processingFormat
+        guard format.sampleRate > 0 else {
+            return [AudioChunk(url: fileURL, offset: 0, isTemporary: false)]
+        }
+
+        let duration = Double(input.length) / format.sampleRate
+        guard duration > transcriptionChunkDuration else {
+            return [AudioChunk(url: fileURL, offset: 0, isTemporary: false)]
+        }
+
+        let framesPerChunk = AVAudioFramePosition(format.sampleRate * transcriptionChunkDuration)
+        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).m4a")
+                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: kAudioFormatMPEG4AAC,
+            AVSampleRateKey: format.sampleRate,
+            AVNumberOfChannelsKey: format.channelCount,
+            AVEncoderBitRateKey: 48_000 * max(1, Int(format.channelCount))
+        ]
+        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 endpoint(baseURL: String, path: String) throws -> URL {
        guard var components = URLComponents(string: baseURL.trimmingCharacters(in: .whitespacesAndNewlines)),
              let scheme = components.scheme?.lowercased(),
@@ -286,6 +286,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 +310,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)
            }
@@ -105,6 +105,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
@@ -115,4 +197,4 @@ class NotesGenerator {
        }
        return true
    }
-} 
+}
@@ -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

@@ -76,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()
@@ -205,6 +214,8 @@ class MeetingViewModel: ObservableObject {
        Task {
            let chunks = await recordingSessionManager.stopRecording()
            meeting.transcriptChunks = chunks
+            meeting.recoveryAudioFolderName = recordingSessionManager.lastRecoveryAudioFolderName
+            refreshRecoveryAudioFolder()
            saveMeeting()
            if !meeting.formattedTranscript.isEmpty {
                await generateNotes()
@@ -212,6 +223,46 @@ class MeetingViewModel: ObservableObject {
            isStartingRecording = false
        }
    }
+
+    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
+                selectedTab = .transcript
+
+                guard saveMeeting() else {
+                    throw CocoaError(.fileWriteUnknown)
+                }
+
+                await generateNotes()
+            } catch {
+                errorMessage = error.localizedDescription
+                print("Retry transcription failed: \(error)")
+            }
+        }
+    }
+
+    private func refreshRecoveryAudioFolder() {
+        recoveryAudioFolderURL = LocalStorageManager.shared.findRecoveryAudioFolder(for: meeting)
+        if let recoveryAudioFolderURL {
+            meeting.recoveryAudioFolderName = recoveryAudioFolderURL.lastPathComponent
+        }
+    }
+
+    func showAudioInFinder() {
+        guard let recoveryAudioFolderURL else { return }
+        LocalStorageManager.shared.showAudioFolderInFinder(recoveryAudioFolderURL)
+    }
    
    func loadTemplates() {
        templates = LocalStorageManager.shared.loadTemplates()
@@ -260,20 +311,40 @@ class MeetingViewModel: ObservableObject {
        
        // Only save if there was no error
        if !hasError {
+            await generateTitleIfNeeded()
            saveMeeting()
        }
        
        isGeneratingNotes = false
    }
+
+    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)")
+        }
+    }
    
-    func saveMeeting() {
-        if isDeleted { return }
+    @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() {
@@ -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 {
@@ -259,6 +259,23 @@ 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()
+                        }
+
                        Button("Delete Meeting", role: .destructive) {
                            showDeleteAlert = true
                        }
@@ -327,7 +344,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 +391,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()
@@ -128,6 +128,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: {
Author	SHA1	Message	Date
coder	579a91d357	fix: preserve system audio duration	2026-07-29 16:06:44 +02:00
james	19b17fc9a5	fix: transcribe long recordings in chunks	2026-07-23 14:48:25 +02:00
james	1268149114	fix: preserve system audio resampler state	2026-07-23 14:29:04 +02:00
james	0f45f2d066	feat: make audio retention configurable	2026-07-22 16:31:01 +02:00
james	f1d57da227	feat: retain meeting audio for three days	2026-07-22 16:24:08 +02:00
james	94d8469eba	fix: capture all system audio	2026-07-22 16:14:33 +02:00
james	628587ae92	feat: retry failed transcriptions	2026-07-20 13:13:15 +02:00
james	f992457cfe	feat: add menu bar mode	2026-07-17 12:46:34 +02:00
james	ad995b59ad	feat: generate meeting titles automatically	2026-07-17 12:15:04 +02:00