Preserve recovery transcripts and add user-approved agent requests

Append successful offline recovery with a duplicate-warning marker and retain failed replay sources. Offer newly available microphones through confirmation notifications.

Add project discovery metadata and blocking association approval, plus nonblocking workflow requests that start a separate settings-agent conversation. Include regression tests, OpenSpec changes, and verified local Release startup.

MeetingAssistant.Tests/MicrophoneAudioSourceTests.cs

@@ -50,6 +50,145 @@ public sealed class MicrophoneAudioSourceTests
         await cancellation.CancelAsync();
     }
 
+    [Fact]
+    public async Task AcceptedNewMicrophoneReplacesCaptureWithinTheSameStream()
+    {
+        var selection = new MicrophoneDeviceSelection();
+        var devices = new SelectableCaptureDevices(selection);
+        var prompts = new AcceptingPrompt();
+        var monitor = new MicrophoneSwitchMonitor(devices, prompts,
+            NullLogger<MicrophoneSwitchMonitor>.Instance, TimeSpan.FromMilliseconds(10), TimeSpan.FromMinutes(1));
+        var source = new MicrophoneAudioSource(devices, NullLogger<MicrophoneAudioSource>.Instance,
+            TimeSpan.Zero, monitor, selection);
+        using var lifetime = new CancellationTokenSource(TimeSpan.FromSeconds(5));
+        await using var chunks = source.CaptureAsync(new MeetingAssistantOptions(), lifetime.Token).GetAsyncEnumerator();
+        try
+        {
+            Assert.True(await chunks.MoveNextAsync());
+            Assert.Equal(1_000, BitConverter.ToInt16(chunks.Current.Pcm));
+            devices.Available = [new("old", "Built-in"), new("new", "USB headset")];
+            Assert.Equal("new", (await prompts.Shown.Task.WaitAsync(TimeSpan.FromSeconds(2))).Id);
+            var nextChunk = chunks.MoveNextAsync().AsTask();
+            Assert.False(nextChunk.IsCompleted);
+            Assert.Null(selection.SelectedDeviceId);
+
+            prompts.Response.SetResult(true);
+
+            Assert.True(await nextChunk.WaitAsync(TimeSpan.FromSeconds(2)));
+            Assert.Equal(2_000, BitConverter.ToInt16(chunks.Current.Pcm));
+            Assert.Equal("new", selection.SelectedDeviceId);
+            Assert.False(lifetime.IsCancellationRequested);
+        }
+        finally
+        {
+            await lifetime.CancelAsync();
+        }
+    }
+
+    [Fact]
+    public async Task EndingMeetingDuringCreationDisposesAbandonedCapture()
+    {
+        using var lifetime = new CancellationTokenSource(TimeSpan.FromSeconds(5));
+        var abandonedCapture = new DisposableAudioSource();
+        var factory = new CallbackCaptureFactory(() =>
+        {
+            lifetime.Cancel();
+            return abandonedCapture;
+        });
+        var source = new MicrophoneAudioSource(factory, NullLogger<MicrophoneAudioSource>.Instance);
+        await using var chunks = source.CaptureAsync(lifetime.Token).GetAsyncEnumerator();
+
+        Assert.False(await chunks.MoveNextAsync());
+        Assert.True(abandonedCapture.Disposed);
+    }
+
+    private sealed class CallbackCaptureFactory(Func<IMeetingAudioSource> create) : IMicrophoneCaptureSourceFactory
+    {
+        public IMeetingAudioSource CreateCapture(MeetingAssistantOptions options) => create();
+    }
+
+    [Fact]
+    public async Task AcceptedSwitchDuringCreationDisposesAbandonedCapture()
+    {
+        var selection = new MicrophoneDeviceSelection();
+        var devices = new SwitchDuringCreationDevices(selection);
+        var prompts = new AcceptingPrompt();
+        prompts.Response.SetResult(true);
+        var monitor = new MicrophoneSwitchMonitor(devices, prompts,
+            NullLogger<MicrophoneSwitchMonitor>.Instance, TimeSpan.FromMilliseconds(10), TimeSpan.FromMinutes(1));
+        var source = new MicrophoneAudioSource(devices, NullLogger<MicrophoneAudioSource>.Instance,
+            TimeSpan.Zero, monitor, selection);
+        using var lifetime = new CancellationTokenSource(TimeSpan.FromSeconds(5));
+        await using var chunks = source.CaptureAsync(new MeetingAssistantOptions(), lifetime.Token).GetAsyncEnumerator();
+        try
+        {
+            Assert.True(await chunks.MoveNextAsync());
+            Assert.Equal("new", selection.SelectedDeviceId);
+            Assert.Equal(2_000, BitConverter.ToInt16(chunks.Current.Pcm));
+            Assert.True(devices.AbandonedCapture.Disposed);
+        }
+        finally
+        {
+            await lifetime.CancelAsync();
+        }
+    }
+
+    private sealed class SwitchDuringCreationDevices(MicrophoneDeviceSelection selection)
+        : IMicrophoneDeviceProvider, IMicrophoneCaptureSourceFactory
+    {
+        private MicrophoneDevice[] available = [new("old", "Built-in")];
+        private int creations;
+        private volatile bool switchObserved;
+        public DisposableAudioSource AbandonedCapture { get; } = new();
+        public IReadOnlyList<MicrophoneDevice> GetAvailableMicrophones()
+        {
+            if (selection.SelectedDeviceId == "new") switchObserved = true;
+            return Volatile.Read(ref available);
+        }
+        public MicrophoneDeviceSnapshot GetMicrophoneSnapshot(MeetingAssistantOptions options)
+            => new(GetAvailableMicrophones(), available[0]);
+
+        public IMeetingAudioSource CreateCapture(MeetingAssistantOptions options)
+        {
+            if (++creations > 1) return new ActiveAudioSource(Pcm16(2_000));
+            Volatile.Write(ref available, [new("old", "Built-in"), new("new", "USB headset")]);
+            // Let the acceptance callback finish before returning the already-opened source.
+            if (!SpinWait.SpinUntil(() => switchObserved, TimeSpan.FromSeconds(2)))
+                throw new TimeoutException("The new microphone was not selected during capture creation.");
+            return AbandonedCapture;
+        }
+    }
+
+    private sealed class DisposableAudioSource : IMeetingAudioSource, IDisposable
+    {
+        public bool Disposed { get; private set; }
+        public IAsyncEnumerable<AudioChunk> CaptureAsync(CancellationToken cancellationToken)
+            => new ActiveAudioSource(Pcm16(1_000)).CaptureAsync(cancellationToken);
+        public void Dispose() => Disposed = true;
+    }
+
+    private sealed class AcceptingPrompt : IMicrophoneSwitchPromptService
+    {
+        public TaskCompletionSource<MicrophoneDevice> Shown { get; } = new(TaskCreationOptions.RunContinuationsAsynchronously);
+        public TaskCompletionSource<bool> Response { get; } = new(TaskCreationOptions.RunContinuationsAsynchronously);
+        public Task<bool> ConfirmSwitchAsync(MicrophoneDevice microphone, CancellationToken cancellationToken)
+        {
+            Shown.TrySetResult(microphone);
+            return Response.Task.WaitAsync(cancellationToken);
+        }
+    }
+
+    private sealed class SelectableCaptureDevices(MicrophoneDeviceSelection selection)
+        : IMicrophoneDeviceProvider, IMicrophoneCaptureSourceFactory
+    {
+        public volatile MicrophoneDevice[] Available = [new("old", "Built-in")];
+        public IReadOnlyList<MicrophoneDevice> GetAvailableMicrophones() => Available;
+        public MicrophoneDeviceSnapshot GetMicrophoneSnapshot(MeetingAssistantOptions options)
+            => new(Available, selection.Resolve(options.Recording.MicrophoneDeviceId, Available[0], Available));
+        public IMeetingAudioSource CreateCapture(MeetingAssistantOptions options)
+            => new ActiveAudioSource(Pcm16(GetMicrophoneSnapshot(options).Current!.Id == "new" ? (short)2_000 : (short)1_000));
+    }
+
     private static byte[] Pcm16(short sample)
     {
         return BitConverter.GetBytes(sample);