diff --git a/Package.swift b/Package.swift
index 56d614e..91766e1 100644
--- a/Package.swift
+++ b/Package.swift
@@ -14,7 +14,7 @@ let package = Package(
     dependencies: [
         .package(
             url: "https://github.com/FluidInference/FluidAudio.git",
-            .upToNextMinor(from: "0.12.6")
+            .upToNextMinor(from: "0.15.5")
         ),
         .package(url: "https://github.com/sparkle-project/Sparkle", from: "2.9.1"),
     ],
diff --git a/Sources/MiniWhisper/Features/EditMode/AppState+EditMode.swift b/Sources/MiniWhisper/Features/EditMode/AppState+EditMode.swift
index 162e76c..725a3ce 100644
--- a/Sources/MiniWhisper/Features/EditMode/AppState+EditMode.swift
+++ b/Sources/MiniWhisper/Features/EditMode/AppState+EditMode.swift
@@ -227,7 +227,7 @@ extension AppState {
                     instruction: transcription.text,
                     selection: context.selectedText,
                     settings: customEditProviderSettings)
-            case .gpt5Mini, .claudeHaiku45:
+            case .gpt56Luna, .claudeHaiku45:
                 edited = try await editModeProvider.editText(
                     instruction: transcription.text,
                     selection: context.selectedText,
diff --git a/Sources/MiniWhisper/Features/Transcription/AppState+Transcription.swift b/Sources/MiniWhisper/Features/Transcription/AppState+Transcription.swift
index f832626..00e53d4 100644
--- a/Sources/MiniWhisper/Features/Transcription/AppState+Transcription.swift
+++ b/Sources/MiniWhisper/Features/Transcription/AppState+Transcription.swift
@@ -50,7 +50,7 @@ extension AppState {
                 }
                 cleaned = try await customEditProvider.cleanupTranscript(
                     rawText, settings: customEditProviderSettings)
-            case .gpt5Mini, .claudeHaiku45:
+            case .gpt56Luna, .claudeHaiku45:
                 cleaned = try await editModeProvider.cleanupTranscript(
                     rawText, model: model)
             }
diff --git a/Sources/MiniWhisper/Models/EditModeSettings.swift b/Sources/MiniWhisper/Models/EditModeSettings.swift
index 8ea42a3..34d4f71 100644
--- a/Sources/MiniWhisper/Models/EditModeSettings.swift
+++ b/Sources/MiniWhisper/Models/EditModeSettings.swift
@@ -6,7 +6,7 @@ import Foundation
 /// `~/.codex/auth.json`); `.custom` routes through `CustomEditProvider`
 /// to a user-supplied OpenAI-compatible chat-completions endpoint.
 enum EditModeModel: String, Codable, CaseIterable, Sendable {
-    case gpt5Mini = "gpt-5.4-mini"
+    case gpt56Luna = "gpt-5.6-luna"
     case claudeHaiku45 = "claude-haiku-4-5"
     case custom = "custom"
 
@@ -15,7 +15,7 @@ enum EditModeModel: String, Codable, CaseIterable, Sendable {
     var backend: EditModeBackend {
         switch self {
         case .claudeHaiku45: return .claudeCli
-        case .gpt5Mini: return .codexCli
+        case .gpt56Luna: return .codexCli
         case .custom: return .customApi
         }
     }
@@ -25,7 +25,7 @@ enum EditModeModel: String, Codable, CaseIterable, Sendable {
     var oauthProvider: String {
         switch self {
         case .claudeHaiku45: return "anthropic"
-        case .gpt5Mini: return "openai-codex"
+        case .gpt56Luna: return "openai-codex"
         case .custom: return ""
         }
     }
@@ -38,7 +38,7 @@ enum EditModeModel: String, Codable, CaseIterable, Sendable {
     var reasoningEffort: String? {
         switch self {
         case .claudeHaiku45: return nil
-        case .gpt5Mini: return "none"
+        case .gpt56Luna: return "none"
         case .custom: return nil
         }
     }
diff --git a/Sources/MiniWhisper/Services/ParakeetProvider.swift b/Sources/MiniWhisper/Services/ParakeetProvider.swift
index 33c4e73..6a79860 100644
--- a/Sources/MiniWhisper/Services/ParakeetProvider.swift
+++ b/Sources/MiniWhisper/Services/ParakeetProvider.swift
@@ -30,7 +30,7 @@ final class ParakeetProvider {
                 }
             )
             let manager = AsrManager(config: .default)
-            try await manager.initialize(models: models)
+            try await manager.loadModels(models)
             asrManager = manager
         }
         initializationTask = task
@@ -54,7 +54,9 @@ final class ParakeetProvider {
 
         let startTime = Date()
 
-        let result = try await manager.transcribe(audioURL, source: .microphone)
+        // Reusing state leaks token context from the previous recording.
+        var decoderState = try TdtDecoderState()
+        let result = try await manager.transcribe(audioURL, decoderState: &decoderState)
         let processingTime = Date().timeIntervalSince(startTime)
 
         let segments = convertToSegments(result)
@@ -68,7 +70,7 @@ final class ParakeetProvider {
         )
     }
 
-    nonisolated private static func mapProgress(_ progress: DownloadUtils.DownloadProgress) -> ModelLoadProgress {
+    nonisolated private static func mapProgress(_ progress: DownloadProgress) -> ModelLoadProgress {
         switch progress.phase {
         case .listing:
             return ModelLoadProgress(phase: .checking, progress: nil)
diff --git a/Sources/MiniWhisper/Views/ModelPickerView.swift b/Sources/MiniWhisper/Views/ModelPickerView.swift
index 20fbf60..c702f09 100644
--- a/Sources/MiniWhisper/Views/ModelPickerView.swift
+++ b/Sources/MiniWhisper/Views/ModelPickerView.swift
@@ -105,11 +105,11 @@ struct ModelPickerView: View {
             ModelRow(
                 icon: "bolt.horizontal.fill",
                 title: "Codex CLI",
-                subtitle: "OpenAI · \(EditModeModel.gpt5Mini.rawValue)",
+                subtitle: "OpenAI · \(EditModeModel.gpt56Luna.rawValue)",
                 badge: nil,
-                isSelected: editModel == .gpt5Mini
+                isSelected: editModel == .gpt56Luna
             ) {
-                selectEditModel(.gpt5Mini)
+                selectEditModel(.gpt56Luna)
             }
 
             ModelRow(
diff --git a/Sources/MiniWhisperCLI/CLI.swift b/Sources/MiniWhisperCLI/CLI.swift
index c2a5a8a..98e8dc9 100644
--- a/Sources/MiniWhisperCLI/CLI.swift
+++ b/Sources/MiniWhisperCLI/CLI.swift
@@ -23,6 +23,8 @@ enum CLI {
             return 0
         case "transcribe":
             return await TranscribeCommand.run(arguments: rest)
+        case "diarize":
+            return await DiarizeCommand.run(arguments: rest)
         case "models":
             return await ModelsCommand.run(arguments: rest)
         case "paths":
@@ -96,6 +98,7 @@ enum Help {
 
             Common commands:
               transcribe <audio>       Transcribe audio with Parakeet or Whisper
+              diarize <audio>          Label who spoke when, as RTTM
               models status            Show local model readiness
               models install parakeet  Install the default Parakeet model
               models install whisper   Install the optional Whisper model
@@ -147,6 +150,7 @@ enum Help {
 
             Commands:
               transcribe <audio>                      Transcribe audio with Parakeet or Whisper
+              diarize <audio>                         Label who spoke when, as RTTM
               models                                  Show local model readiness
               models status [--json]                  Show local model readiness
               models install <parakeet|whisper>       Install or verify a model
@@ -199,6 +203,35 @@ enum Help {
         )
     }
 
+    static func printDiarize() {
+        Console.out(
+            """
+            MiniWhisper CLI
+
+            Usage:
+              miniwhispercli diarize <audio> [options]
+
+            Labels who spoke when and writes RTTM. Does not transcribe; join the
+            output against a transcript on timestamps.
+
+            Options:
+              -o, --output <path>       Write RTTM to a file instead of stdout
+              --speakers <n>            Expected speaker count (default: automatic)
+              --threshold <n>           Clustering threshold, 0.5-0.9. Lower finds more
+                                        speakers (default: 0.6). Ignored when
+                                        --speakers is set
+              --channel <mix|0|1>       Which channel to read. Two-source recordings put
+                                        one speaker per channel (default: mix)
+              -q, --quiet               Suppress progress on stderr
+              -h, --help                Show this help
+
+            Examples:
+              miniwhispercli diarize recording.wav
+              miniwhispercli diarize recording.wav --speakers 3 -o recording.rttm
+            """
+        )
+    }
+
     static func printTranscribe() {
         Console.out(
             """
diff --git a/Sources/MiniWhisperCLI/DiarizeCommand.swift b/Sources/MiniWhisperCLI/DiarizeCommand.swift
new file mode 100644
index 0000000..d6438c5
--- /dev/null
+++ b/Sources/MiniWhisperCLI/DiarizeCommand.swift
@@ -0,0 +1,168 @@
+import Foundation
+@preconcurrency import FluidAudio
+
+/// Speaker diarization: who spoke when, without transcribing.
+///
+/// Emits RTTM because that is the interchange format diarization tooling reads,
+/// and it joins cleanly against a separate transcript on timestamps.
+enum DiarizeCommand {
+    static func run(arguments: [String]) async -> Int32 {
+        do {
+            let options = try DiarizeOptions.parse(arguments)
+            if options.showHelp {
+                Help.printDiarize()
+                return 0
+            }
+            return try await execute(options)
+        } catch let error as CLIError {
+            Console.error(error.errorDescription ?? "Invalid arguments.")
+            return 2
+        } catch {
+            Console.error("Diarization failed: \(error.localizedDescription)")
+            return 1
+        }
+    }
+
+    private static func execute(_ options: DiarizeOptions) async throws -> Int32 {
+        let audioURL = PathResolver.fileURL(for: options.audioPath)
+        guard FileManager.default.fileExists(atPath: audioURL.path) else {
+            throw CLIError.runtime("Audio file not found: \(audioURL.path)")
+        }
+
+        let samples = try WhisperCLITranscriber.resampleTo16kHz(
+            audioURL: audioURL, channel: options.channel)
+        guard !samples.isEmpty else {
+            throw CLIError.runtime("Audio file decoded to zero samples: \(audioURL.path)")
+        }
+        let duration = Double(samples.count) / 16_000
+
+        // DiarizerManager ignores numSpeakers; OfflineDiarizerManager honours it.
+        var config = OfflineDiarizerConfig.default
+        if let threshold = options.clusteringThreshold {
+            config.clustering.threshold = Double(threshold)
+        }
+        if let speakers = options.numSpeakers {
+            config.clustering.numSpeakers = speakers
+        }
+
+        if !options.quiet {
+            Console.error("Loading diarizer models...")
+        }
+        let manager = OfflineDiarizerManager(config: config)
+        try await manager.prepareModels()
+
+        if !options.quiet {
+            let target = options.numSpeakers.map(String.init) ?? "auto"
+            Console.error(
+                "Diarizing \(audioURL.lastPathComponent) "
+                + "(\(String(format: "%.1f", duration))s, speakers: \(target))...")
+        }
+
+        let started = Date()
+        let result = try await manager.process(audio: samples)
+        let elapsed = Date().timeIntervalSince(started)
+
+        // RTTM identifies segments by recording id, not by path.
+        let recordingID = audioURL.deletingPathExtension().lastPathComponent
+        let rttm = renderRTTM(segments: result.segments, recordingID: recordingID)
+
+        if let output = options.outputPath {
+            try TextFileWriter.write(rttm, to: output)
+            if !options.quiet {
+                Console.error("Wrote \(result.segments.count) segments to \(output)")
+            }
+        } else {
+            Console.write(rttm)
+        }
+
+        if !options.quiet {
+            let speakers = Set(result.segments.map(\.speakerId)).count
+            let speech = result.segments.reduce(0.0) { $0 + Double($1.durationSeconds) }
+            Console.error(
+                "\(speakers) speakers, \(result.segments.count) segments, "
+                + "\(String(format: "%.1f", speech))s speech in "
+                + "\(String(format: "%.1f", elapsed))s "
+                + "(\(String(format: "%.0f", duration / max(elapsed, 0.001)))x realtime)")
+        }
+
+        return 0
+    }
+
+    /// NIST RTTM: ten space-separated fields, one SPEAKER line per segment.
+    /// Field 4 is onset and field 5 is duration, both in seconds — not an end time.
+    static func renderRTTM(segments: [TimedSpeakerSegment], recordingID: String) -> String {
+        var lines: [String] = []
+        for segment in segments.sorted(by: { $0.startTimeSeconds < $1.startTimeSeconds }) {
+            let start = String(format: "%.3f", segment.startTimeSeconds)
+            let duration = String(format: "%.3f", segment.durationSeconds)
+            lines.append(
+                "SPEAKER \(recordingID) 1 \(start) \(duration) <NA> <NA> \(segment.speakerId) <NA> <NA>")
+        }
+        return lines.joined(separator: "\n") + (lines.isEmpty ? "" : "\n")
+    }
+}
+
+struct DiarizeOptions {
+    var audioPath: String = ""
+    var outputPath: String?
+    var numSpeakers: Int?
+    var clusteringThreshold: Float?
+    var channel: AudioChannelSelection = .mix
+    var quiet: Bool = false
+    var showHelp: Bool = false
+
+    static func parse(_ arguments: [String]) throws -> DiarizeOptions {
+        var options = DiarizeOptions()
+        var index = 0
+
+        while index < arguments.count {
+            let argument = arguments[index]
+            switch argument {
+            case "-h", "--help":
+                options.showHelp = true
+                return options
+            case "-o", "--output":
+                index += 1
+                guard index < arguments.count else {
+                    throw CLIError.runtime("Missing value for \(argument).")
+                }
+                options.outputPath = arguments[index]
+            case "--speakers":
+                index += 1
+                guard index < arguments.count, let value = Int(arguments[index]), value > 0 else {
+                    throw CLIError.runtime("--speakers needs a positive integer.")
+                }
+                options.numSpeakers = value
+            case "--threshold":
+                index += 1
+                guard index < arguments.count, let value = Float(arguments[index]) else {
+                    throw CLIError.runtime("--threshold needs a number.")
+                }
+                options.clusteringThreshold = value
+            case "--channel":
+                index += 1
+                guard index < arguments.count,
+                      let channel = AudioChannelSelection.parse(arguments[index]) else {
+                    throw CLIError.runtime("--channel needs mix or a channel index like 0 or 1.")
+                }
+                options.channel = channel
+            case "-q", "--quiet":
+                options.quiet = true
+            default:
+                guard !argument.hasPrefix("-") else {
+                    throw CLIError.runtime("Unknown option: \(argument)")
+                }
+                guard options.audioPath.isEmpty else {
+                    throw CLIError.runtime("Unexpected extra argument: \(argument)")
+                }
+                options.audioPath = argument
+            }
+            index += 1
+        }
+
+        if options.audioPath.isEmpty && !options.showHelp {
+            throw CLIError.runtime("Missing audio file. Run `miniwhispercli diarize --help`.")
+        }
+        return options
+    }
+}
diff --git a/Sources/MiniWhisperCLI/SkillsCommand.swift b/Sources/MiniWhisperCLI/SkillsCommand.swift
index f92db21..67a5192 100644
--- a/Sources/MiniWhisperCLI/SkillsCommand.swift
+++ b/Sources/MiniWhisperCLI/SkillsCommand.swift
@@ -14,6 +14,10 @@ enum RuntimeSkills {
         RuntimeSkillInfo(
             name: "timestamps",
             description: "Timed transcripts, subtitles, captions, overlays, and edit-boundary timing"
+        ),
+        RuntimeSkillInfo(
+            name: "speakers",
+            description: "Speaker attribution: who spoke when, RTTM output, and per-channel splitting"
         )
     ]
 
@@ -25,6 +29,7 @@ enum RuntimeSkills {
         switch name {
         case "core": return CoreSkill.text
         case "timestamps": return TimestampsSkill.text
+        case "speakers": return SpeakersSkill.text
         default: return nil
         }
     }
@@ -47,6 +52,7 @@ enum CoreSkill {
         Start here:
           miniwhispercli skills get core
           miniwhispercli skills get timestamps  # for subtitles, captions, overlays, or edit timing
+          miniwhispercli skills get speakers    # for who spoke when, or speaker-labelled transcripts
           miniwhispercli skills list --json
 
         Version-matched guidance lives in the installed binary.
diff --git a/Sources/MiniWhisperCLI/SpeakersSkill.swift b/Sources/MiniWhisperCLI/SpeakersSkill.swift
new file mode 100644
index 0000000..f71b0a4
--- /dev/null
+++ b/Sources/MiniWhisperCLI/SpeakersSkill.swift
@@ -0,0 +1,96 @@
+import Foundation
+
+enum SpeakersSkill {
+    static let text =
+        """
+        ---
+        name: miniwhisper-speakers
+        description: Runtime guidance for MiniWhisper speaker attribution covering who spoke when, RTTM output, and per-channel splitting.
+        ---
+
+        # MiniWhisper Speakers
+
+        Load this when the request asks **who** spoke, not only what was said: speaker
+        labels, per-turn transcripts, or an RTTM file.
+
+        `diarize` does not transcribe. It labels time ranges. A speaker-labelled
+        transcript needs two runs joined on timestamps.
+
+        ## Choose the route first
+
+        Two recordings that sound the same need different commands.
+
+        - **One speaker per channel.** Some recordings capture each source on its own
+          channel. Transcribe each channel separately and tag by channel. Attribution
+          is exact by construction and no clustering is involved.
+          ```bash
+          miniwhispercli transcribe <audio> --channel 0 -o side-a.txt
+          miniwhispercli transcribe <audio> --channel 1 -o side-b.txt
+          ```
+        - **Shared microphone.** All speakers land in the same signal. Use `diarize`,
+          which clusters voices and can be wrong.
+          ```bash
+          miniwhispercli diarize <audio> -o speakers.rttm
+          ```
+
+        Default `--channel mix` averages all channels. Pass a channel index when
+        each channel holds an independent source.
+
+        If a channel holds more than one person, diarize that channel alone:
+        `miniwhispercli diarize <audio> --channel 1 --speakers 2`.
+
+        ## Speaker count
+
+        Run without `--speakers` first. Set it only when the count is known from the
+        recording, not guessed from the result.
+
+        If the automatic run and a fixed-count run disagree, the audio is genuinely
+        ambiguous. Report both answers. Do not force a count to make the output tidy.
+
+        `--threshold` applies only when `--speakers` is not set; a fixed count
+        overrides it. Lower values find more speakers. Stay inside 0.5-0.9.
+
+        ## Join to a transcript
+
+        ```bash
+        miniwhispercli transcribe <audio> --timestamps word --format json -o words.json
+        miniwhispercli diarize <audio> -o speakers.rttm
+        ```
+
+        `transcribe` defaults to Parakeet. Prefer it for the transcript you join
+        against: it needs no voice-activity detection, so it neither loops on silence
+        nor loses punctuation on long recordings.
+
+        `--model whisper` transcribes words more accurately but is a poor fit for long
+        audio here. Requesting word timestamps disables its VAD, and it then repeats
+        itself across silent stretches; leaving VAD on can strip punctuation and merge
+        many turns into one long segment. On short clips neither problem appears.
+
+        RTTM is one `SPEAKER` line per segment, ten space-separated fields. Field 4 is
+        the **onset** and field 5 is the **duration**, both in seconds. Field 5 is not
+        an end time; adding the two gives the end.
+
+        Assign one speaker per transcript segment by majority overlap.
+
+        ## Keep the timelines aligned
+
+        A clipped transcript and a full-file RTTM do not share a timeline. `--from`,
+        `--to` and `--duration` shift the transcript's clock but not the RTTM's.
+        Either transcribe the whole file, or clip the audio once and run both commands
+        against the clip.
+
+        ## Known limits
+
+        - Overlapping speech is not separated. Output segments do not overlap, so
+          simultaneous talk is attributed to one speaker.
+        - A single microphone with three or more people is the hardest case and shows
+          real bleed. Say so instead of presenting the output as exact.
+        - Report the route used (channel split or diarization), the speaker count, and
+          whether the count was automatic or fixed.
+
+        ## Output contract
+
+        RTTM goes to stdout, or to `-o <file>`. Progress, model loading, and the
+        summary line go to stderr. Do not parse stderr as data.
+        """
+}
diff --git a/Sources/MiniWhisperCLI/TranscribeCommand.swift b/Sources/MiniWhisperCLI/TranscribeCommand.swift
index 662e1c0..b666ac9 100644
--- a/Sources/MiniWhisperCLI/TranscribeCommand.swift
+++ b/Sources/MiniWhisperCLI/TranscribeCommand.swift
@@ -24,6 +24,7 @@ struct TranscribeOptions {
     var model: TranscribeModelChoice = .parakeet
     var source: SourceChoice = .microphone
     var sourceSpecified = false
+    var channel: AudioChannelSelection = .mix
     var whisperLanguage: WhisperLanguageChoice = .auto
     var whisperLanguageSpecified = false
     var whisperAlignmentMode: WhisperAlignmentMode = .none
@@ -142,6 +143,13 @@ enum TranscribeCommand {
                 }
                 options.source = source
                 options.sourceSpecified = true
+            case "--channel":
+                let value = try value(after: argument, in: arguments, at: &index)
+                guard let channel = AudioChannelSelection.parse(value) else {
+                    throw CLIError.usage(
+                        "Invalid channel: \(value). Expected mix or a channel index like 0 or 1.")
+                }
+                options.channel = channel
             case "--language":
                 let value = try value(after: argument, in: arguments, at: &index)
                 options.whisperLanguage = try WhisperLanguageChoice.parse(value)
@@ -343,23 +351,25 @@ enum TranscribeCommand {
         }
 
         let models = try await AsrModels.downloadAndLoad(version: ParakeetModel.version)
-        let manager = AsrManager(config: .default)
+        // Streaming is now a config flag, not a separate method.
+        let manager = AsrManager(config: ASRConfig(streamingEnabled: options.forceStreaming))
 
         do {
-            try await manager.initialize(models: models)
+            try await manager.loadModels(models)
 
             if !options.quiet {
                 let mode = options.forceStreaming ? "streaming" : "batch"
-                Console.error("Transcribing \(audioURL.path) (\(mode), model: parakeet, source: \(options.source.rawValue))...")
+                Console.error("Transcribing \(audioURL.path) (\(mode), model: parakeet, channel: \(options.channel.label))...")
             }
 
             let wallClockStart = Date()
-            let result: ASRResult
-            if options.forceStreaming {
-                result = try await manager.transcribeStreaming(audioURL, source: options.source.fluidAudioSource)
-            } else {
-                result = try await manager.transcribe(audioURL, source: options.source.fluidAudioSource)
-            }
+            // Reusing state leaks token context between files.
+            var decoderState = try TdtDecoderState()
+            // Samples, not the URL: the URL overload reads the file itself and would
+            // bypass channel selection.
+            let samples = try WhisperCLITranscriber.resampleTo16kHz(
+                audioURL: audioURL, channel: options.channel)
+            let result = try await manager.transcribe(samples, decoderState: &decoderState)
             let wallClockProcessingTime = Date().timeIntervalSince(wallClockStart)
             await manager.cleanup()
 
@@ -409,7 +419,8 @@ enum TranscribeCommand {
             audioURL: audioURL,
             language: options.whisperLanguage,
             alignmentMode: effectiveWhisperAlignmentMode(for: options),
-            quiet: options.quiet
+            quiet: options.quiet,
+            channel: options.channel
         )
         let jsonWordTimings = options.timestampMode == .word ? result.wordTimings : []
         let subtitleSegments = jsonWordTimings.isEmpty
diff --git a/Sources/MiniWhisperCLI/WhisperCLITranscriber.swift b/Sources/MiniWhisperCLI/WhisperCLITranscriber.swift
index d4157fd..58c6bfb 100644
--- a/Sources/MiniWhisperCLI/WhisperCLITranscriber.swift
+++ b/Sources/MiniWhisperCLI/WhisperCLITranscriber.swift
@@ -307,7 +307,8 @@ enum WhisperCLITranscriber {
         audioURL: URL,
         language: WhisperLanguageChoice,
         alignmentMode: WhisperAlignmentMode,
-        quiet: Bool
+        quiet: Bool,
+        channel: AudioChannelSelection = .mix
     ) async throws -> WhisperCLIResult {
         try await ensureModels(quiet: quiet)
 
@@ -329,7 +330,7 @@ enum WhisperCLITranscriber {
             Console.error("Transcribing \(audioURL.path) (batch, model: whisper, language: \(language.displayValue), align: \(alignment))...")
         }
 
-        let samples = try resampleTo16kHz(audioURL: audioURL)
+        let samples = try resampleTo16kHz(audioURL: audioURL, channel: channel)
         let audioDuration = AudioMetadata.durationSeconds(for: audioURL) ?? 0
         let start = Date()
         // VAD compacts audio before decode, and whisper.cpp token timestamps stay on that compacted timeline.
@@ -396,7 +397,12 @@ enum WhisperCLITranscriber {
         try FileManager.default.moveItem(at: temporaryURL, to: destination)
     }
 
-    private static func resampleTo16kHz(audioURL: URL) throws -> [Float] {
+    /// AVAudioConverter silently drops non-zero channels instead of downmixing,
+    /// so channels are folded to mono here before resampling.
+    static func resampleTo16kHz(
+        audioURL: URL,
+        channel: AudioChannelSelection = .mix
+    ) throws -> [Float] {
         let audioFile = try AVAudioFile(
             forReading: audioURL,
             commonFormat: .pcmFormatFloat32,
@@ -404,37 +410,86 @@ enum WhisperCLITranscriber {
         )
         let inputFormat = audioFile.processingFormat
 
-        guard let outputFormat = AVAudioFormat(
-            commonFormat: .pcmFormatFloat32,
-            sampleRate: 16_000,
-            channels: 1,
-            interleaved: false
-        ) else {
+        let frameCount = AVAudioFrameCount(audioFile.length)
+        guard frameCount > 0,
+              let inputBuffer = AVAudioPCMBuffer(pcmFormat: inputFormat, frameCapacity: frameCount) else {
             throw WhisperCLIError.resampleFailed
         }
+        try audioFile.read(into: inputBuffer)
 
-        let frameCount = AVAudioFrameCount(audioFile.length)
-        guard let inputBuffer = AVAudioPCMBuffer(pcmFormat: inputFormat, frameCapacity: frameCount) else {
+        let mono = try foldToMono(inputBuffer, channel: channel)
+
+        if inputFormat.sampleRate == 16_000 {
+            return mono
+        }
+        return try resampleMono(mono, from: inputFormat.sampleRate)
+    }
+
+    /// Collapse a multi-channel buffer to a single float array at the source rate.
+    private static func foldToMono(
+        _ buffer: AVAudioPCMBuffer,
+        channel: AudioChannelSelection
+    ) throws -> [Float] {
+        guard let data = buffer.floatChannelData else {
             throw WhisperCLIError.resampleFailed
         }
-        try audioFile.read(into: inputBuffer)
+        let frames = Int(buffer.frameLength)
+        let channels = Int(buffer.format.channelCount)
+
+        switch channel {
+        case .index(let requested):
+            guard requested < channels else {
+                throw WhisperCLIError.channelOutOfRange(requested: requested, available: channels)
+            }
+            return Array(UnsafeBufferPointer(start: data[requested], count: frames))
 
-        if inputFormat.sampleRate == 16_000 && inputFormat.channelCount == 1 {
-            let pointer = inputBuffer.floatChannelData![0]
-            return Array(UnsafeBufferPointer(start: pointer, count: Int(inputBuffer.frameLength)))
+        case .mix:
+            if channels == 1 {
+                return Array(UnsafeBufferPointer(start: data[0], count: frames))
+            }
+            // Average, not sum: summing two correlated channels clips.
+            var mixed = [Float](repeating: 0, count: frames)
+            let scale = 1 / Float(channels)
+            for channelIndex in 0..<channels {
+                let samples = data[channelIndex]
+                for frame in 0..<frames {
+                    mixed[frame] += samples[frame] * scale
+                }
+            }
+            return mixed
         }
+    }
 
-        guard let resampler = AVAudioConverter(from: inputFormat, to: outputFormat) else {
+    private static func resampleMono(_ samples: [Float], from sourceRate: Double) throws -> [Float] {
+        guard let sourceFormat = AVAudioFormat(
+            commonFormat: .pcmFormatFloat32, sampleRate: sourceRate, channels: 1, interleaved: false
+        ), let targetFormat = AVAudioFormat(
+            commonFormat: .pcmFormatFloat32, sampleRate: 16_000, channels: 1, interleaved: false
+        ) else {
+            throw WhisperCLIError.resampleFailed
+        }
+
+        guard let sourceBuffer = AVAudioPCMBuffer(
+            pcmFormat: sourceFormat, frameCapacity: AVAudioFrameCount(samples.count)
+        ) else {
+            throw WhisperCLIError.resampleFailed
+        }
+        sourceBuffer.frameLength = AVAudioFrameCount(samples.count)
+        samples.withUnsafeBufferPointer { source in
+            sourceBuffer.floatChannelData![0].update(from: source.baseAddress!, count: samples.count)
+        }
+
+        guard let resampler = AVAudioConverter(from: sourceFormat, to: targetFormat) else {
             throw WhisperCLIError.resampleFailed
         }
 
-        let ratio = outputFormat.sampleRate / inputFormat.sampleRate
-        let outputFrameCount = AVAudioFrameCount((Double(inputBuffer.frameLength) * ratio).rounded(.up)) + 1024
-        guard let outputBuffer = AVAudioPCMBuffer(pcmFormat: outputFormat, frameCapacity: outputFrameCount) else {
+        let ratio = 16_000 / sourceRate
+        let capacity = AVAudioFrameCount((Double(samples.count) * ratio).rounded(.up)) + 1024
+        guard let outputBuffer = AVAudioPCMBuffer(pcmFormat: targetFormat, frameCapacity: capacity) else {
             throw WhisperCLIError.resampleFailed
         }
 
-        let inputState = CLIWhisperInputState(buffer: inputBuffer)
+        let inputState = CLIWhisperInputState(buffer: sourceBuffer)
         var error: NSError?
         resampler.convert(to: outputBuffer, error: &error) { _, outStatus in
             if inputState.consumed {
@@ -466,6 +521,7 @@ enum WhisperCLIError: LocalizedError {
     case transcriptionFailed
     case downloadFailed
     case resampleFailed
+    case channelOutOfRange(requested: Int, available: Int)
 
     var errorDescription: String? {
         switch self {
@@ -473,6 +529,28 @@ enum WhisperCLIError: LocalizedError {
         case .transcriptionFailed: return "Whisper transcription failed."
         case .downloadFailed: return "Failed to download Whisper model."
         case .resampleFailed: return "Failed to resample audio for Whisper."
+        case .channelOutOfRange(let requested, let available):
+            let plural = available == 1 ? "channel" : "channels"
+            return "Channel \(requested) requested but the file has \(available) \(plural) (0-\(available - 1))."
+        }
+    }
+}
+
+/// Which channels of a multi-channel file feed transcription.
+enum AudioChannelSelection: Equatable {
+    case mix
+    case index(Int)
+
+    static func parse(_ value: String) -> AudioChannelSelection? {
+        if value == "mix" { return .mix }
+        guard let index = Int(value), index >= 0 else { return nil }
+        return .index(index)
+    }
+
+    var label: String {
+        switch self {
+        case .mix: return "mix"
+        case .index(let index): return String(index)
         }
     }
 }