feat(app): merge consecutive same-speaker transcript segments into blocks

Instead of emitting a separate line for each sentence-level segment,
consecutive segments from the same speaker are now merged into a single
block with combined text and spanning timestamps. This produces cleaner
transcripts for protocol generation.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

Author: 2 people

app/MeetingTranscriber/Sources/DiarizationProcess.swift

@@ -129,6 +129,32 @@ enum DiarizationProcess {
         )
     }
 
+    /// Merge consecutive segments from the same speaker into single blocks.
+    /// Preserves the start timestamp of the first segment and end timestamp of the last.
+    /// Text is joined with spaces.
+    static func mergeConsecutiveSpeakers(
+        _ segments: [TimestampedSegment],
+    ) -> [TimestampedSegment] {
+        guard var current = segments.first else { return [] }
+
+        var merged: [TimestampedSegment] = []
+        for seg in segments.dropFirst() {
+            if seg.speaker == current.speaker {
+                current = TimestampedSegment(
+                    start: current.start,
+                    end: seg.end,
+                    text: "\(current.text) \(seg.text)",
+                    speaker: current.speaker,
+                )
+            } else {
+                merged.append(current)
+                current = seg
+            }
+        }
+        merged.append(current)
+        return merged
+    }
+
     /// Assign speakers using separate diarizations for app and mic tracks.
     /// App segments are matched against appDiarization, mic segments against micDiarization.
     static func assignSpeakersDualTrack(

app/MeetingTranscriber/Sources/PipelineQueue.swift

@@ -184,6 +184,12 @@ class PipelineQueue {
         }
     }
 
+    func addWarning(id: UUID, _ message: String) {
+        guard let index = jobs.firstIndex(where: { $0.id == id }) else { return }
+        guard !jobs[index].warnings.contains(message) else { return }
+        jobs[index].warnings.append(message)
+    }
+
     /// Reset the elapsed timer for a new pipeline stage.
     private func startElapsedTimer() {
         elapsedTimer?.cancel()
@@ -450,7 +456,8 @@ class PipelineQueue {
                                 appDiarization: namedAppDiar,
                                 micDiarization: namedMicDiar,
                             )
-                            finalTranscript = labeled.map(\.formattedLine).joined(separator: "\n")
+                            let merged = DiarizationProcess.mergeConsecutiveSpeakers(labeled)
+                            finalTranscript = merged.map(\.formattedLine).joined(separator: "\n")
                         } else if let currentDiarization = diarization {
                             // Single-source: standard assignment
                             let namedDiarization = DiarizationResult(
@@ -468,12 +475,14 @@ class PipelineQueue {
                                 transcript: segments,
                                 diarization: namedDiarization,
                             )
-                            finalTranscript = labeled.map(\.formattedLine).joined(separator: "\n")
+                            let merged = DiarizationProcess.mergeConsecutiveSpeakers(labeled)
+                            finalTranscript = merged.map(\.formattedLine).joined(separator: "\n")
                         }
                         let segCount = diarization?.segments.count ?? 0
                         logger.info("Diarization complete: \(segCount) segments")
                     } catch {
                         logger.warning("Diarization failed, using undiarized transcript: \(error.localizedDescription)")
+                        addWarning(id: jobID, "Diarization failed — speakers not identified")
                         // Continue with original transcript
                     }
                 } else {
@@ -515,6 +524,12 @@ class PipelineQueue {
             }
             stopElapsedTimer()
             updateJobState(id: jobID, to: .done)
+            if let job = jobs.first(where: { $0.id == jobID }), !job.warnings.isEmpty {
+                NotificationManager.shared.notify(
+                    title: "Protocol Ready (with warnings)",
+                    body: job.warnings.joined(separator: "; "),
+                )
+            }
         } catch is CancellationError {
             stopElapsedTimer()
             logger.info("Job \(jobID) cancelled")

app/MeetingTranscriber/Tests/DiarizationProcessTests.swift

@@ -284,6 +284,71 @@ final class DiarizationProcessTests: XCTestCase {
         XCTAssertNil(merged.embeddings)
     }
 
+    // MARK: - Merge Consecutive Speakers
+
+    func testMergeConsecutiveSpeakers() {
+        let segments = [
+            TimestampedSegment(start: 0, end: 5, text: "Hello there.", speaker: "Alice"),
+            TimestampedSegment(start: 5, end: 10, text: "How are you?", speaker: "Alice"),
+            TimestampedSegment(start: 10, end: 15, text: "I'm fine.", speaker: "Bob"),
+            TimestampedSegment(start: 15, end: 20, text: "Thanks.", speaker: "Bob"),
+            TimestampedSegment(start: 20, end: 25, text: "Great!", speaker: "Alice"),
+        ]
+
+        let merged = DiarizationProcess.mergeConsecutiveSpeakers(segments)
+
+        XCTAssertEqual(merged.count, 3)
+        XCTAssertEqual(merged[0].speaker, "Alice")
+        XCTAssertEqual(merged[0].text, "Hello there. How are you?")
+        XCTAssertEqual(merged[0].start, 0)
+        XCTAssertEqual(merged[0].end, 10)
+        XCTAssertEqual(merged[1].speaker, "Bob")
+        XCTAssertEqual(merged[1].text, "I'm fine. Thanks.")
+        XCTAssertEqual(merged[1].start, 10)
+        XCTAssertEqual(merged[1].end, 20)
+        XCTAssertEqual(merged[2].speaker, "Alice")
+        XCTAssertEqual(merged[2].text, "Great!")
+        XCTAssertEqual(merged[2].start, 20)
+        XCTAssertEqual(merged[2].end, 25)
+    }
+
+    func testMergeConsecutiveSpeakers_empty() {
+        let merged = DiarizationProcess.mergeConsecutiveSpeakers([])
+        XCTAssertTrue(merged.isEmpty)
+    }
+
+    func testMergeConsecutiveSpeakers_singleSegment() {
+        let segments = [
+            TimestampedSegment(start: 0, end: 5, text: "Hello", speaker: "Alice"),
+        ]
+        let merged = DiarizationProcess.mergeConsecutiveSpeakers(segments)
+        XCTAssertEqual(merged.count, 1)
+        XCTAssertEqual(merged[0].text, "Hello")
+    }
+
+    func testMergeConsecutiveSpeakers_allSameSpeaker() {
+        let segments = [
+            TimestampedSegment(start: 0, end: 5, text: "One.", speaker: "Alice"),
+            TimestampedSegment(start: 5, end: 10, text: "Two.", speaker: "Alice"),
+            TimestampedSegment(start: 10, end: 15, text: "Three.", speaker: "Alice"),
+        ]
+        let merged = DiarizationProcess.mergeConsecutiveSpeakers(segments)
+        XCTAssertEqual(merged.count, 1)
+        XCTAssertEqual(merged[0].text, "One. Two. Three.")
+        XCTAssertEqual(merged[0].start, 0)
+        XCTAssertEqual(merged[0].end, 15)
+    }
+
+    func testMergeConsecutiveSpeakers_allDifferent() {
+        let segments = [
+            TimestampedSegment(start: 0, end: 5, text: "A", speaker: "Alice"),
+            TimestampedSegment(start: 5, end: 10, text: "B", speaker: "Bob"),
+            TimestampedSegment(start: 10, end: 15, text: "C", speaker: "Carol"),
+        ]
+        let merged = DiarizationProcess.mergeConsecutiveSpeakers(segments)
+        XCTAssertEqual(merged.count, 3)
+    }
+
     func testDiarizationErrorDescription() {
         let error: DiarizationError = .notAvailable
         XCTAssertEqual(error.errorDescription, "Diarization not available")