Merge main into macOS support and repair integration fixtures

2026-09-18 10:56:40 +02:00
parent 84dc696ce9 e011e36ef7
commit 723298e720
77 changed files with 7622 additions and 467 deletions
@@ -6,6 +6,8 @@ public interface IMeetingInactivityPromptService
        MeetingInactivityPromptRequest request,
        Func<MeetingInactivityPromptResponse, CancellationToken, Task> handleResponseAsync,
        CancellationToken cancellationToken);
+
+    Task DismissAllAsync(CancellationToken cancellationToken);
 }

 public sealed record MeetingInactivityPromptRequest(
@@ -18,9 +20,32 @@ public enum MeetingInactivityPromptResponse
 {
    Dismissed,
    Continue,
+    Pause,
    Stop
 }

+internal sealed record MeetingInactivityPromptAction(
+    string Content,
+    string ResponseArgument,
+    MeetingInactivityPromptResponse Response);
+
+internal static class MeetingInactivityPromptActions
+{
+    public static IReadOnlyList<MeetingInactivityPromptAction> All { get; } =
+    [
+        new("Yes", "stop", MeetingInactivityPromptResponse.Stop),
+        new("No", "continue", MeetingInactivityPromptResponse.Continue),
+        new("Pause transcription", "pause", MeetingInactivityPromptResponse.Pause)
+    ];
+
+    public static MeetingInactivityPromptResponse ParseResponse(string? value)
+    {
+        return All.FirstOrDefault(action =>
+                action.ResponseArgument.Equals(value, StringComparison.OrdinalIgnoreCase))
+            ?.Response ?? MeetingInactivityPromptResponse.Continue;
+    }
+}
+
 public sealed class NoopMeetingInactivityPromptService : IMeetingInactivityPromptService
 {
    public Task ShowStopPromptAsync(
@@ -30,4 +55,9 @@ public sealed class NoopMeetingInactivityPromptService : IMeetingInactivityPromp
    {
        return Task.CompletedTask;
    }
+
+    public Task DismissAllAsync(CancellationToken cancellationToken)
+    {
+        return Task.CompletedTask;
+    }
 }
@@ -34,6 +34,7 @@ public sealed class MeetingRecordingCoordinator
    private readonly IMeetingInactivityClock inactivityClock;
    private readonly IOfflineTranscriptionBacklog offlineTranscriptionBacklog;
    private readonly MeetingAssistantOptions options;
+    private readonly SpeakerSampleCollectionPolicy speakerSampleCollectionPolicy;
    private readonly ILogger<MeetingRecordingCoordinator> logger;
    private readonly SemaphoreSlim gate = new(1, 1);
    private RecordingRun? currentRun;
@@ -63,7 +64,8 @@ public sealed class MeetingRecordingCoordinator
        IMeetingRunArtifactCleaner? artifactCleaner = null,
        IMeetingInactivityPromptService? inactivityPromptService = null,
        IMeetingInactivityClock? inactivityClock = null,
-        IOfflineTranscriptionBacklog? offlineTranscriptionBacklog = null)
+        IOfflineTranscriptionBacklog? offlineTranscriptionBacklog = null,
+        SpeakerSampleCollectionPolicy? speakerSampleCollectionPolicy = null)
    {
        this.audioSource = audioSource;
        this.speechRecognitionPipelineFactory = speechRecognitionPipelineFactory;
@@ -86,6 +88,8 @@ public sealed class MeetingRecordingCoordinator
        this.inactivityClock = inactivityClock ?? new SystemMeetingInactivityClock();
        this.offlineTranscriptionBacklog = offlineTranscriptionBacklog ?? NoopOfflineTranscriptionBacklog.Instance;
        this.options = options.Value;
+        this.speakerSampleCollectionPolicy = speakerSampleCollectionPolicy
+            ?? SpeakerSampleCollectionPolicy.ExistingBackend;
        this.logger = logger;
    }

@@ -96,7 +100,8 @@ public sealed class MeetingRecordingCoordinator
        currentArtifacts?.AssistantContextPath,
        currentArtifacts?.SummaryPath,
        GetProcessState(currentRun),
-        currentRun?.LaunchProfileName);
+        currentRun?.LaunchProfileName,
+        IsRecording && currentRun?.IsTranscriptionPaused == true);

    public MeetingSessionArtifacts? CurrentArtifacts => currentArtifacts;

@@ -289,10 +294,12 @@ public sealed class MeetingRecordingCoordinator
                startedAt,
                launchProfile.Name,
                runOptions.SpeakerIdentification.LiveSampleBufferDuration,
-                runOptions.SpeakerIdentification.MaxSnippetsPerSpeaker,
+                speakerSampleCollectionPolicy.ResolveRetainedSampleLimit(
+                    runOptions.SpeakerIdentification.MaxSnippetsPerSpeaker),
+                speakerSampleCollectionPolicy.RequireNonOverlappingSamples,
                logger);
            run.Task = Task.Run(() => RecordAsync(run), CancellationToken.None);
-            if (runOptions.Recording.InactivitySafeguard.Enabled)
+            if (ShouldRunInactivitySafeguard(runOptions.Recording.InactivitySafeguard))
            {
                _ = Task.Run(
                    () => RunInactivitySafeguardAsync(run),
@@ -334,11 +341,14 @@ public sealed class MeetingRecordingCoordinator

    public async Task<RecordingStatus> StopAsync(CancellationToken cancellationToken)
    {
-        return await StopAsync(null, cancellationToken);
+        return await StopAsync(null, null, null, null, cancellationToken);
    }

    private async Task<RecordingStatus> StopAsync(
        DateTimeOffset? inferredEndTime,
+        RecordingRun? expectedRun,
+        long? expectedActivityVersion,
+        DateTimeOffset? expectedPauseStartedAt,
        CancellationToken cancellationToken)
    {
        RecordingRun run;
@@ -347,13 +357,30 @@ public sealed class MeetingRecordingCoordinator
        await gate.WaitAsync(cancellationToken);
        try
        {
-            if (currentRun is null || currentRun.IsCaptureStopping)
+            if (currentRun is null ||
+                currentRun.IsCaptureStopping ||
+                expectedRun is not null && !ReferenceEquals(currentRun, expectedRun))
            {
                return CurrentStatus;
            }

            run = currentRun;
-            if (inferredEndTime is not null)
+            var inactivityStopClaimed = expectedActivityVersion is not null;
+            if (expectedActivityVersion is not null &&
+                (inferredEndTime is null ||
+                 !run.TryClaimInactivityStop(expectedActivityVersion.Value, inferredEndTime.Value)))
+            {
+                return CurrentStatus;
+            }
+
+            var maximumPauseStopClaimed = expectedPauseStartedAt is not null;
+            if (expectedPauseStartedAt is not null &&
+                !run.TryClaimMaximumPauseStop(expectedPauseStartedAt.Value))
+            {
+                return CurrentStatus;
+            }
+
+            if (!inactivityStopClaimed && !maximumPauseStopClaimed && inferredEndTime is not null)
            {
                run.SetInferredEndTime(inferredEndTime.Value);
            }
@@ -363,7 +390,7 @@ public sealed class MeetingRecordingCoordinator
            {
                run.Abort();
            }
-            else
+            else if (!inactivityStopClaimed && !maximumPauseStopClaimed)
            {
                run.StopCapture();
            }
@@ -409,6 +436,65 @@ public sealed class MeetingRecordingCoordinator
        return CurrentStatus;
    }

+    public async Task<RecordingStatus> SetTranscriptionPausedAsync(
+        bool isPaused,
+        CancellationToken cancellationToken)
+    {
+        return await SetTranscriptionPausedAsync(isPaused, null, null, cancellationToken);
+    }
+
+    private async Task<RecordingStatus> SetTranscriptionPausedAsync(
+        bool isPaused,
+        RecordingRun? expectedRun,
+        long? expectedActivityVersion,
+        CancellationToken cancellationToken)
+    {
+        await gate.WaitAsync(cancellationToken);
+        try
+        {
+            var run = currentRun;
+            if (run is null ||
+                run.IsCaptureStopping ||
+                expectedRun is not null && !ReferenceEquals(run, expectedRun))
+            {
+                return CurrentStatus;
+            }
+
+            var changed = false;
+            await run.PipelineGate.WaitAsync(cancellationToken);
+            try
+            {
+                var changedAt = inactivityClock.Now;
+                changed = run.TrySetTranscriptionPaused(
+                    isPaused,
+                    changedAt,
+                    expectedActivityVersion);
+            }
+            finally
+            {
+                run.PipelineGate.Release();
+            }
+
+            if (changed && isPaused)
+            {
+                await DismissInactivityPromptsAsync(cancellationToken);
+            }
+
+            if (changed)
+            {
+                logger.LogInformation(
+                    "Meeting transcription {PauseState}",
+                    isPaused ? "paused" : "unpaused");
+            }
+
+            return CurrentStatus;
+        }
+        finally
+        {
+            gate.Release();
+        }
+    }
+
    public async Task<RecordingStatus> AbortAsync(CancellationToken cancellationToken)
    {
        RecordingRun run;
@@ -679,8 +765,7 @@ public sealed class MeetingRecordingCoordinator
                        chunk.Channels);
                }

-                await run.RecordedAudio.AppendAsync(chunk, run.CaptureCancellation);
-                await run.WriteAudioAsync(chunk, run.CaptureCancellation);
+                await run.RouteCapturedAudioAsync(chunk, run.CaptureCancellation);
            }

            logger.LogInformation(
@@ -719,7 +804,6 @@ public sealed class MeetingRecordingCoordinator
                run.ResetSpeakerIdentification();
            }

-            run.RecordTranscriptActivity(segment, inactivityClock.Now);
            var sample = run.TryAddSpeakerSample(segment);
            if (sample is not null)
            {
@@ -736,6 +820,56 @@ public sealed class MeetingRecordingCoordinator
            var relabeledSegment = run.Relabel(segment);
            run.AddLiveSegment(relabeledSegment);
            await AppendTranscriptSegmentAsync(run, relabeledSegment, cancellationToken);
+            run.RecordTranscriptActivity(segment, inactivityClock.Now);
+            if (!string.IsNullOrWhiteSpace(segment.Text))
+            {
+                // Switching profiles holds the coordinator gate while draining this reader.
+                // Notification cleanup must not make transcript draining wait for that gate.
+                _ = DismissInactivityPromptsForRunAsync(run, run.CaptureCancellation);
+            }
+        }
+    }
+
+    private async Task DismissInactivityPromptsForRunAsync(
+        RecordingRun run,
+        CancellationToken cancellationToken)
+    {
+        try
+        {
+            await gate.WaitAsync(cancellationToken);
+            try
+            {
+                if (!ReferenceEquals(currentRun, run) || run.IsCaptureStopping)
+                {
+                    return;
+                }
+
+                await DismissInactivityPromptsAsync(cancellationToken);
+            }
+            finally
+            {
+                gate.Release();
+            }
+        }
+        catch (OperationCanceledException) when (cancellationToken.IsCancellationRequested)
+        {
+            // Pending cleanup is no longer needed after this run stops capturing.
+        }
+    }
+
+    private async Task DismissInactivityPromptsAsync(CancellationToken cancellationToken)
+    {
+        try
+        {
+            await inactivityPromptService.DismissAllAsync(cancellationToken);
+        }
+        catch (OperationCanceledException) when (cancellationToken.IsCancellationRequested)
+        {
+            throw;
+        }
+        catch (Exception exception)
+        {
+            logger.LogWarning(exception, "Failed to dismiss transcript inactivity prompts");
        }
    }

@@ -863,7 +997,10 @@ public sealed class MeetingRecordingCoordinator
    private async Task RunInactivitySafeguardAsync(RecordingRun run)
    {
        var safeguardOptions = run.Options.Recording.InactivitySafeguard;
-        var promptThresholds = GetInactivityPromptThresholds(safeguardOptions);
+        var promptThresholds = safeguardOptions.Enabled
+            ? GetInactivityPromptThresholds(safeguardOptions)
+            : [];
+        var checkInterval = GetInactivitySafeguardCheckInterval(safeguardOptions);
        var promptedThresholds = new HashSet<TimeSpan>();
        var lastActivityVersion = run.GetTranscriptActivitySnapshot().ActivityVersion;

@@ -871,7 +1008,7 @@ public sealed class MeetingRecordingCoordinator
            "Recording inactivity safeguard started with prompt thresholds {PromptThresholds}, auto-stop {AutoStopAfter}, check interval {CheckInterval}",
            string.Join(", ", promptThresholds),
            safeguardOptions.AutoStopAfter,
-            safeguardOptions.CheckInterval);
+            checkInterval);

        try
        {
@@ -887,9 +1024,38 @@ public sealed class MeetingRecordingCoordinator
                        snapshot.LastTranscriptActivityAt);
                }

+                var pauseStartedAt = snapshot.TranscriptionPausedAt;
+                if (pauseStartedAt is not null)
+                {
+                    var maximumPauseDuration = safeguardOptions.MaximumPauseDuration;
+                    if (maximumPauseDuration > TimeSpan.Zero &&
+                        inactivityClock.Now - pauseStartedAt.Value >= maximumPauseDuration)
+                    {
+                        logger.LogWarning(
+                            "Recording inactivity safeguard stopping meeting after transcription remained paused for {PauseDuration}",
+                            maximumPauseDuration);
+                        var stopStatus = await StopAsync(
+                            null,
+                            run,
+                            null,
+                            pauseStartedAt,
+                            CancellationToken.None);
+                        if (!stopStatus.IsRecording)
+                        {
+                            return;
+                        }
+                    }
+
+                    await inactivityClock.DelayAsync(
+                        checkInterval,
+                        run.CaptureCancellation);
+                    continue;
+                }
+
                var now = inactivityClock.Now;
                var inactivityDuration = now - snapshot.LastTranscriptActivityAt;
-                if (safeguardOptions.AutoStopAfter > TimeSpan.Zero &&
+                if (safeguardOptions.Enabled &&
+                    safeguardOptions.AutoStopAfter > TimeSpan.Zero &&
                    inactivityDuration >= safeguardOptions.AutoStopAfter)
                {
                    var inferredEndTime = run.GetInactivitySafeguardEndTime(safeguardOptions.InferredEndPadding);
@@ -897,8 +1063,16 @@ public sealed class MeetingRecordingCoordinator
                        "Recording inactivity safeguard auto-stopping meeting after {InactivityDuration} without transcript text; inferred end time {InferredEndTime}",
                        inactivityDuration,
                        inferredEndTime);
-                    await StopAsync(inferredEndTime, CancellationToken.None);
-                    return;
+                    var stopStatus = await StopAsync(
+                        inferredEndTime,
+                        run,
+                        snapshot.ActivityVersion,
+                        null,
+                        CancellationToken.None);
+                    if (!stopStatus.IsRecording)
+                    {
+                        return;
+                    }
                }

                foreach (var threshold in promptThresholds)
@@ -915,6 +1089,7 @@ public sealed class MeetingRecordingCoordinator
                        inactivityDuration,
                        threshold,
                        inferredEndTime);
+                    var promptActivityVersion = snapshot.ActivityVersion;
                    await inactivityPromptService.ShowStopPromptAsync(
                        new MeetingInactivityPromptRequest(
                            inactivityDuration,
@@ -930,16 +1105,36 @@ public sealed class MeetingRecordingCoordinator

                            if (response == MeetingInactivityPromptResponse.Stop)
                            {
-                                await StopAsync(inferredEndTime, CancellationToken.None);
+                                await StopAsync(
+                                    inferredEndTime,
+                                    run,
+                                    promptActivityVersion,
+                                    null,
+                                    CancellationToken.None);
+                            }
+                            else if (response == MeetingInactivityPromptResponse.Pause)
+                            {
+                                await SetTranscriptionPausedAsync(
+                                    true,
+                                    run,
+                                    promptActivityVersion,
+                                    CancellationToken.None);
                            }
                        },
                        run.CaptureCancellation);

+                    var currentActivity = run.GetTranscriptActivitySnapshot();
+                    if (currentActivity.IsTranscriptionPaused ||
+                        currentActivity.ActivityVersion != promptActivityVersion)
+                    {
+                        await DismissInactivityPromptsAsync(run.CaptureCancellation);
+                    }
+
                    break;
                }

                await inactivityClock.DelayAsync(
-                    GetInactivitySafeguardCheckInterval(safeguardOptions),
+                    checkInterval,
                    run.CaptureCancellation);
            }
        }
@@ -1007,11 +1202,11 @@ public sealed class MeetingRecordingCoordinator
        try
        {
            var meetingNote = await meetingNoteStore.ReadAsync(run.MeetingNotePath, cancellationToken);
-            var checkpoint = run.CreateLiveIdentificationCheckpoint(meetingNote);
+            var checkpoint = run.CreateLiveIdentificationCheckpoint(meetingNote, samples);
            if (checkpoint is null)
            {
                logger.LogInformation(
-                    "Skipping live speaker identity matching because no new unmapped sample speakers or attendee changes were found");
+                    "Skipping live speaker identity matching because no new eligible speaker evidence or attendee changes were found");
                return;
            }

@@ -1839,6 +2034,11 @@ public sealed class MeetingRecordingCoordinator
            .ToList();
    }

+    private static bool ShouldRunInactivitySafeguard(RecordingInactivitySafeguardOptions options)
+    {
+        return options.Enabled || options.MaximumPauseDuration > TimeSpan.Zero;
+    }
+
    private static TimeSpan GetInactivitySafeguardCheckInterval(
        RecordingInactivitySafeguardOptions options)
    {
@@ -1895,6 +2095,8 @@ public sealed class MeetingRecordingCoordinator
        private TimeSpan? lastTranscriptSegmentEnd;
        private long transcriptActivityVersion;
        private DateTimeOffset? inferredEndTime;
+        private bool isTranscriptionPaused;
+        private DateTimeOffset? transcriptionPausedAt;

        public RecordingRun(
            CancellationTokenSource captureCancellation,
@@ -1910,6 +2112,7 @@ public sealed class MeetingRecordingCoordinator
            string launchProfileName,
            TimeSpan liveSampleBufferDuration,
            int maxSpeakerSamples,
+            bool requireNonOverlappingSpeakerSamples,
            ILogger logger)
        {
            CaptureCancellationSource = captureCancellation;
@@ -1930,8 +2133,9 @@ public sealed class MeetingRecordingCoordinator
                liveSampleBufferDuration,
                maxSpeakerSamples,
                options.SpeakerIdentification.MinimumSampleSpeechDuration,
-                options.SpeakerIdentification.MaximumSampleSegmentGap,
-                logger);
+                options.SpeakerIdentification.MaximumSampleDuration,
+                logger,
+                requireNonOverlappingSpeakerSamples);
        }

        public CancellationTokenSource CaptureCancellationSource { get; }
@@ -1978,6 +2182,17 @@ public sealed class MeetingRecordingCoordinator

        public bool HasAttachedPromptMetadata { get; private set; }

+        public bool IsTranscriptionPaused
+        {
+            get
+            {
+                lock (transcriptActivityGate)
+                {
+                    return isTranscriptionPaused;
+                }
+            }
+        }
+
        public AssistantContextState ContextState { get; private set; } = AssistantContextState.CollectingMetadata;

        public DateTimeOffset? InferredEndTime
@@ -2001,6 +2216,37 @@ public sealed class MeetingRecordingCoordinator
            HasAttachedPromptMetadata = true;
        }

+        public bool TrySetTranscriptionPaused(
+            bool isPaused,
+            DateTimeOffset changedAt,
+            long? expectedActivityVersion)
+        {
+            lock (transcriptActivityGate)
+            {
+                if (expectedActivityVersion is not null &&
+                    transcriptActivityVersion != expectedActivityVersion.Value)
+                {
+                    return false;
+                }
+
+                if (isTranscriptionPaused == isPaused)
+                {
+                    return false;
+                }
+
+                isTranscriptionPaused = isPaused;
+                transcriptionPausedAt = isPaused ? changedAt : null;
+
+                if (!isPaused)
+                {
+                    lastTranscriptActivityAt = changedAt;
+                }
+
+                transcriptActivityVersion++;
+                return true;
+            }
+        }
+
        public void Abort()
        {
            IsAborted = true;
@@ -2029,13 +2275,17 @@ public sealed class MeetingRecordingCoordinator
            return string.Equals(LaunchProfileName, launchProfileName, StringComparison.OrdinalIgnoreCase);
        }

-        public async ValueTask WriteAudioAsync(AudioChunk chunk, CancellationToken cancellationToken)
+        public async ValueTask RouteCapturedAudioAsync(AudioChunk chunk, CancellationToken cancellationToken)
        {
            await PipelineGate.WaitAsync(cancellationToken);
            try
            {
-                AppendAudio(chunk);
-                await Pipeline.WriteAsync(chunk, cancellationToken);
+                var routedChunk = IsTranscriptionPaused
+                    ? chunk with { Pcm = new byte[chunk.Pcm.Length] }
+                    : chunk;
+                await RecordedAudio.AppendAsync(routedChunk, cancellationToken);
+                AppendAudio(routedChunk);
+                await Pipeline.WriteAsync(routedChunk, cancellationToken);
            }
            finally
            {
@@ -2219,7 +2469,9 @@ public sealed class MeetingRecordingCoordinator
                return new TranscriptActivitySnapshot(
                    lastTranscriptActivityAt,
                    lastTranscriptSegmentEnd,
-                    transcriptActivityVersion);
+                    transcriptActivityVersion,
+                    isTranscriptionPaused,
+                    transcriptionPausedAt);
            }
        }

@@ -2239,6 +2491,35 @@ public sealed class MeetingRecordingCoordinator
            }
        }

+        public bool TryClaimInactivityStop(long expectedActivityVersion, DateTimeOffset endTime)
+        {
+            lock (transcriptActivityGate)
+            {
+                if (isTranscriptionPaused || transcriptActivityVersion != expectedActivityVersion)
+                {
+                    return false;
+                }
+
+                inferredEndTime = endTime;
+                StopCapture();
+                return true;
+            }
+        }
+
+        public bool TryClaimMaximumPauseStop(DateTimeOffset expectedPauseStartedAt)
+        {
+            lock (transcriptActivityGate)
+            {
+                if (!isTranscriptionPaused || transcriptionPausedAt != expectedPauseStartedAt)
+                {
+                    return false;
+                }
+
+                StopCapture();
+                return true;
+            }
+        }
+
        public void AppendAudio(AudioChunk chunk)
        {
            speakerSampleCollector.AppendAudio(chunk);
@@ -2262,9 +2543,11 @@ public sealed class MeetingRecordingCoordinator
            return speakerSampleCollector.Snapshot();
        }

-        public LiveIdentificationCheckpoint? CreateLiveIdentificationCheckpoint(MeetingNote meetingNote)
+        public LiveIdentificationCheckpoint? CreateLiveIdentificationCheckpoint(
+            MeetingNote meetingNote,
+            IReadOnlyList<SpeakerAudioSample> samples)
        {
-            var speakers = GetUnmappedSampleSpeakers();
+            var speakers = GetUnmappedSampleSpeakers(samples);
            if (speakers.Count == 0)
            {
                return null;
@@ -2272,7 +2555,11 @@ public sealed class MeetingRecordingCoordinator

            var checkpoint = new LiveIdentificationCheckpoint(
                speakers,
-                BuildAttendeeSignature(meetingNote));
+                BuildAttendeeSignature(meetingNote),
+                Options.SpeakerIdentification.Resemblyzer.Enabled
+                    ? speakers.Select(speaker => samples.Count(sample =>
+                        string.Equals(sample.Speaker, speaker, StringComparison.OrdinalIgnoreCase))).ToArray()
+                    : []);
            lock (liveIdentificationGate)
            {
                return lastLiveIdentificationCheckpoint?.Matches(checkpoint) == true
@@ -2330,9 +2617,9 @@ public sealed class MeetingRecordingCoordinator
                StringComparer.OrdinalIgnoreCase);
        }

-        private IReadOnlyList<string> GetUnmappedSampleSpeakers()
+        private IReadOnlyList<string> GetUnmappedSampleSpeakers(IReadOnlyList<SpeakerAudioSample> samples)
        {
-            return GetSpeakerSamplesSnapshot()
+            return samples
                .Select(sample => sample.Speaker)
                .Where(speaker => !string.IsNullOrWhiteSpace(speaker))
                .Where(speaker => !string.Equals(speaker, "Unknown", StringComparison.OrdinalIgnoreCase))
@@ -2368,7 +2655,9 @@ public sealed class MeetingRecordingCoordinator
        public sealed record TranscriptActivitySnapshot(
            DateTimeOffset LastTranscriptActivityAt,
            TimeSpan? LastTranscriptSegmentEnd,
-            long ActivityVersion);
+            long ActivityVersion,
+            bool IsTranscriptionPaused,
+            DateTimeOffset? TranscriptionPausedAt);

        private static int StateRank(AssistantContextState state)
        {
@@ -2386,11 +2675,13 @@ public sealed class MeetingRecordingCoordinator

        public sealed record LiveIdentificationCheckpoint(
            IReadOnlyList<string> Speakers,
-            string AttendeeSignature)
+            string AttendeeSignature,
+            IReadOnlyList<int> SampleCounts)
        {
            public bool Matches(LiveIdentificationCheckpoint other)
            {
                return string.Equals(AttendeeSignature, other.AttendeeSignature, StringComparison.Ordinal) &&
+                    SampleCounts.SequenceEqual(other.SampleCounts) &&
                    Speakers.Count == other.Speakers.Count &&
                    Speakers.SequenceEqual(other.Speakers, StringComparer.OrdinalIgnoreCase);
            }
@@ -2423,7 +2714,8 @@ public sealed record RecordingStatus(
    string? AssistantContextPath,
    string? SummaryPath,
    RecordingProcessState State = RecordingProcessState.Idle,
-    string? LaunchProfile = null);
+    string? LaunchProfile = null,
+    bool IsPaused = false);

 public enum RecordingProcessState
 {
@@ -9,37 +9,31 @@ internal sealed class SpeakerAudioSampleCollector
    private readonly object gate = new();
    private readonly RollingAudioBuffer audioBuffer;
    private readonly Dictionary<string, List<SpeakerAudioSample>> samplesBySpeaker = new(StringComparer.OrdinalIgnoreCase);
+    private readonly Dictionary<string, TimeSpan> lastAcceptedEndBySpeaker = new(StringComparer.OrdinalIgnoreCase);
    private readonly int maxSamplesPerSpeaker;
-    private readonly TimeSpan minimumUninterruptedSpeechDuration;
-    private readonly TimeSpan maximumSegmentGap;
+    private readonly TimeSpan minimumSampleSpeechDuration;
+    private readonly TimeSpan maximumSampleDuration;
+    private readonly bool requireNonOverlappingSamples;
    private readonly ILogger? logger;
-    private PendingSpeakerSpan? pendingSpan;
-
-    public SpeakerAudioSampleCollector(TimeSpan bufferDuration, int maxSamplesPerSpeaker)
-        : this(
-            bufferDuration,
-            maxSamplesPerSpeaker,
-            TimeSpan.FromSeconds(30),
-            TimeSpan.FromSeconds(1),
-            logger: null)
-    {
-    }
+    private SpeakerSampleSpan? pendingSpan;

    public SpeakerAudioSampleCollector(
        TimeSpan bufferDuration,
        int maxSamplesPerSpeaker,
-        TimeSpan minimumUninterruptedSpeechDuration,
-        TimeSpan maximumSegmentGap,
-        ILogger? logger = null)
+        TimeSpan minimumSampleSpeechDuration,
+        TimeSpan maximumSampleDuration,
+        ILogger? logger = null,
+        bool requireNonOverlappingSamples = false)
    {
+        SpeakerSampleDurationConfiguration.ValidateOrThrow(
+            minimumSampleSpeechDuration,
+            maximumSampleDuration,
+            "Speaker sample collector configuration is invalid");
        audioBuffer = new RollingAudioBuffer(bufferDuration);
        this.maxSamplesPerSpeaker = Math.Max(1, maxSamplesPerSpeaker);
-        this.minimumUninterruptedSpeechDuration = minimumUninterruptedSpeechDuration > TimeSpan.Zero
-            ? minimumUninterruptedSpeechDuration
-            : TimeSpan.Zero;
-        this.maximumSegmentGap = maximumSegmentGap >= TimeSpan.Zero
-            ? maximumSegmentGap
-            : TimeSpan.Zero;
+        this.minimumSampleSpeechDuration = minimumSampleSpeechDuration;
+        this.maximumSampleDuration = maximumSampleDuration;
+        this.requireNonOverlappingSamples = requireNonOverlappingSamples;
        this.logger = logger;
    }

@@ -53,6 +47,7 @@ internal sealed class SpeakerAudioSampleCollector
        lock (gate)
        {
            samplesBySpeaker.Clear();
+            lastAcceptedEndBySpeaker.Clear();
            pendingSpan = null;
            audioBuffer.Reset();
        }
@@ -68,34 +63,54 @@ internal sealed class SpeakerAudioSampleCollector
            return null;
        }

-        TranscriptionSegment sampleSegment;
-        PendingSpanReset? reset;
+        SpeakerSampleSpan? sampleSpan;
+        SpeakerSampleSpan? previousSpan;
        lock (gate)
        {
-            (sampleSegment, reset) = ExtendPendingSpan(segment);
+            if (requireNonOverlappingSamples &&
+                lastAcceptedEndBySpeaker.TryGetValue(segment.Speaker, out var lastAcceptedEnd) &&
+                segment.Start < lastAcceptedEnd)
+            {
+                logger?.LogInformation(
+                    "Discarding speaker identity sample for {Speaker} because it overlaps an accepted sample ending at {AcceptedSampleEnd}",
+                    segment.Speaker,
+                    lastAcceptedEnd);
+                return null;
+            }
+
+            (sampleSpan, previousSpan) = ExtendPendingSpan(segment);
        }

-        if (reset is not null)
+        if (sampleSpan is null)
        {
            logger?.LogInformation(
-                "Reset speaker identity sample span from {PreviousSpeaker} to {Speaker}: previous end {PreviousEnd}, next start {NextStart}, gap {Gap}, maximum gap {MaximumGap}",
-                reset.PreviousSpeaker,
-                segment.Speaker,
-                reset.PreviousEnd,
-                segment.Start,
-                reset.Gap,
-                maximumSegmentGap);
+                "Discarding speaker identity sample for {Speaker} because the segment duration is not positive",
+                segment.Speaker);
+            return null;
        }

-        var score = Score(sampleSegment, minimumUninterruptedSpeechDuration);
+        var sampleSegment = sampleSpan.ToSegment();
+
+        if (previousSpan is not null)
+        {
+            logger?.LogInformation(
+                "Reset speaker identity sample span from {PreviousSpeaker} to {Speaker}: previous end {PreviousEnd}, next start {NextStart}",
+                previousSpan.Speaker,
+                segment.Speaker,
+                previousSpan.End,
+                segment.Start);
+        }
+
+        var score = Score(sampleSegment, sampleSpan.SpeechDuration, minimumSampleSpeechDuration);
        if (!score.Accepted)
        {
            logger?.LogInformation(
-                "Discarding speaker identity sample for {Speaker} because {Reason}: duration {Duration}, minimum duration {MinimumDuration}, word count {WordCount}",
+                "Discarding speaker identity sample for {Speaker} because {Reason}: speaker audio {SpeakerAudioDuration}, clip duration {ClipDuration}, minimum duration {MinimumDuration}, word count {WordCount}",
                sampleSegment.Speaker,
                score.Reason,
+                sampleSpan.SpeechDuration,
                sampleSegment.End - sampleSegment.Start,
-                minimumUninterruptedSpeechDuration,
+                minimumSampleSpeechDuration,
                score.WordCount);
            return null;
        }
@@ -115,6 +130,13 @@ internal sealed class SpeakerAudioSampleCollector
        var sample = new SpeakerAudioSample(sampleSegment.Speaker, sampleSegment, wavBytes, score.Value);
        lock (gate)
        {
+            if (requireNonOverlappingSamples &&
+                ReferenceEquals(pendingSpan, sampleSpan))
+            {
+                pendingSpan = null;
+                lastAcceptedEndBySpeaker[sampleSegment.Speaker] = sampleSegment.End;
+            }
+
            if (!samplesBySpeaker.TryGetValue(sampleSegment.Speaker, out var samples))
            {
                samples = [];
@@ -163,35 +185,26 @@ internal sealed class SpeakerAudioSampleCollector
            !string.Equals(speaker, "Unknown", StringComparison.OrdinalIgnoreCase);
    }

-    private (TranscriptionSegment Segment, PendingSpanReset? Reset) ExtendPendingSpan(TranscriptionSegment segment)
+    private (SpeakerSampleSpan? Span, SpeakerSampleSpan? PreviousSpan) ExtendPendingSpan(TranscriptionSegment segment)
    {
-        if (pendingSpan is null ||
-            !SpeakerSampleSpanSelector.CanExtend(pendingSpan.Speaker, pendingSpan.End, segment, maximumSegmentGap))
+        if (pendingSpan is not null && pendingSpan.TryExtend(segment, out var extended))
        {
-            var reset = pendingSpan is null
-                ? null
-                : new PendingSpanReset(
-                    pendingSpan.Speaker,
-                    pendingSpan.End,
-                    segment.Start - pendingSpan.End);
-            pendingSpan = new PendingSpeakerSpan(
-                segment.Speaker,
-                segment.Start,
-                segment.End,
-                [segment.Text]);
-            return (pendingSpan.ToSegment(), reset);
+            pendingSpan = extended;
+            return (pendingSpan, null);
        }

-        pendingSpan = pendingSpan.Extend(segment);
-        return (pendingSpan.ToSegment(), null);
+        var previousSpan = pendingSpan;
+        pendingSpan = SpeakerSampleSpan.Create(segment, maximumSampleDuration);
+        return (pendingSpan, previousSpan);
    }

    private static SampleScore Score(
        TranscriptionSegment segment,
-        TimeSpan minimumUninterruptedSpeechDuration)
+        TimeSpan speechDuration,
+        TimeSpan minimumSampleSpeechDuration)
    {
-        var durationSeconds = (segment.End - segment.Start).TotalSeconds;
-        if (durationSeconds < minimumUninterruptedSpeechDuration.TotalSeconds)
+        var durationSeconds = speechDuration.TotalSeconds;
+        if (durationSeconds < minimumSampleSpeechDuration.TotalSeconds)
        {
            return new SampleScore(false, 0, "speech duration is below the configured minimum", WordCount(segment.Text));
        }
@@ -202,7 +215,7 @@ internal sealed class SpeakerAudioSampleCollector
            return new SampleScore(false, 0, "word count is below the minimum useful sample length", words);
        }

-        var durationScore = Math.Min(durationSeconds / Math.Max(1, minimumUninterruptedSpeechDuration.TotalSeconds), 2);
+        var durationScore = Math.Min(durationSeconds / Math.Max(1, minimumSampleSpeechDuration.TotalSeconds), 2);
        var wordScore = Math.Min(words / 60.0, 1);
        var sentenceBonus = segment.Text.TrimEnd().EndsWith('.') ||
            segment.Text.TrimEnd().EndsWith('?') ||
@@ -221,30 +234,4 @@ internal sealed class SpeakerAudioSampleCollector

    private sealed record SampleScore(bool Accepted, double Value, string? Reason, int WordCount);

-    private sealed record PendingSpanReset(string PreviousSpeaker, TimeSpan PreviousEnd, TimeSpan Gap);
-
-    private sealed record PendingSpeakerSpan(
-        string Speaker,
-        TimeSpan Start,
-        TimeSpan End,
-        IReadOnlyList<string> TextParts)
-    {
-        public PendingSpeakerSpan Extend(TranscriptionSegment segment)
-        {
-            return this with
-            {
-                End = segment.End > End ? segment.End : End,
-                TextParts = TextParts.Append(segment.Text).ToList()
-            };
-        }
-
-        public TranscriptionSegment ToSegment()
-        {
-            return new TranscriptionSegment(
-                Start,
-                End,
-                Speaker,
-                string.Join(' ', TextParts.Where(part => !string.IsNullOrWhiteSpace(part))));
-        }
-    }
 }
@@ -11,7 +11,7 @@ public sealed class WindowsMeetingInactivityPromptService : IMeetingInactivityPr
    private const string NotificationGroup = "meeting-inactivity";
    private readonly ConcurrentDictionary<string, PendingPrompt> pendingPrompts = new(StringComparer.OrdinalIgnoreCase);
    private readonly ILogger<WindowsMeetingInactivityPromptService> logger;
-    private readonly object registrationGate = new();
+    private readonly object notificationGate = new();
    private bool registered;

    public WindowsMeetingInactivityPromptService(ILogger<WindowsMeetingInactivityPromptService> logger)
@@ -37,24 +37,27 @@ public sealed class WindowsMeetingInactivityPromptService : IMeetingInactivityPr

        try
        {
-            EnsureRegistered();
-            var promptId = Guid.NewGuid().ToString("N");
-            pendingPrompts[promptId] = new PendingPrompt(handleResponseAsync);
-            logger.LogInformation(
-                "Registered native Windows inactivity notification {PromptId} response callback at threshold {Threshold}",
-                promptId,
-                request.Threshold);
-            var notification = BuildNotification(promptId, request);
-            notification.Show(toast =>
+            lock (notificationGate)
            {
-                toast.Group = NotificationGroup;
-                toast.Tag = promptId;
-                toast.ExpirationTime = MeetingToastExpirationPolicy.StopReminderExpiration(DateTimeOffset.Now);
-            });
-            logger.LogInformation(
-                "Displayed native Windows inactivity notification {PromptId} at threshold {Threshold}",
-                promptId,
-                request.Threshold);
+                EnsureRegistered();
+                var promptId = Guid.NewGuid().ToString("N");
+                pendingPrompts[promptId] = new PendingPrompt(handleResponseAsync);
+                logger.LogInformation(
+                    "Registered native Windows inactivity notification {PromptId} response callback at threshold {Threshold}",
+                    promptId,
+                    request.Threshold);
+                var notification = BuildNotification(promptId, request);
+                notification.Show(toast =>
+                {
+                    toast.Group = NotificationGroup;
+                    toast.Tag = promptId;
+                    toast.ExpirationTime = MeetingToastExpirationPolicy.StopReminderExpiration(DateTimeOffset.Now);
+                });
+                logger.LogInformation(
+                    "Displayed native Windows inactivity notification {PromptId} at threshold {Threshold}",
+                    promptId,
+                    request.Threshold);
+            }
        }
        catch (Exception exception)
        {
@@ -76,6 +79,36 @@ public sealed class WindowsMeetingInactivityPromptService : IMeetingInactivityPr
        return Task.CompletedTask;
    }

+    public Task DismissAllAsync(CancellationToken cancellationToken)
+    {
+        cancellationToken.ThrowIfCancellationRequested();
+        lock (notificationGate)
+        {
+            if (pendingPrompts.IsEmpty)
+            {
+                return Task.CompletedTask;
+            }
+
+            pendingPrompts.Clear();
+            if (!OperatingSystem.IsWindowsVersionAtLeast(10, 0, 17763))
+            {
+                return Task.CompletedTask;
+            }
+
+            try
+            {
+                ToastNotificationManagerCompat.History.RemoveGroup(NotificationGroup);
+                logger.LogInformation("Dismissed all native Windows inactivity notifications");
+            }
+            catch (Exception exception)
+            {
+                logger.LogWarning(exception, "Failed to dismiss native Windows inactivity notifications");
+            }
+
+            return Task.CompletedTask;
+        }
+    }
+
    public Task StopAsync(CancellationToken cancellationToken)
    {
        return Task.CompletedTask;
@@ -83,29 +116,28 @@ public sealed class WindowsMeetingInactivityPromptService : IMeetingInactivityPr

    public void Dispose()
    {
-        if (!registered)
+        lock (notificationGate)
        {
-            return;
-        }
+            if (!registered)
+            {
+                return;
+            }

-        try
-        {
-            ToastNotificationManagerCompat.OnActivated -= OnNotificationInvoked;
-        }
-        catch (Exception exception)
-        {
-            logger.LogWarning(exception, "Failed to detach native Windows toast notification activation handler");
+            try
+            {
+                ToastNotificationManagerCompat.OnActivated -= OnNotificationInvoked;
+                registered = false;
+            }
+            catch (Exception exception)
+            {
+                logger.LogWarning(exception, "Failed to detach native Windows toast notification activation handler");
+            }
        }
    }

    private void EnsureRegistered()
    {
-        if (registered)
-        {
-            return;
-        }
-
-        lock (registrationGate)
+        lock (notificationGate)
        {
            if (registered)
            {
@@ -122,29 +154,25 @@ public sealed class WindowsMeetingInactivityPromptService : IMeetingInactivityPr
        string promptId,
        MeetingInactivityPromptRequest request)
    {
-        var yesButton = new ToastButton()
-            .SetContent("Yes")
-            .AddArgument("source", NotificationSource)
-            .AddArgument("promptId", promptId)
-            .AddArgument("response", "stop")
-            .SetBackgroundActivation();
-
-        var noButton = new ToastButton()
-            .SetContent("No")
-            .AddArgument("source", NotificationSource)
-            .AddArgument("promptId", promptId)
-            .AddArgument("response", "continue")
-            .SetBackgroundActivation();
-
-        return new ToastContentBuilder()
+        var builder = new ToastContentBuilder()
            .AddArgument("source", NotificationSource)
            .AddArgument("promptId", promptId)
            .SetToastScenario(ToastScenario.Reminder)
            .SetToastDuration(ToastDuration.Long)
            .AddText("Stop meeting?")
-            .AddText($"No transcript text has arrived for {FormatDuration(request.InactivityDuration)}.")
-            .AddButton(yesButton)
-            .AddButton(noButton);
+            .AddText($"No transcript text has arrived for {FormatDuration(request.InactivityDuration)}.");
+
+        foreach (var action in MeetingInactivityPromptActions.All)
+        {
+            builder.AddButton(new ToastButton()
+                .SetContent(action.Content)
+                .AddArgument("source", NotificationSource)
+                .AddArgument("promptId", promptId)
+                .AddArgument("response", action.ResponseArgument)
+                .SetBackgroundActivation());
+        }
+
+        return builder;
    }

    private void OnNotificationInvoked(ToastNotificationActivatedEventArgsCompat args)
@@ -177,10 +205,9 @@ public sealed class WindowsMeetingInactivityPromptService : IMeetingInactivityPr
            return;
        }

-        var response = TryGetArgument(arguments, "response", out var responseValue) &&
-            string.Equals(responseValue, "stop", StringComparison.OrdinalIgnoreCase)
-                ? MeetingInactivityPromptResponse.Stop
-                : MeetingInactivityPromptResponse.Continue;
+        var response = TryGetArgument(arguments, "response", out var responseValue)
+            ? MeetingInactivityPromptActions.ParseResponse(responseValue)
+            : MeetingInactivityPromptResponse.Continue;
        _ = Task.Run(async () =>
        {
            try