Skip to content

Fastest and only macOS Dictation app with on-device STT and custom trained AI enhancement model. Windows, iOS testflight! Android, Linux waitlist open! A local Wispr Flow alternative. Follow https://x.com/fluidvoiceapp for more

fix(meeting): keep speaker labels through silent turns, flag speaker-bleed echoes

Shreeraman A K73a89caa75b7
diff --git a/Sources/Fluid/Services/Meeting/MeetingEchoDetector.swift b/Sources/Fluid/Services/Meeting/MeetingEchoDetector.swift
new file mode 100644
index 00000000..165fdaff
--- /dev/null
+++ b/Sources/Fluid/Services/Meeting/MeetingEchoDetector.swift
@@ -0,0 +1,41 @@
+import Foundation
+
+/// Flags a microphone turn as remote audio picked up through speaker bleed.
+nonisolated enum MeetingEchoDetector {
+ static let minimumMicWords = 4
+ static let minimumMatchedContentWords = 2
+ static let containmentThreshold = 0.75
+
+ private static let stopwords: Set<String> = [
+ "the", "a", "an", "and", "or", "but", "so", "to", "of", "in", "on", "it", "is",
+ "was", "i", "you", "we", "they", "that", "this", "like", "just", "know", "yeah",
+ "ok", "okay", "right", "mean", "my", "me",
+ ]
+
+ static func normalizedWords(_ text: String) -> [String] {
+ text.lowercased()
+ .components(separatedBy: CharacterSet.alphanumerics.inverted)
+ .filter { !$0.isEmpty }
+ }
+
+ static func contentWords(_ text: String) -> Set<String> {
+ Set(self.normalizedWords(text).filter { !self.stopwords.contains($0) })
+ }
+
+ /// Containment, not Jaccard: Jaccard punishes echo's length mismatch (real pair scored 0.17).
+ static func containment(micText: String, remoteText: String) -> Double {
+ let micWords = self.contentWords(micText)
+ guard !micWords.isEmpty else { return 0 }
+ let remoteWords = self.contentWords(remoteText)
+ guard !remoteWords.isEmpty else { return 0 }
+ return Double(micWords.intersection(remoteWords).count) / Double(micWords.count)
+ }
+
+ static func isLikelyEcho(micText: String, remoteText: String) -> Bool {
+ let micWords = Set(self.normalizedWords(micText))
+ guard micWords.count >= self.minimumMicWords else { return false }
+ let matchedContentWords = self.contentWords(micText).intersection(self.contentWords(remoteText)).count
+ guard matchedContentWords >= self.minimumMatchedContentWords else { return false }
+ return self.containment(micText: micText, remoteText: remoteText) >= self.containmentThreshold
+ }
+}
diff --git a/Sources/Fluid/Services/Meeting/MeetingModels.swift b/Sources/Fluid/Services/Meeting/MeetingModels.swift
index df30634b..19b051b2 100644
--- a/Sources/Fluid/Services/Meeting/MeetingModels.swift
+++ b/Sources/Fluid/Services/Meeting/MeetingModels.swift
@@ -367,6 +367,10 @@ nonisolated struct MeetingTranscriptSegment: Codable, Identifiable, Equatable, S
var status: MeetingTranscriptStatus
var overlap: MeetingTranscriptOverlap
var completeness: MeetingTranscriptCompleteness
+ /// Optional so pre-fix manifests still decode; a non-optional default would `keyNotFound`.
+ var isLikelyEcho: Bool? = nil
+
+ var isEcho: Bool { self.isLikelyEcho == true }
}
nonisolated struct MeetingProcessingAttempt: Codable, Identifiable, Equatable, Sendable {
diff --git a/Sources/Fluid/Services/Meeting/MeetingProcessingPipeline.swift b/Sources/Fluid/Services/Meeting/MeetingProcessingPipeline.swift
index 2b3452d0..73aedc33 100644
--- a/Sources/Fluid/Services/Meeting/MeetingProcessingPipeline.swift
+++ b/Sources/Fluid/Services/Meeting/MeetingProcessingPipeline.swift
@@ -177,6 +177,16 @@ nonisolated struct MeetingSpeakerEmbeddingIndex: Sendable {
}
}
+nonisolated enum MeetingTurnSelection {
+ /// Drops empty-text turns; nil when all were empty (caller falls back to whole-chunk).
+ static func keepingNonEmpty<T>(
+ _ turns: [(index: Int, turn: T, text: String)]
+ ) -> [(index: Int, turn: T, text: String)]? {
+ let nonEmpty = turns.filter { !$0.text.isEmpty }
+ return nonEmpty.isEmpty ? nil : nonEmpty
+ }
+}
+
nonisolated enum MeetingLocalSpeakerEvidenceSelector {
static func candidate(
cleanDurationByCluster: [SessionSpeakerID: TimeInterval],
@@ -268,7 +278,9 @@ private final class MeetingProviderLanguagePin {
@MainActor
final class MeetingProcessingPipeline: MeetingProcessingControlling {
- static let pipelineVersion = 1
+ static let pipelineVersion = 2
+ /// Conversational pauses run to a few seconds; 1.0s fragmented turns and starved the ASR.
+ static let meetingTurnMergeGapSeconds = 3.0
private enum LabeledPassError: Error {
case emptyTurn
@@ -288,6 +300,7 @@ final class MeetingProcessingPipeline: MeetingProcessingControlling {
var end: TimeInterval
var text: String
var overlapsRemote: Bool
+ var isLikelyEcho = false
}
private struct Accumulator {
@@ -663,16 +676,10 @@ final class MeetingProcessingPipeline: MeetingProcessingControlling {
}.value
if SpeakerDiarizationService.isSupported {
do {
- let diarization = try await diarizer.diarizeWithProfiles(fileURL: url)
+ let diarization = try await diarizer.diarizeWithProfiles(fileURL: url, maxGapSeconds: Self.meetingTurnMergeGapSeconds)
let turns = diarization.turns
if !turns.isEmpty {
- remoteSpeech.append(contentsOf: turns.map { turn in
- TimelineInterval(
- start: chunkOffset + turn.startSeconds,
- end: chunkOffset + turn.endSeconds
- )
- })
- var transcribedTurns: [(Int, SpeakerDiarizationService.SpeakerTurn, String)] = []
+ var allTurns: [(index: Int, turn: SpeakerDiarizationService.SpeakerTurn, text: String)] = []
for (index, turn) in turns.enumerated() {
let text = try await self.transcribeTurn(
turn,
@@ -682,9 +689,24 @@ final class MeetingProcessingPipeline: MeetingProcessingControlling {
asrService: context.asrService,
languagePin: context.languagePin
)
- guard !text.isEmpty else { throw LabeledPassError.emptyTurn }
- transcribedTurns.append((index, turn, text))
+ allTurns.append((index, turn, text))
+ }
+ guard let transcribedTurns = MeetingTurnSelection.keepingNonEmpty(allTurns) else {
+ throw LabeledPassError.emptyTurn
+ }
+ if transcribedTurns.count < allTurns.count {
+ DebugLogger.shared.log(
+ "Meeting remote transcription chunk \(chunk.id): skipped \(allTurns.count - transcribedTurns.count) of \(allTurns.count) silent turns",
+ source: "MeetingProcessingPipeline"
+ )
}
+ // Filtered turns only: a silent turn must not mark a mic turn overlapsRemote.
+ remoteSpeech.append(contentsOf: transcribedTurns.map { _, turn, _ in
+ TimelineInterval(
+ start: chunkOffset + turn.startSeconds,
+ end: chunkOffset + turn.endSeconds
+ )
+ })
var speakerIDByLabel: [String: SessionSpeakerID] = [:]
var usedSpeakerIDs = Set<SessionSpeakerID>()
for (_, turn, _) in transcribedTurns where speakerIDByLabel[turn.speakerLabel] == nil {
@@ -732,7 +754,7 @@ final class MeetingProcessingPipeline: MeetingProcessingControlling {
if error is CancellationError { throw error }
if case MeetingProcessingError.audioUnreadable = error { throw error }
DebugLogger.shared.warning(
- "Meeting remote diarization failed; preserving an unlabeled track transcript",
+ "Meeting remote diarization failed; preserving an unlabeled track transcript: \(error)",
source: "MeetingProcessingPipeline"
)
}
@@ -827,10 +849,10 @@ final class MeetingProcessingPipeline: MeetingProcessingControlling {
}.value
if SpeakerDiarizationService.isSupported {
do {
- let diarization = try await diarizer.diarizeWithProfiles(fileURL: url)
+ let diarization = try await diarizer.diarizeWithProfiles(fileURL: url, maxGapSeconds: Self.meetingTurnMergeGapSeconds)
let turns = diarization.turns
if !turns.isEmpty {
- var transcribedTurns: [(Int, SpeakerDiarizationService.SpeakerTurn, String)] = []
+ var allTurns: [(index: Int, turn: SpeakerDiarizationService.SpeakerTurn, text: String)] = []
for (index, turn) in turns.enumerated() {
let text = try await self.transcribeTurn(
turn,
@@ -840,8 +862,16 @@ final class MeetingProcessingPipeline: MeetingProcessingControlling {
asrService: context.asrService,
languagePin: context.languagePin
)
- guard !text.isEmpty else { throw LabeledPassError.emptyTurn }
- transcribedTurns.append((index, turn, text))
+ allTurns.append((index, turn, text))
+ }
+ guard let transcribedTurns = MeetingTurnSelection.keepingNonEmpty(allTurns) else {
+ throw LabeledPassError.emptyTurn
+ }
+ if transcribedTurns.count < allTurns.count {
+ DebugLogger.shared.log(
+ "Meeting microphone transcription chunk \(chunk.id): skipped \(allTurns.count - transcribedTurns.count) of \(allTurns.count) silent turns",
+ source: "MeetingProcessingPipeline"
+ )
}
var clusterIDByLabel: [String: SessionSpeakerID] = [:]
var usedClusterIDs = Set<SessionSpeakerID>()
@@ -882,7 +912,7 @@ final class MeetingProcessingPipeline: MeetingProcessingControlling {
if error is CancellationError { throw error }
if case MeetingProcessingError.audioUnreadable = error { throw error }
DebugLogger.shared.warning(
- "Meeting microphone speech detection failed; preserving an unlabeled track transcript",
+ "Meeting microphone speech detection failed; preserving an unlabeled track transcript: \(error)",
source: "MeetingProcessingPipeline"
)
}
@@ -983,7 +1013,27 @@ final class MeetingProcessingPipeline: MeetingProcessingControlling {
isLocalUser: false,
clusterID: nil
)
- for turn in stagedTurns {
+ let applicationTrackID = session.audioTracks.first(where: { $0.kind == .applicationAudio })?.id
+ // The 60s remote whole-chunk fallback is too coarse to score against; exclude its speaker.
+ let fallbackSpeakerID = accumulator.speakerIDByKey["meeting-audio"]
+ var classifiedTurns = stagedTurns
+ if let applicationTrackID {
+ for index in classifiedTurns.indices where classifiedTurns[index].overlapsRemote {
+ let turn = classifiedTurns[index]
+ guard turn.clusterID != localClusterID else { continue }
+ let remoteText = Self.echoCandidateText(
+ segments: accumulator.segments,
+ speakerIDToExclude: fallbackSpeakerID,
+ applicationTrackID: applicationTrackID,
+ window: (turn.start, turn.end)
+ )
+ classifiedTurns[index].isLikelyEcho = MeetingEchoDetector.isLikelyEcho(
+ micText: turn.text,
+ remoteText: remoteText
+ )
+ }
+ }
+ for turn in classifiedTurns {
let isCleanLocalTurn = turn.clusterID == localClusterID && !turn.overlapsRemote
accumulator.segments.append(Self.segment(
key: "microphone:\(turn.chunkID.uuidString):\(turn.index)",
@@ -992,7 +1042,8 @@ final class MeetingProcessingPipeline: MeetingProcessingControlling {
start: turn.start,
end: turn.end,
text: turn.text,
- overlap: turn.overlapsRemote ? .overlapsOtherTrack : .none
+ overlap: turn.overlapsRemote ? .overlapsOtherTrack : .none,
+ isLikelyEcho: turn.isLikelyEcho
))
}
}
@@ -1114,6 +1165,23 @@ final class MeetingProcessingPipeline: MeetingProcessingControlling {
return Double(file.length) / file.processingFormat.sampleRate
}
+ /// Overlapping application-track text, minus the coarse whole-chunk fallback speaker.
+ nonisolated static func echoCandidateText(
+ segments: [MeetingTranscriptSegment],
+ speakerIDToExclude: SessionSpeakerID?,
+ applicationTrackID: MeetingAudioTrackID,
+ window: (start: TimeInterval, end: TimeInterval)
+ ) -> String {
+ segments
+ .filter { segment in
+ segment.sourceTrackID == applicationTrackID
+ && (speakerIDToExclude == nil || segment.speakerID != speakerIDToExclude)
+ && min(window.end, segment.end.seconds) - max(window.start, segment.start.seconds) > 0.15
+ }
+ .map(\.text)
+ .joined(separator: " ")
+ }
+
private static func segment(
key: String,
trackID: MeetingAudioTrackID,
@@ -1121,7 +1189,8 @@ final class MeetingProcessingPipeline: MeetingProcessingControlling {
start: TimeInterval,
end: TimeInterval,
text: String,
- overlap: MeetingTranscriptOverlap
+ overlap: MeetingTranscriptOverlap,
+ isLikelyEcho: Bool = false
) -> MeetingTranscriptSegment {
MeetingTranscriptSegment(
id: self.stableUUID("segment:\(key)"),
@@ -1133,7 +1202,8 @@ final class MeetingProcessingPipeline: MeetingProcessingControlling {
revision: 0,
status: .final,
overlap: overlap,
- completeness: .complete
+ completeness: .complete,
+ isLikelyEcho: isLikelyEcho
)
}
diff --git a/Sources/Fluid/Services/Meeting/MeetingTranscriptExporter.swift b/Sources/Fluid/Services/Meeting/MeetingTranscriptExporter.swift
index e1f3ac9c..669a8ac9 100644
--- a/Sources/Fluid/Services/Meeting/MeetingTranscriptExporter.swift
+++ b/Sources/Fluid/Services/Meeting/MeetingTranscriptExporter.swift
@@ -2,9 +2,11 @@ import Foundation
/// Single source of truth for rendering a `MeetingSession` transcript as plain text or JSON.
nonisolated enum MeetingTranscriptExporter {
- static func text(for session: MeetingSession) -> String {
+ static func text(for session: MeetingSession, includeEchoes: Bool = false) -> String {
let speakerNames = Dictionary(uniqueKeysWithValues: session.activeSpeakers.map { ($0.id, $0.displayName) })
- let segments = session.transcriptSegments.sorted { $0.start.seconds < $1.start.seconds }
+ let segments = session.transcriptSegments
+ .filter { includeEchoes || !$0.isEcho }
+ .sorted { $0.start.seconds < $1.start.seconds }
return segments.map { segment in
let speaker = Self.resolvedSpeakerName(segment.speakerID, in: session, speakerNames: speakerNames)
return "[\(Self.timestampText(segment.start.seconds))] \(speaker): \(segment.text)"
@@ -32,7 +34,8 @@ nonisolated enum MeetingTranscriptExporter {
revision: $0.revision,
status: $0.status.rawValue,
overlap: $0.overlap.rawValue,
- completeness: $0.completeness.rawValue
+ completeness: $0.completeness.rawValue,
+ isLikelyEcho: $0.isEcho
)
}
let document = ExportedTranscript(
@@ -115,6 +118,7 @@ private struct ExportedSegment: Codable {
var status: String
var overlap: String
var completeness: String
+ var isLikelyEcho: Bool
}
private struct ExportedTranscript: Codable {
diff --git a/Sources/Fluid/Services/SpeakerDiarizationService.swift b/Sources/Fluid/Services/SpeakerDiarizationService.swift
index 78694ec0..29379305 100644
--- a/Sources/Fluid/Services/SpeakerDiarizationService.swift
+++ b/Sources/Fluid/Services/SpeakerDiarizationService.swift
@@ -51,7 +51,8 @@ actor SpeakerDiarizationService {
/// Includes one bounded centroid per local cluster so callers can stitch the
/// same voice across independently processed files without retaining audio.
- func diarizeWithProfiles(fileURL: URL) async throws -> DiarizationOutput {
+ /// - Parameter maxGapSeconds: file transcription keeps the 1.0s default; meetings pass wider.
+ func diarizeWithProfiles(fileURL: URL, maxGapSeconds: Double = 1.0) async throws -> DiarizationOutput {
if !self.modelsReady {
await MainActor.run {
DebugLogger.shared.info(
@@ -110,7 +111,7 @@ actor SpeakerDiarizationService {
}
return DiarizationOutput(
- turns: Self.mergeAdjacentTurns(turns),
+ turns: Self.mergeAdjacentTurns(turns, maxGapSeconds: maxGapSeconds),
profilesByLabel: profilesByLabel
)
}
@@ -186,7 +187,7 @@ actor SpeakerDiarizationService {
try await self.diarizeWithProfiles(fileURL: fileURL).turns
}
- func diarizeWithProfiles(fileURL: URL) async throws -> DiarizationOutput {
+ func diarizeWithProfiles(fileURL: URL, maxGapSeconds: Double = 1.0) async throws -> DiarizationOutput {
throw NSError(
domain: "SpeakerDiarizationService",
code: -1,
diff --git a/Sources/Fluid/UI/MeetingTranscriptionView.swift b/Sources/Fluid/UI/MeetingTranscriptionView.swift
index e12bc585..15e13b7f 100644
--- a/Sources/Fluid/UI/MeetingTranscriptionView.swift
+++ b/Sources/Fluid/UI/MeetingTranscriptionView.swift
@@ -181,7 +181,7 @@ struct MeetingTranscriptionView: View {
onRetry: { self.retryProcessingSession(id: $0) },
onRevealAudio: self.revealCapturedAudio,
onExportAudio: self.exportAudio,
- onExportTranscript: self.exportTranscript,
+ onExportTranscript: { self.exportTranscript($0, format: $1, includeEchoes: false) },
onDeleteAudioRequest: { self.pendingDeleteAudioSessionID = $0 },
onDeleteRequest: { self.pendingDeleteSessionID = $0 }
)
@@ -920,14 +920,14 @@ struct MeetingTranscriptionView: View {
self.isShowingMeetingSettings = false
}
- private func copyTranscript(_ session: MeetingSession) {
- let text = MeetingTranscriptExporter.text(for: session)
+ private func copyTranscript(_ session: MeetingSession, includeEchoes: Bool) {
+ let text = MeetingTranscriptExporter.text(for: session, includeEchoes: includeEchoes)
guard !text.isEmpty else { return }
NSPasteboard.general.clearContents()
NSPasteboard.general.setString(text, forType: .string)
}
- private func exportTranscript(_ session: MeetingSession, format: MeetingTranscriptExportFormat) {
+ private func exportTranscript(_ session: MeetingSession, format: MeetingTranscriptExportFormat, includeEchoes: Bool) {
let panel = NSSavePanel()
panel.nameFieldStringValue = "\(Self.sanitizedExportName(session.title)).\(format.fileExtension)"
panel.message = "Exported transcripts are outside FluidVoice's retention controls and may be indexed or synced by other apps."
@@ -936,7 +936,7 @@ struct MeetingTranscriptionView: View {
do {
let data: Data
switch format {
- case .text: data = Data(MeetingTranscriptExporter.text(for: session).utf8)
+ case .text: data = Data(MeetingTranscriptExporter.text(for: session, includeEchoes: includeEchoes).utf8)
case .json: data = try MeetingTranscriptExporter.json(for: session)
}
try data.write(to: url, options: .atomic)
@@ -1037,8 +1037,8 @@ struct MeetingTranscriptionCanvas: View {
let onRetrySession: (MeetingSession) -> Void
let onRevealAudio: (MeetingSession) -> Void
let onRecordAgain: (MeetingSession) -> Void
- let onCopyTranscript: (MeetingSession) -> Void
- let onExportTranscript: (MeetingSession, MeetingTranscriptExportFormat) -> Void
+ let onCopyTranscript: (MeetingSession, Bool) -> Void
+ let onExportTranscript: (MeetingSession, MeetingTranscriptExportFormat, Bool) -> Void
let onReassignSegment: (MeetingSessionID, MeetingTranscriptSegmentID, SessionSpeakerID) -> Void
let onRenameSpeaker: (MeetingSessionID, SessionSpeakerID, String) -> Void
let onMergeSpeakers: (MeetingSessionID, SessionSpeakerID, SessionSpeakerID) -> Void
@@ -1315,7 +1315,7 @@ private struct MeetingHistoryInspector: View {
Button("Export Transcript (Text)…", systemImage: "doc.text") {
self.onExportTranscript(session, .text)
}
- .disabled(session.transcriptSegments.isEmpty)
+ .disabled(!session.transcriptSegments.contains(where: { !$0.isEcho }))
Button("Export Transcript (JSON)…", systemImage: "curlybraces") {
self.onExportTranscript(session, .json)
}
@@ -2098,8 +2098,9 @@ private struct MeetingResultCanvas: View {
let session: MeetingSession
let isQuiescent: Bool
let canUndo: Bool
- let onCopyTranscript: (MeetingSession) -> Void
- let onExportTranscript: (MeetingSession, MeetingTranscriptExportFormat) -> Void
+ @State private var showsProbableEchoes = false
+ let onCopyTranscript: (MeetingSession, Bool) -> Void
+ let onExportTranscript: (MeetingSession, MeetingTranscriptExportFormat, Bool) -> Void
let onReassignSegment: (MeetingTranscriptSegmentID, SessionSpeakerID) -> Void
let onRenameSpeaker: (SessionSpeakerID, String) -> Void
let onMergeSpeakers: (SessionSpeakerID, SessionSpeakerID) -> Void
@@ -2113,23 +2114,42 @@ private struct MeetingResultCanvas: View {
Dictionary(uniqueKeysWithValues: self.session.activeSpeakers.map { ($0.id, $0.displayName) })
}
+ private var hasEchoSegments: Bool {
+ self.session.transcriptSegments.contains(where: \.isEcho)
+ }
+
+ /// Single projection so shown and copied never disagree.
+ private func visibleSegments(sorted: [MeetingTranscriptSegment]) -> [MeetingTranscriptSegment] {
+ self.showsProbableEchoes ? sorted : sorted.filter { !$0.isEcho }
+ }
+
/// Sorted once with per-row display state — no per-row re-sorting.
- private var rows: [(segment: MeetingTranscriptSegment, showsLabel: Bool, isLocal: Bool)] {
- let sorted = self.session.transcriptSegments.sorted { $0.start.seconds < $1.start.seconds }
- return sorted.enumerated().map { index, segment in
- let showsLabel = index == 0 || segment.speakerID != sorted[index - 1].speakerID
+ private func rows(
+ for visibleSegments: [MeetingTranscriptSegment]
+ ) -> [(segment: MeetingTranscriptSegment, showsLabel: Bool, isLocal: Bool)] {
+ visibleSegments.enumerated().map { index, segment in
+ let showsLabel = index == 0 || segment.speakerID != visibleSegments[index - 1].speakerID
return (segment, showsLabel, self.isLocalSegment(segment))
}
}
var body: some View {
let speakerNames = self.speakerNames
- let activeSpeakers = self.session.activeSpeakers
+ let sorted = self.session.transcriptSegments.sorted { $0.start.seconds < $1.start.seconds }
+ let visibleSegments = self.visibleSegments(sorted: sorted)
+ let visibleSpeakerIDs = Set(visibleSegments.compactMap(\.speakerID))
+ let activeSpeakers = self.session.activeSpeakers.filter { visibleSpeakerIDs.contains($0.id) }
+ let rows = self.rows(for: visibleSegments)
VStack(alignment: .leading, spacing: self.theme.metrics.spacing.xl) {
HStack(alignment: .firstTextBaseline) {
Text(self.session.title)
.font(self.theme.typography.title)
Spacer()
+ if self.hasEchoSegments {
+ Toggle("Show probable echo", isOn: self.$showsProbableEchoes)
+ .toggleStyle(.checkbox)
+ .font(self.theme.typography.caption)
+ }
Label(self.statusText, systemImage: self.statusIcon)
.font(self.theme.typography.badge)
.foregroundStyle(self.statusColor)
@@ -2164,7 +2184,7 @@ private struct MeetingResultCanvas: View {
}
}
- if self.session.transcriptSegments.isEmpty {
+ if visibleSegments.isEmpty {
ContentUnavailableView(
"No transcript text",
systemImage: "waveform.slash",
@@ -2173,7 +2193,7 @@ private struct MeetingResultCanvas: View {
.frame(maxWidth: .infinity, minHeight: 180)
} else {
VStack(alignment: .leading, spacing: 28) {
- ForEach(self.rows, id: \.segment.id) { row in
+ ForEach(rows, id: \.segment.id) { row in
MeetingTranscriptSegmentRow(
segment: row.segment,
speakerName: row.segment.speakerID.flatMap { speakerNames[$0] } ?? "Unknown speaker",
@@ -2192,17 +2212,17 @@ private struct MeetingResultCanvas: View {
HStack(spacing: self.theme.metrics.spacing.sm) {
Button("Copy Transcript", systemImage: "doc.on.doc") {
- self.onCopyTranscript(self.session)
+ self.onCopyTranscript(self.session, self.showsProbableEchoes)
}
.fluidButton(.compact, size: .medium)
- .disabled(self.session.transcriptSegments.isEmpty)
+ .disabled(visibleSegments.isEmpty)
Menu("Export Transcript", systemImage: "square.and.arrow.up") {
- Button("Text…") { self.onExportTranscript(self.session, .text) }
- Button("JSON…") { self.onExportTranscript(self.session, .json) }
+ Button("Text…") { self.onExportTranscript(self.session, .text, self.showsProbableEchoes) }
+ Button("JSON…") { self.onExportTranscript(self.session, .json, self.showsProbableEchoes) }
}
.fluidButton(.compact, size: .medium)
- .disabled(self.session.transcriptSegments.isEmpty)
+ .disabled(visibleSegments.isEmpty)
Button("Undo", systemImage: "arrow.uturn.backward") {
self.onUndo()
@@ -2230,6 +2250,8 @@ private struct MeetingResultCanvas: View {
} message: {
Text("Enter a new name for this speaker.")
}
+ // Prevents an echo toggle left on for one meeting from leaking into the next.
+ .onChange(of: self.session.id) { _, _ in self.showsProbableEchoes = false }
}
@ViewBuilder
@@ -2553,6 +2575,7 @@ private struct MeetingTranscriptSegmentRow: View {
self.remoteMessage
}
}
+ .opacity(self.segment.isEcho ? 0.6 : 1)
.contextMenu {
Menu("Reassign to") {
ForEach(self.reassignTargets) { target in
@@ -2587,6 +2610,11 @@ private struct MeetingTranscriptSegmentRow: View {
self.theme.palette.contentBackground,
in: RoundedRectangle(cornerRadius: 18, style: .continuous)
)
+ if self.segment.isEcho {
+ Text("probable echo")
+ .font(self.theme.typography.caption)
+ .foregroundStyle(self.theme.palette.tertiaryText)
+ }
}
.frame(maxWidth: .infinity, alignment: .trailing)
.padding(.leading, 96)
@@ -2604,6 +2632,11 @@ private struct MeetingTranscriptSegmentRow: View {
.lineSpacing(5)
.foregroundStyle(self.theme.palette.primaryText)
.textSelection(.enabled)
+ if self.segment.isEcho {
+ Text("probable echo")
+ .font(self.theme.typography.caption)
+ .foregroundStyle(self.theme.palette.tertiaryText)
+ }
}
.frame(maxWidth: .infinity, alignment: .leading)
.padding(.trailing, 48)
diff --git a/Tests/FluidDictationIntegrationTests/SpeakerTurnMergingTests.swift b/Tests/FluidDictationIntegrationTests/SpeakerTurnMergingTests.swift
index a2bf72c3..33aaadbb 100644
--- a/Tests/FluidDictationIntegrationTests/SpeakerTurnMergingTests.swift
+++ b/Tests/FluidDictationIntegrationTests/SpeakerTurnMergingTests.swift
@@ -39,19 +39,44 @@ final class SpeakerTurnMergingTests: XCTestCase {
func testSameSpeakerAcrossLongGapStaysSeparate() {
let merged = SpeakerDiarizationService.mergeAdjacentTurns([
self.turn("Speaker 1", 0, 5),
- self.turn("Speaker 1", 6.5, 9),
+ self.turn("Speaker 1", 8.5, 11),
])
- XCTAssertEqual(merged.count, 2, "1.5s exceeds the 1.0s merge gap")
+ XCTAssertEqual(merged.count, 2, "3.5s exceeds the 1.0s default merge gap")
}
- func testGapExactlyAtTheLimitIsMerged() {
+ func testDefaultGapIsPinnedAtOneSecond() {
let merged = SpeakerDiarizationService.mergeAdjacentTurns([
self.turn("Speaker 1", 0, 5),
self.turn("Speaker 1", 6.0, 9),
])
+ XCTAssertEqual(merged.count, 1, "a gap of exactly the 1.0s default still merges")
+
+ let separated = SpeakerDiarizationService.mergeAdjacentTurns([
+ self.turn("Speaker 1", 0, 5),
+ self.turn("Speaker 1", 6.1, 9),
+ ])
+ XCTAssertEqual(separated.count, 2, "1.1s exceeds the 1.0s default merge gap; file transcription keeps this default")
+ }
+
+ func testGapExactlyAtTheLimitIsMerged() {
+ let merged = SpeakerDiarizationService.mergeAdjacentTurns([
+ self.turn("Speaker 1", 0, 5),
+ self.turn("Speaker 1", 8.0, 11),
+ ], maxGapSeconds: 3.0)
XCTAssertEqual(merged.count, 1, "a gap of exactly maxGapSeconds still merges")
}
+ /// Real conversational pauses run to a few seconds; meeting processing passes 3.0s
+ /// explicitly (MeetingProcessingPipeline.meetingTurnMergeGapSeconds) so a 1.0s gap doesn't
+ /// fragment every turn on a live Zoom call and starve the ASR of context.
+ func testTypicalConversationalPauseMerges() {
+ let merged = SpeakerDiarizationService.mergeAdjacentTurns([
+ self.turn("Speaker 1", 0, 5),
+ self.turn("Speaker 1", 7.5, 11),
+ ], maxGapSeconds: 3.0)
+ XCTAssertEqual(merged.count, 1)
+ }
+
func testDifferentSpeakersAreNeverMerged() {
let merged = SpeakerDiarizationService.mergeAdjacentTurns([
self.turn("Speaker 1", 0, 5),
@@ -516,7 +541,7 @@ extension MeetingSessionModelTests {
"schemaVersion", "title", "languageCode", "startedAt", "endedAt", "durationSeconds",
"mode", "applicationDisplayName", "speakers", "id", "displayName", "isLocalUser",
"segments", "startSeconds", "endSeconds", "speakerID", "text", "revision", "status",
- "overlap", "completeness",
+ "overlap", "completeness", "isLikelyEcho",
]
private func collectDictionaryKeys(in value: Any, into keys: inout Set<String>) {
@@ -551,6 +576,30 @@ extension MeetingSessionModelTests {
])
}
+ /// `isLikelyEcho` must stay optional: a non-optional defaulted property makes the synthesized
+ /// decoder require the key, and the store silently drops sessions that fail to decode.
+ func testSegmentWithoutEchoKeyStillDecodes() throws {
+ let legacySegmentJSON = """
+ {
+ "id": "3F2504E0-4F89-11D3-9A0C-0305E82C3301",
+ "start": { "value": 0, "timescale": 1000 },
+ "end": { "value": 1000, "timescale": 1000 },
+ "sourceTrackID": "3F2504E0-4F89-11D3-9A0C-0305E82C3302",
+ "text": "legacy segment",
+ "revision": 0,
+ "status": "final",
+ "overlap": "none",
+ "completeness": "complete"
+ }
+ """
+ let segment = try JSONDecoder().decode(
+ MeetingTranscriptSegment.self,
+ from: Data(legacySegmentJSON.utf8)
+ )
+ XCTAssertFalse(segment.isEcho)
+ XCTAssertNil(segment.isLikelyEcho)
+ }
+
func testJSONExportContainsOnlyAllowlistedKeys() throws {
let session = MeetingModelFixture.makeSession()
let data = try MeetingTranscriptExporter.json(for: session)
@@ -654,6 +703,160 @@ extension MeetingSessionModelTests {
let startSeconds = try XCTUnwrap(segments.first?["startSeconds"] as? Double)
XCTAssertEqual(startSeconds, 4, accuracy: 0.001)
}
+
+ func testTextExportExcludesEchoByDefaultAndIncludesWithFlag() throws {
+ var session = MeetingModelFixture.makeSession()
+ var echoSegment = session.transcriptSegments[0]
+ echoSegment.id = UUID()
+ echoSegment.start = MeetingModelFixture.mediaTime(20)
+ echoSegment.end = MeetingModelFixture.mediaTime(24)
+ echoSegment.text = "Echoed remote text"
+ echoSegment.isLikelyEcho = true
+ session.transcriptSegments.append(echoSegment)
+
+ let withoutEchoes = MeetingTranscriptExporter.text(for: session)
+ XCTAssertFalse(withoutEchoes.contains("Echoed remote text"))
+
+ let withEchoes = MeetingTranscriptExporter.text(for: session, includeEchoes: true)
+ XCTAssertTrue(withEchoes.contains("Echoed remote text"))
+ }
+
+ func testJSONExportAlwaysIncludesEchoSegmentsWithFlag() throws {
+ var session = MeetingModelFixture.makeSession()
+ var echoSegment = session.transcriptSegments[0]
+ echoSegment.id = UUID()
+ echoSegment.start = MeetingModelFixture.mediaTime(20)
+ echoSegment.end = MeetingModelFixture.mediaTime(24)
+ echoSegment.text = "Echoed remote text"
+ echoSegment.isLikelyEcho = true
+ session.transcriptSegments.append(echoSegment)
+
+ let data = try MeetingTranscriptExporter.json(for: session)
+ let json = try XCTUnwrap(JSONSerialization.jsonObject(with: data) as? [String: Any])
+ let segments = try XCTUnwrap(json["segments"] as? [[String: Any]])
+
+ XCTAssertEqual(segments.count, 2)
+ let echoFlags = segments.compactMap { $0["isLikelyEcho"] as? Bool }
+ XCTAssertEqual(echoFlags.count, 2, "isLikelyEcho must always be present so the export key set stays stable")
+ XCTAssertTrue(echoFlags.contains(true))
+ XCTAssertTrue(echoFlags.contains(false))
+ }
+}
+
+final class MeetingEchoDetectorTests: XCTestCase {
+ func testIdenticalTextIsEcho() {
+ let text = "It was proactive like sometimes it was just like check on me during the day."
+ XCTAssertTrue(MeetingEchoDetector.isLikelyEcho(micText: text, remoteText: text))
+ }
+
+ /// The real pair that motivated containment over Jaccard.
+ func testRealZoomPairIsEcho() {
+ let mic = "It was proactive like sometimes it was just like check on me during the day."
+ let remote = "It was proactive, like sometimes the winter like check on me during the day."
+ XCTAssertTrue(MeetingEchoDetector.isLikelyEcho(micText: mic, remoteText: remote))
+ }
+
+ func testUnrelatedMicTextOverlappingRemoteTextIsNotEcho() {
+ let mic = "Let's move the roadmap review to Thursday afternoon instead please."
+ let remote = "It was proactive, like sometimes the winter like check on me during the day."
+ XCTAssertFalse(MeetingEchoDetector.isLikelyEcho(micText: mic, remoteText: remote))
+ }
+
+ func testShortFullyContainedMicLineIsNotEchoBelowMinimumWordFloor() {
+ let mic = "check on me"
+ let remote = "It was proactive, like sometimes the winter like check on me during the day."
+ XCTAssertLessThan(MeetingEchoDetector.normalizedWords(mic).count, MeetingEchoDetector.minimumMicWords)
+ XCTAssertEqual(MeetingEchoDetector.containment(micText: mic, remoteText: remote), 1.0)
+ XCTAssertFalse(MeetingEchoDetector.isLikelyEcho(micText: mic, remoteText: remote))
+ }
+
+ func testEmptyRemoteTextIsNotEcho() {
+ let mic = "It was proactive like sometimes it was just like check on me during the day."
+ XCTAssertFalse(MeetingEchoDetector.isLikelyEcho(micText: mic, remoteText: ""))
+ }
+
+ /// Short genuine speech that happens to share most of its (few) content words with unrelated
+ /// remote text must not be flagged — only 2 of 3 mic content words match.
+ func testShortGenuineSpeechSharingFewContentWordsIsNotEcho() {
+ let mic = "the roadmap timeline works"
+ let remote = "roadmap timeline"
+ XCTAssertFalse(MeetingEchoDetector.isLikelyEcho(micText: mic, remoteText: remote))
+ }
+}
+
+final class MeetingTurnSelectionTests: XCTestCase {
+ private typealias Turn = (index: Int, turn: String, text: String)
+
+ func testMiddleTurnEmptyKeepsOthersWithOriginalIndices() {
+ let turns: [Turn] = [(0, "a", "hello"), (1, "b", ""), (2, "c", "world")]
+ let kept = MeetingTurnSelection.keepingNonEmpty(turns)
+ XCTAssertEqual(kept?.map(\.index), [0, 2])
+ XCTAssertEqual(kept?.map(\.text), ["hello", "world"])
+ }
+
+ func testAllEmptyReturnsNil() {
+ let turns: [Turn] = [(0, "a", ""), (1, "b", "")]
+ XCTAssertNil(MeetingTurnSelection.keepingNonEmpty(turns))
+ }
+
+ func testNoneEmptyReturnsUnchanged() {
+ let turns: [Turn] = [(0, "a", "hello"), (1, "b", "world")]
+ let kept = MeetingTurnSelection.keepingNonEmpty(turns)
+ XCTAssertEqual(kept?.map(\.index), [0, 1])
+ XCTAssertEqual(kept?.map(\.text), ["hello", "world"])
+ }
+}
+
+/// F1 regression guard: the 60s whole-chunk fallback segment is too coarse to score for echo
+/// containment, so it must never enter the candidate set.
+final class MeetingEchoCandidateTextTests: XCTestCase {
+ private let applicationTrackID = UUID()
+ private let diarizedSpeakerID = UUID()
+ private let fallbackSpeakerID = UUID()
+
+ private func segment(speakerID: SessionSpeakerID, start: TimeInterval, end: TimeInterval, text: String) -> MeetingTranscriptSegment {
+ MeetingTranscriptSegment(
+ id: UUID(),
+ start: MeetingMediaTime(value: Int64(start * 1000), timescale: 1000),
+ end: MeetingMediaTime(value: Int64(end * 1000), timescale: 1000),
+ sourceTrackID: self.applicationTrackID,
+ speakerID: speakerID,
+ text: text,
+ revision: 0,
+ status: .final,
+ overlap: .none,
+ completeness: .complete
+ )
+ }
+
+ func testFallbackSpeakerSegmentIsExcludedFromCandidateSet() {
+ let diarized = self.segment(speakerID: self.diarizedSpeakerID, start: 0, end: 5, text: "diarized remote text")
+ let fallback = self.segment(speakerID: self.fallbackSpeakerID, start: 0, end: 60, text: "coarse whole chunk fallback text")
+
+ let text = MeetingProcessingPipeline.echoCandidateText(
+ segments: [diarized, fallback],
+ speakerIDToExclude: self.fallbackSpeakerID,
+ applicationTrackID: self.applicationTrackID,
+ window: (start: 1, end: 3)
+ )
+
+ XCTAssertEqual(text, "diarized remote text")
+ }
+
+ func testNilExclusionKeepsAllOverlappingSegments() {
+ let diarized = self.segment(speakerID: self.diarizedSpeakerID, start: 0, end: 5, text: "diarized remote text")
+ let fallback = self.segment(speakerID: self.fallbackSpeakerID, start: 0, end: 60, text: "coarse whole chunk fallback text")
+
+ let text = MeetingProcessingPipeline.echoCandidateText(
+ segments: [diarized, fallback],
+ speakerIDToExclude: nil,
+ applicationTrackID: self.applicationTrackID,
+ window: (start: 1, end: 3)
+ )
+
+ XCTAssertTrue(text.contains("diarized remote text"))
+ XCTAssertTrue(text.contains("coarse whole chunk fallback text"))
+ }
}
final class MeetingSpeakerEmbeddingIndexTests: XCTestCase {