chore(deps): update dependency microsoft.agents.ai.openai to 1.23.0

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/HealthEndpointTests.cs

@@ -1,6 +1,7 @@
 using System.Net;
 using System.Net.Http.Json;
 using MeetingAssistant.Recording;
+using MeetingAssistant.Workflow;
 using Microsoft.AspNetCore.Hosting;
 using Microsoft.AspNetCore.Mvc.Testing;
 using Microsoft.AspNetCore.TestHost;
@@ -41,6 +42,17 @@ public sealed class HealthEndpointTests : IClassFixture<WebApplicationFactory<Pr
         Assert.Equal("ok", body?.Status);
     }
 
+    [Fact]
+    public async Task NeutralBuildReportsSpeakerPlaybackUnavailable()
+    {
+        var playback = factory.Services.GetRequiredService<IWorkflowRulesEditorSamplePlaybackQueue>();
+
+        var result = await playback.QueueAsync(1, [1, 2]);
+
+        Assert.Contains("Windows build", result);
+        Assert.DoesNotContain("Queued", result);
+    }
+
     [Fact]
     public async Task ApplicationStartupDeletesStaleTemporaryRecordings()
     {

MeetingAssistant.Tests/MeetingAssistant.Tests.csproj

@@ -10,7 +10,7 @@
   <ItemGroup>
     <PackageReference Include="coverlet.collector" Version="10.0.1" />
     <PackageReference Include="Microsoft.AspNetCore.Mvc.Testing" Version="10.0.12" />
-    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="18.10.0" />
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="18.10.1" />
     <PackageReference Include="xunit" Version="2.9.3" />
     <PackageReference Include="xunit.runner.visualstudio" Version="4.0.0" />
   </ItemGroup>

MeetingAssistant.Tests/MeetingSummaryInstructionBuilderTests.cs

@@ -7,6 +7,37 @@ namespace MeetingAssistant.Tests;
 
 public sealed class MeetingSummaryInstructionBuilderTests
 {
+    [Fact]
+    public async Task BuilderAddsBoundMetadataWithoutAgentsAndRequestGuidanceToCustomPrompt()
+    {
+        var root = Path.Combine(Path.GetTempPath(), "meeting-assistant-tests", Guid.NewGuid().ToString("N"));
+        var projectsRoot = Path.Combine(root, "Projects");
+        var artifacts = CreateArtifacts(root);
+        await WriteMeetingNoteAsync(artifacts.MeetingNotePath, ["Alpha"]);
+        Directory.CreateDirectory(Path.Combine(projectsRoot, "Alpha"));
+        await File.WriteAllTextAsync(Path.Combine(projectsRoot, "Alpha", "PROJECT.md"),
+            "---\nname: Alpha Platform\ndescription: Builds meeting automation\n---\nInternal notes");
+        await WriteProjectAgentsAsync(projectsRoot, "Unbound", "Do not expose these instructions");
+        var builder = new MeetingSummaryInstructionBuilder(Options.Create(new MeetingAssistantOptions
+        {
+            Agent = new AgentOptions { InitialPrompt = "Custom base." },
+            Vault = new VaultOptions { ProjectsFolder = projectsRoot }
+        }));
+
+        var instructions = await builder.BuildAsync(artifacts, CancellationToken.None);
+
+        Assert.StartsWith("Custom base.", instructions);
+        Assert.Contains("# Alpha", instructions);
+        Assert.Contains("Alpha Platform", instructions);
+        Assert.Contains("Builds meeting automation", instructions);
+        Assert.Contains("PROJECT.md", instructions);
+        Assert.Contains("256", instructions);
+        Assert.Contains("request_project_association", instructions);
+        Assert.Contains("request_workflow_change", instructions);
+        Assert.DoesNotContain("Internal notes", instructions);
+        Assert.DoesNotContain("Do not expose", instructions);
+    }
+
     [Fact]
     public async Task BuilderUsesDefaultPromptWhenConfiguredPromptIsBlank()
     {
@@ -75,7 +106,8 @@ public sealed class MeetingSummaryInstructionBuilderTests
 
         var instructions = await builder.BuildAsync(artifacts, CancellationToken.None);
 
-        Assert.Equal("Custom summarizer instructions.", instructions);
+        Assert.StartsWith("Custom summarizer instructions.", instructions);
+        Assert.Contains("request_project_association", instructions);
     }
 
     [Fact]
@@ -96,21 +128,12 @@ public sealed class MeetingSummaryInstructionBuilderTests
 
         var instructions = await builder.BuildAsync(artifacts, CancellationToken.None);
 
-        var expected = """
-            Base.
-
-            ---
-            projects:
-
-            # Alpha
-
-            Alpha instructions.
-
-            # Beta
-
-            Beta instructions.
-            """;
-        Assert.Equal(NormalizeLineEndings(expected), NormalizeLineEndings(instructions));
+        Assert.StartsWith("Base.", instructions);
+        Assert.Contains("---\nprojects:", NormalizeLineEndings(instructions));
+        Assert.Contains("# Alpha", instructions);
+        Assert.Contains("Alpha instructions.", instructions);
+        Assert.Contains("# Beta", instructions);
+        Assert.Contains("Beta instructions.", instructions);
     }
 
     private static MeetingSessionArtifacts CreateArtifacts(string root)

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);

MeetingAssistant.Tests/MicrophoneSwitchMonitorTests.cs

@@ -0,0 +1,163 @@
+using System.Threading.Channels;
+using MeetingAssistant.Recording;
+using Microsoft.Extensions.Logging.Abstractions;
+
+namespace MeetingAssistant.Tests;
+
+public sealed class MicrophoneSwitchMonitorTests
+{
+    [Fact]
+    public async Task CancellationDuringConfirmationDeviceLookupCannotSwitchMicrophone()
+    {
+        using var lifetime = new CancellationTokenSource(TimeSpan.FromSeconds(5));
+        var devices = new MutableDevices();
+        var prompts = new ImmediatelyAcceptedPrompt(() => devices.BeforeRead = lifetime.Cancel);
+        var monitor = new MicrophoneSwitchMonitor(devices, prompts,
+            NullLogger<MicrophoneSwitchMonitor>.Instance, TimeSpan.FromMilliseconds(10), TimeSpan.FromMinutes(1));
+        var switched = false;
+        var monitoring = monitor.RunAsync((_, _) => switched = true, lifetime.Token);
+        devices.Available = [new("usb", "USB microphone")];
+
+        await monitoring.WaitAsync(TimeSpan.FromSeconds(2));
+
+        Assert.True(prompts.WasShown);
+        Assert.False(switched);
+    }
+
+    [Fact]
+    public async Task OffersOnlyNewDevicesOnceAndSwitchesOnlyAfterAcceptance()
+    {
+        var oldDevice = new MicrophoneDevice("old", "Built-in microphone");
+        var newDevice = new MicrophoneDevice("new", "USB headset");
+        var devices = new MutableDevices { Available = [oldDevice] };
+        var prompts = new ControlledPrompts();
+        var monitor = CreateMonitor(devices, prompts);
+        var switched = new TaskCompletionSource<MicrophoneDevice>(TaskCreationOptions.RunContinuationsAsynchronously);
+        using var lifetime = new CancellationTokenSource(TimeSpan.FromSeconds(5));
+        var monitoring = monitor.RunAsync((device, _) => switched.TrySetResult(device), lifetime.Token);
+        try
+        {
+            devices.Available = [oldDevice, newDevice];
+            var prompt = await prompts.NextAsync();
+            Assert.Equal(newDevice, prompt.Device);
+            Assert.False(switched.Task.IsCompleted);
+            await devices.WaitForPollsAsync();
+            Assert.False(prompts.HasMore);
+
+            prompt.Response.SetResult(true);
+            Assert.Equal(newDevice, await switched.Task.WaitAsync(TimeSpan.FromSeconds(2)));
+            await devices.WaitForPollsAsync();
+            Assert.False(prompts.HasMore);
+        }
+        finally
+        {
+            await lifetime.CancelAsync();
+            await monitoring;
+        }
+    }
+
+    [Theory]
+    [InlineData("declined")]
+    [InlineData("removed")]
+    [InlineData("expired")]
+    [InlineData("ended")]
+    public async Task InvalidOrDeclinedPromptsCannotChangeSelection(string outcome)
+    {
+        var device = new MicrophoneDevice("usb", "USB microphone");
+        var devices = new MutableDevices();
+        var prompts = new ControlledPrompts();
+        var monitor = CreateMonitor(devices, prompts,
+            outcome == "expired" ? TimeSpan.FromMilliseconds(30) : null);
+        var switched = false;
+        using var lifetime = new CancellationTokenSource(TimeSpan.FromSeconds(5));
+        var monitoring = monitor.RunAsync((_, _) => switched = true, lifetime.Token);
+        try
+        {
+            devices.Available = [device];
+            var prompt = await prompts.NextAsync();
+            if (outcome == "declined")
+            {
+                prompt.Response.SetResult(false);
+                await devices.WaitForPollsAsync();
+            }
+            else
+            {
+                if (outcome == "removed") devices.Available = [];
+                if (outcome == "ended") await lifetime.CancelAsync();
+                var canceled = new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously);
+                using var registration = prompt.Cancellation.Register(() => canceled.TrySetResult());
+                await canceled.Task.WaitAsync(TimeSpan.FromSeconds(2));
+                prompt.Response.TrySetResult(true);
+            }
+
+            await lifetime.CancelAsync();
+            await monitoring;
+            Assert.False(switched);
+        }
+        finally
+        {
+            await lifetime.CancelAsync();
+            await monitoring;
+        }
+    }
+
+    private static MicrophoneSwitchMonitor CreateMonitor(MutableDevices devices, ControlledPrompts prompts,
+        TimeSpan? promptLifetime = null) => new(devices, prompts,
+        NullLogger<MicrophoneSwitchMonitor>.Instance, TimeSpan.FromMilliseconds(10),
+        promptLifetime ?? TimeSpan.FromMinutes(1));
+
+    private sealed class MutableDevices : IMicrophoneDeviceProvider
+    {
+        private readonly Channel<bool> polls = Channel.CreateUnbounded<bool>();
+        public volatile MicrophoneDevice[] Available = [];
+        public Action? BeforeRead { get; set; }
+
+        public IReadOnlyList<MicrophoneDevice> GetAvailableMicrophones()
+        {
+            BeforeRead?.Invoke();
+            polls.Writer.TryWrite(true);
+            return Available;
+        }
+
+        public MicrophoneDeviceSnapshot GetMicrophoneSnapshot(MeetingAssistantOptions options)
+            => new(Available, Available.FirstOrDefault());
+
+        public async Task WaitForPollsAsync()
+        {
+            while (polls.Reader.TryRead(out _)) { }
+            for (var i = 0; i < 3; i++)
+                await polls.Reader.ReadAsync().AsTask().WaitAsync(TimeSpan.FromSeconds(2));
+        }
+    }
+
+    private sealed class ImmediatelyAcceptedPrompt(Action beforeAcceptance) : IMicrophoneSwitchPromptService
+    {
+        public bool WasShown { get; private set; }
+
+        public Task<bool> ConfirmSwitchAsync(MicrophoneDevice microphone, CancellationToken cancellationToken)
+        {
+            WasShown = true;
+            beforeAcceptance();
+            return Task.FromResult(true);
+        }
+    }
+
+    private sealed class ControlledPrompts : IMicrophoneSwitchPromptService
+    {
+        private readonly Channel<Prompt> requests = Channel.CreateUnbounded<Prompt>();
+        public bool HasMore => requests.Reader.TryPeek(out _);
+        public Task<Prompt> NextAsync() => requests.Reader.ReadAsync().AsTask().WaitAsync(TimeSpan.FromSeconds(2));
+
+        public async Task<bool> ConfirmSwitchAsync(MicrophoneDevice microphone, CancellationToken cancellationToken)
+        {
+            var prompt = new Prompt(microphone, cancellationToken);
+            requests.Writer.TryWrite(prompt);
+            return await prompt.Response.Task.WaitAsync(cancellationToken);
+        }
+    }
+
+    private sealed record Prompt(MicrophoneDevice Device, CancellationToken Cancellation)
+    {
+        public TaskCompletionSource<bool> Response { get; } = new(TaskCreationOptions.RunContinuationsAsynchronously);
+    }
+}

MeetingAssistant.Tests/ProjectKnowledgeToolTests.cs

@@ -1,10 +1,90 @@
 using MeetingAssistant.MeetingNotes;
 using MeetingAssistant.Summary;
+using System.Text.Json;
 
 namespace MeetingAssistant.Tests;
 
 public sealed class ProjectKnowledgeToolTests
 {
+    [Theory]
+    [InlineData("name: Incomplete project")]
+    [InlineData("description: Missing name")]
+    [InlineData("name: ' '\ndescription: Missing name")]
+    public async Task CatalogUsesLegacyFallbackForIncompleteMetadata(string frontmatter)
+    {
+        var root = Path.Combine(Path.GetTempPath(), "meeting-assistant-tests", Guid.NewGuid().ToString("N"));
+        var projectRoot = Path.Combine(root, "Projects", "Alpha");
+        Directory.CreateDirectory(projectRoot);
+        await File.WriteAllTextAsync(Path.Combine(projectRoot, "PROJECT.md"), $"---\n{frontmatter}\n---\nNotes");
+        var tools = new MeetingSummaryTools(CreateArtifacts(root),
+            new MeetingAssistantOptions { Vault = { ProjectsFolder = Path.Combine(root, "Projects") } });
+
+        using var catalog = JsonDocument.Parse(await tools.ListProjects());
+
+        var project = Assert.Single(catalog.RootElement.EnumerateArray());
+        Assert.Equal("Alpha", project.GetProperty("displayname").GetString());
+        Assert.Equal("", project.GetProperty("description").GetString());
+    }
+
+    [Fact]
+    public async Task ProjectMetadataWriteEnforcesDescriptionLimitAndPreservesOtherContent()
+    {
+        var root = Path.Combine(Path.GetTempPath(), "meeting-assistant-tests", Guid.NewGuid().ToString("N"));
+        var projectRoot = Path.Combine(root, "Projects", "Alpha");
+        Directory.CreateDirectory(projectRoot);
+        var artifacts = CreateArtifacts(root);
+        Directory.CreateDirectory(Path.GetDirectoryName(artifacts.MeetingNotePath)!);
+        await File.WriteAllTextAsync(artifacts.MeetingNotePath, "---\nprojects: Alpha\n---");
+        var tools = new MeetingSummaryTools(artifacts,
+            new MeetingAssistantOptions { Vault = { ProjectsFolder = Path.Combine(root, "Projects") } });
+        var original = $"---\nname: Alpha Platform\ndescription: {new string('a', 256)}\nowner: Ada\n---\nUser-authored project notes.";
+        Assert.Equal("Alpha/PROJECT.md", await tools.WriteProjectFile("Alpha", "PROJECT.md", original));
+
+        var rejected = await tools.WriteProjectFile("Alpha", "PROJECT.md",
+            $"description: {new string('b', 257)}", from: 3, to: 3);
+
+        Assert.StartsWith("Refused:", rejected);
+        Assert.Equal(original, await File.ReadAllTextAsync(Path.Combine(projectRoot, "PROJECT.md")));
+        Assert.StartsWith("Refused:", await tools.WriteProjectFile("Alpha", "PROJECT.md", "No metadata", replace_file: true));
+        Assert.Equal("Alpha/PROJECT.md", await tools.WriteProjectFile("Alpha", "PROJECT.md",
+            "description: Updated project purpose", from: 3, to: 3));
+        var updated = await tools.ReadProjectFile("Alpha", "PROJECT.md");
+        Assert.Contains("owner: Ada", updated);
+        Assert.Contains("User-authored project notes.", updated);
+        Assert.Contains("Updated project purpose", await tools.ListProjects());
+    }
+
+    [Fact]
+    public async Task CatalogListsAllProjectsWithMetadataAndLegacyFallbackWithoutGrantingReadAccess()
+    {
+        var root = Path.Combine(Path.GetTempPath(), "meeting-assistant-tests", Guid.NewGuid().ToString("N"));
+        var projectsRoot = Path.Combine(root, "Projects");
+        Directory.CreateDirectory(Path.Combine(projectsRoot, "Alpha"));
+        Directory.CreateDirectory(Path.Combine(projectsRoot, "Legacy"));
+        Directory.CreateDirectory(Path.Combine(projectsRoot, "Malformed"));
+        await File.WriteAllTextAsync(Path.Combine(projectsRoot, "Alpha", "PROJECT.md"),
+            "---\nname: Alpha Platform\ndescription: Meeting automation\n---\nPrivate project notes");
+        await File.WriteAllTextAsync(Path.Combine(projectsRoot, "Alpha", "AGENTS.md"), "Private instructions");
+        await File.WriteAllTextAsync(Path.Combine(projectsRoot, "Malformed", "PROJECT.md"), "---\nname: [broken\n---");
+        var tools = new MeetingSummaryTools(CreateArtifacts(root),
+            new MeetingAssistantOptions { Vault = { ProjectsFolder = projectsRoot } });
+
+        var catalog = await tools.ListProjects();
+
+        using var json = JsonDocument.Parse(catalog);
+        var projects = json.RootElement.EnumerateArray().ToArray();
+        Assert.Equal(3, projects.Length);
+        Assert.Equal("Alpha", projects[0].GetProperty("id").GetString());
+        Assert.Equal("Alpha Platform", projects[0].GetProperty("displayname").GetString());
+        Assert.Equal("Meeting automation", projects[0].GetProperty("description").GetString());
+        Assert.Equal("Legacy", projects[1].GetProperty("displayname").GetString());
+        Assert.Equal("", projects[1].GetProperty("description").GetString());
+        Assert.Equal("Malformed", projects[2].GetProperty("displayname").GetString());
+        Assert.Equal("", projects[2].GetProperty("description").GetString());
+        Assert.DoesNotContain("Private", catalog);
+        Assert.Equal("", await tools.ReadProjectFile("Alpha", "AGENTS.md"));
+    }
+
     [Fact]
     public async Task ToolsOperateOnProjectsBoundInMeetingFrontmatter()
     {
@@ -48,7 +128,7 @@ public sealed class ProjectKnowledgeToolTests
                 }
             });
 
-        Assert.Equal("MeetingAssistant", await tools.ListProjects());
+        Assert.Contains("MeetingAssistant", await tools.ListProjects());
         Assert.Equal("README.md\nnotes/context.md", await tools.ListProjectFiles("MeetingAssistant"));
         Assert.Equal("Second alpha line\nThird beta line", await tools.ReadProjectFile("MeetingAssistant", "README.md", 2, 99));
 
@@ -56,15 +136,15 @@ public sealed class ProjectKnowledgeToolTests
 
         Assert.Equal("MeetingAssistant/notes/summary.md", writeResult);
         Assert.Equal("# Project Update", await File.ReadAllTextAsync(Path.Combine(meetingAssistantRoot, "notes", "summary.md")));
-        Assert.Equal("IgnoredProject/ignored.md", await tools.WriteProjectFile("IgnoredProject", "ignored.md", "changed"));
-        Assert.Equal("alpha should not be searched\nchanged", await File.ReadAllTextAsync(Path.Combine(ignoredRoot, "ignored.md")));
+        Assert.StartsWith("Refused:", await tools.WriteProjectFile("IgnoredProject", "ignored.md", "changed"));
+        Assert.Equal("alpha should not be searched", await File.ReadAllTextAsync(Path.Combine(ignoredRoot, "ignored.md")));
         Assert.Equal(
             "README.md:2 Second alpha line",
             await tools.Search("alpha"));
     }
 
     [Fact]
-    public async Task ListProjectsAcceptsScalarProjectFrontmatter()
+    public async Task ProjectFileAccessAcceptsScalarProjectFrontmatter()
     {
         var root = Path.Combine(Path.GetTempPath(), "meeting-assistant-tests", Guid.NewGuid().ToString("N"));
         var projectsRoot = Path.Combine(root, "Projects");
@@ -88,7 +168,8 @@ public sealed class ProjectKnowledgeToolTests
                 }
             });
 
-        Assert.Equal("MeetingAssistant", await tools.ListProjects());
+        Assert.Equal("MeetingAssistant/notes.md", await tools.WriteProjectFile("MeetingAssistant", "notes.md", "Bound project"));
+        Assert.Equal("Bound project", await tools.ReadProjectFile("MeetingAssistant", "notes.md"));
     }
 
     [Fact]
@@ -100,8 +181,11 @@ public sealed class ProjectKnowledgeToolTests
         Directory.CreateDirectory(projectRoot);
         var projectFile = Path.Combine(projectRoot, "notes.md");
         await File.WriteAllTextAsync(projectFile, "one\ntwo\nthree\nfour");
+        var artifacts = CreateArtifacts(root);
+        Directory.CreateDirectory(Path.GetDirectoryName(artifacts.MeetingNotePath)!);
+        await File.WriteAllTextAsync(artifacts.MeetingNotePath, "---\nprojects: MeetingAssistant\n---\n");
         var tools = new MeetingSummaryTools(
-            CreateArtifacts(root),
+            artifacts,
             new MeetingAssistantOptions
             {
                 Vault =
@@ -132,8 +216,13 @@ public sealed class ProjectKnowledgeToolTests
         var root = Path.Combine(Path.GetTempPath(), "meeting-assistant-tests", Guid.NewGuid().ToString("N"));
         var projectsRoot = Path.Combine(root, "Projects");
         Directory.CreateDirectory(Path.Combine(projectsRoot, "MeetingAssistant"));
+        var artifacts = CreateArtifacts(root);
+        Directory.CreateDirectory(Path.GetDirectoryName(artifacts.MeetingNotePath)!);
+        await File.WriteAllTextAsync(artifacts.MeetingNotePath, "---\nprojects: MeetingAssistant\n---\n");
+        var outsidePath = Path.Combine(projectsRoot, "outside.md");
+        await File.WriteAllTextAsync(outsidePath, "Preserve outside content");
         var tools = new MeetingSummaryTools(
-            CreateArtifacts(root),
+            artifacts,
             new MeetingAssistantOptions
             {
                 Vault =
@@ -144,6 +233,7 @@ public sealed class ProjectKnowledgeToolTests
 
         Assert.StartsWith("Refused:", await tools.WriteProjectFile("MissingProject", "notes.md", "content"));
         Assert.StartsWith("Refused:", await tools.WriteProjectFile("MeetingAssistant", "../outside.md", "content"));
+        Assert.Equal("Preserve outside content", await File.ReadAllTextAsync(outsidePath));
         Assert.StartsWith("Refused:", await tools.WriteProjectFile("MeetingAssistant", "notes.md", "content", from: 1));
         Assert.StartsWith("Refused:", await tools.WriteProjectFile("MeetingAssistant", "notes.md", "content", from: 1, to: 1, insert: 1));
         Assert.StartsWith("Refused:", await tools.WriteProjectFile("MeetingAssistant", "notes.md", "content", from: 1, to: 1, replace_file: true));

MeetingAssistant.Tests/RecordingCoordinatorTests.cs

@@ -2170,8 +2170,8 @@ public sealed class RecordingCoordinatorTests
         Assert.Equal(1, processed);
         Assert.Empty(backlog.Items);
         Assert.Equal(["english"], pipelineFactory.ProfileNames);
-        var segment = Assert.Single(transcriptStore.ReplacedSegments);
-        Assert.Contains("english chunk:4", segment.Text, StringComparison.Ordinal);
+        Assert.Single(transcriptStore.Segments, segment => segment.Text.Contains("english chunk:4", StringComparison.Ordinal));
+        Assert.Contains(transcriptStore.Segments, segment => segment.Text.Contains("may duplicate earlier transcript passages", StringComparison.Ordinal));
         Assert.Equal(stoppedAt, noteStore.SavedNote?.Frontmatter.EndTime);
         Assert.True(summaryPipeline.WasRun);
         Assert.Equal(
@@ -2182,6 +2182,167 @@ public sealed class RecordingCoordinatorTests
             workflowEvent.TranscriptLineText?.Contains("english chunk:4", StringComparison.Ordinal) == true);
     }
 
+    [Theory]
+    [InlineData(null, false)]
+    [InlineData("", false)]
+    [InlineData(" \t", false)]
+    [InlineData("<Reconnecting... 1/5>", true)]
+    public async Task OfflineReplayWithoutSpeechPreservesTranscriptAndRecoveryFilesUntilSuccessfulRetry(
+        string? replayText, bool isMarker)
+    {
+        var root = Path.Combine(Path.GetTempPath(), "meeting-assistant-tests", Guid.NewGuid().ToString("N"));
+        Directory.CreateDirectory(root);
+        try
+        {
+            var audioPath = Path.Combine(root, "queued.wav");
+            using (var writer = new NAudio.Wave.WaveFileWriter(audioPath, new NAudio.Wave.WaveFormat(16000, 16, 1)))
+            {
+                writer.Write([1, 0, 2, 0], 0, 4);
+            }
+
+            var options = Options.Create(new MeetingAssistantOptions
+            {
+                Vault = new VaultOptions { BaseFolder = root, MeetingNotesFolder = "Notes", TranscriptsFolder = "Transcripts" },
+                Recording = new RecordingOptions { TemporaryRecordingsFolder = root }
+            });
+            var transcriptStore = new VaultTranscriptStore(options, NullLogger<VaultTranscriptStore>.Instance);
+            var noteStore = new MarkdownMeetingNoteStore(options, NullLogger<MarkdownMeetingNoteStore>.Instance);
+            var artifactStore = new InMemoryMeetingArtifactStore();
+            var summaryPipeline = new TranscriptReadingSummaryPipeline();
+            var workflowEngine = new CapturingMeetingWorkflowEngine();
+            var backlog = new FileOfflineTranscriptionBacklog(options, NullLogger<FileOfflineTranscriptionBacklog>.Instance);
+            var startedAt = DateTimeOffset.Now.AddMinutes(-5);
+            var stoppedAt = startedAt.AddMinutes(4);
+            var session = await transcriptStore.CreateSessionAsync(options.Value, startedAt, CancellationToken.None);
+            var artifacts = new MeetingSessionArtifacts(
+                Path.Combine(root, "meeting.md"), session.TranscriptPath,
+                Path.Combine(root, "context.md"), Path.Combine(root, "summary.md"));
+            var note = await noteStore.SaveAsync(new MeetingNote(
+                artifacts.MeetingNotePath,
+                new MeetingNoteFrontmatter
+                {
+                    Title = "Queued meeting", StartTime = startedAt,
+                    Transcript = session.TranscriptPath,
+                    AssistantContext = artifacts.AssistantContextPath,
+                    Summary = artifacts.SummaryPath
+                },
+                "Existing user notes"), CancellationToken.None);
+            await transcriptStore.UpdateMetadataAsync(session, artifacts, note, CancellationToken.None);
+            await transcriptStore.AppendLineAsync(session, "[00:00:01] Ada: Preserve this live transcript.", CancellationToken.None);
+            await File.AppendAllTextAsync(session.TranscriptPath, "User correction: keep the original speaker names.");
+            var originalTranscript = await File.ReadAllBytesAsync(session.TranscriptPath);
+            var originalBody = MeetingArtifactFrontmatterRenderer.Split(await File.ReadAllTextAsync(session.TranscriptPath)).Body;
+            var originalNote = await File.ReadAllBytesAsync(note.Path);
+            var originalAudio = await File.ReadAllBytesAsync(audioPath);
+            var item = new OfflineTranscriptionBacklogItem(
+                "queued", audioPath, session.TranscriptPath, note.Path,
+                artifacts.AssistantContextPath, artifacts.SummaryPath, startedAt, stoppedAt, "default");
+            await backlog.EnqueueAsync(item, CancellationToken.None);
+            var replaySegments = new List<TranscriptionSegment>();
+            if (replayText is not null)
+            {
+                replaySegments.Add(new TranscriptionSegment(
+                    TimeSpan.Zero, TimeSpan.FromSeconds(1), "Unknown", replayText,
+                    isMarker ? TranscriptionSegmentKind.Marker : TranscriptionSegmentKind.Speech));
+            }
+
+            var processor = new OfflineTranscriptionBacklogProcessor(
+                backlog,
+                new TestSpeechRecognitionPipelineFactory(new SequencedStreamingTranscriptionProvider(replaySegments)),
+                transcriptStore, noteStore, artifactStore, summaryPipeline, workflowEngine,
+                CreateRecordingDictationWordProvider(new FixedDictationWordStore([])), options,
+                NullLogger<OfflineTranscriptionBacklogProcessor>.Instance);
+
+            for (var attempt = 0; attempt < 2; attempt++)
+            {
+                var processed = await processor.ProcessPendingAsync(CancellationToken.None);
+
+                Assert.Equal(originalTranscript, await File.ReadAllBytesAsync(session.TranscriptPath));
+                Assert.Equal(0, processed);
+                Assert.Equal(originalNote, await File.ReadAllBytesAsync(note.Path));
+                Assert.Equal(originalAudio, await File.ReadAllBytesAsync(audioPath));
+                var reloadedBacklog = new FileOfflineTranscriptionBacklog(options, NullLogger<FileOfflineTranscriptionBacklog>.Instance);
+                Assert.Equal(item, Assert.Single(await reloadedBacklog.ListAsync(CancellationToken.None)));
+                Assert.Null(summaryPipeline.Transcript);
+                Assert.Empty(artifactStore.States);
+                Assert.Empty(workflowEngine.Events);
+            }
+
+            replaySegments.Clear();
+            replaySegments.Add(new TranscriptionSegment(
+                TimeSpan.Zero, TimeSpan.FromSeconds(1), "Ada", "Preserve this live transcript. Recovered speech."));
+
+            Assert.Equal(1, await processor.ProcessPendingAsync(CancellationToken.None));
+            var recoveredTranscript = await File.ReadAllTextAsync(session.TranscriptPath);
+            Assert.Contains("Recovered speech.", recoveredTranscript, StringComparison.Ordinal);
+            var recoveredBody = MeetingArtifactFrontmatterRenderer.Split(recoveredTranscript).Body;
+            Assert.StartsWith(originalBody, recoveredBody, StringComparison.Ordinal);
+            Assert.Equal(2, recoveredBody.Split("Preserve this live transcript.", StringSplitOptions.None).Length - 1);
+            var appended = recoveredBody[originalBody.Length..];
+            Assert.StartsWith(Environment.NewLine + "## Offline transcription recovery", appended, StringComparison.Ordinal);
+            Assert.Contains("may duplicate earlier transcript passages", appended, StringComparison.Ordinal);
+            Assert.Contains("Treat repeated passages as the same discussion when summarizing", appended, StringComparison.Ordinal);
+            Assert.True(appended.IndexOf("may duplicate", StringComparison.Ordinal) < appended.IndexOf("Recovered speech.", StringComparison.Ordinal));
+            Assert.Equal(stoppedAt, (await noteStore.ReadAsync(note.Path, CancellationToken.None)).Frontmatter.EndTime);
+            Assert.Equal(recoveredTranscript, summaryPipeline.Transcript);
+            Assert.Equal(new[] { AssistantContextState.Summarizing, AssistantContextState.Finished }, artifactStore.States);
+            Assert.Empty(await backlog.ListAsync(CancellationToken.None));
+            Assert.False(File.Exists(audioPath));
+        }
+        finally
+        {
+            Directory.Delete(root, recursive: true);
+        }
+    }
+
+    [Fact]
+    public async Task StopTimeoutKeepsSummaryApprovalAliveWithoutQueuingOfflineReplay()
+    {
+        var audioSource = new CapturedChunkThenCancelAudioSource(new AudioChunk([1, 0, 2, 0], 16000, 1));
+        var summary = new WaitingForApprovalSummaryPipeline();
+        var backlog = new InMemoryOfflineTranscriptionBacklog();
+        var artifacts = new InMemoryMeetingArtifactStore();
+        var coordinator = new MeetingRecordingCoordinator(
+            audioSource, new TestSpeechRecognitionPipelineFactory(new FinalSegmentOnAudioCompletionProvider()),
+            new InMemoryTranscriptStore(), new InMemoryMeetingNoteStore(), new CapturingMeetingNoteOpener(),
+            artifacts, new InMemoryRecordedAudioStore(), summary,
+            Options.Create(new MeetingAssistantOptions
+            {
+                Recording = new RecordingOptions
+                {
+                    TranscriptionProvider = "azure-speech",
+                    StopProcessingTimeout = TimeSpan.FromMilliseconds(500)
+                }
+            }), NullLogger<MeetingRecordingCoordinator>.Instance, offlineTranscriptionBacklog: backlog);
+        await coordinator.StartAsync(CancellationToken.None);
+        await audioSource.WaitUntilCapturedAsync();
+        var stopping = coordinator.StopAsync(CancellationToken.None);
+        await summary.Started.Task.WaitAsync(TimeSpan.FromSeconds(2));
+        try
+        {
+            var status = await stopping.WaitAsync(TimeSpan.FromSeconds(2));
+            Assert.False(status.IsRecording);
+            Assert.False(summary.Cancellation.IsCancellationRequested);
+            Assert.Empty(backlog.Items);
+        }
+        finally { summary.Release.TrySetResult(); }
+        await WaitUntilAsync(() => artifacts.States.Contains(AssistantContextState.Finished), "Approved summary did not finish.");
+    }
+
+    private sealed class WaitingForApprovalSummaryPipeline : IMeetingSummaryPipeline
+    {
+        public TaskCompletionSource Started { get; } = new(TaskCreationOptions.RunContinuationsAsynchronously);
+        public TaskCompletionSource Release { get; } = new(TaskCreationOptions.RunContinuationsAsynchronously);
+        public CancellationToken Cancellation { get; private set; }
+        public async Task<MeetingSummaryRunResult> RunAsync(MeetingSessionArtifacts artifacts, CancellationToken cancellationToken)
+        {
+            Cancellation = cancellationToken;
+            Started.TrySetResult();
+            await Release.Task.WaitAsync(cancellationToken);
+            return new MeetingSummaryRunResult(artifacts.SummaryPath, "Approved and completed");
+        }
+    }
+
     [Fact]
     public async Task AbortStopsRecordingDeletesArtifactsAndSkipsSummary()
     {
@@ -2386,12 +2547,17 @@ public sealed class RecordingCoordinatorTests
         await coordinator.StopAsync(CancellationToken.None);
     }
 
-    [Fact]
-    public async Task ToggleToDifferentLaunchProfileBuffersAudioCapturedWhilePreviousPipelineDrains()
+    [Theory]
+    [InlineData("default", "english")]
+    [InlineData("english", "default")]
+    public async Task ProfileSwitchDrainsFinalTranscriptAndResumesBufferedAudioWithoutBlockingNotifications(
+        string initialProfile,
+        string targetProfile)
     {
         var audioSource = new ControlledAudioSource();
         var pipelineFactory = new BlockingProfileSwitchSpeechRecognitionPipelineFactory();
         var transcriptStore = new InMemoryTranscriptStore();
+        var promptService = new IgnoringMeetingInactivityPromptService();
         var launchProfiles = CreateLaunchProfiles(
             Path.Combine(Path.GetTempPath(), "meeting-assistant-tests", Guid.NewGuid().ToString("N"), "default"),
             Path.Combine(Path.GetTempPath(), "meeting-assistant-tests", Guid.NewGuid().ToString("N"), "english"));
@@ -2406,13 +2572,16 @@ public sealed class RecordingCoordinatorTests
             new CapturingMeetingSummaryPipeline(),
             Options.Create(launchProfiles.GetRequiredProfile(null).Options),
             NullLogger<MeetingRecordingCoordinator>.Instance,
+            inactivityPromptService: promptService,
             launchProfiles: launchProfiles);
 
-        await coordinator.StartAsync(CancellationToken.None);
+        await coordinator.StartAsync(initialProfile, CancellationToken.None);
         await audioSource.WriteAsync(new AudioChunk([1, 0], 16000, 1), CancellationToken.None);
-        await transcriptStore.WaitForTextAsync("default chunk:2");
+        await transcriptStore.WaitForTextAsync($"{initialProfile} chunk:2");
+        await WaitUntilAsync(() => promptService.DismissAllCount == 1);
 
-        var switchTask = coordinator.ToggleAsync("english", CancellationToken.None);
+        using var switchCancellation = new CancellationTokenSource(TimeSpan.FromSeconds(10));
+        var switchTask = coordinator.ToggleAsync(targetProfile, switchCancellation.Token);
         await pipelineFactory.WaitUntilFirstPipelineDrainIsBlockedAsync();
         await audioSource.WriteAsync(new AudioChunk([1, 0, 2, 0, 3, 0], 16000, 1), CancellationToken.None);
 
@@ -2420,10 +2589,21 @@ public sealed class RecordingCoordinatorTests
 
         pipelineFactory.ReleaseFirstPipelineDrain();
         await switchTask.WaitAsync(TimeSpan.FromSeconds(5));
-        await transcriptStore.WaitForTextAsync("english chunk:6");
+        await transcriptStore.WaitForTextAsync($"{targetProfile} chunk:6");
+        await WaitUntilAsync(() => promptService.DismissAllCount == 3);
 
-        Assert.Equal([null, "english"], pipelineFactory.ProfileNames);
-        await coordinator.StopAsync(CancellationToken.None);
+        Assert.Equal(targetProfile, coordinator.CurrentStatus.LaunchProfile);
+        Assert.Equal([initialProfile, targetProfile], pipelineFactory.ProfileNames);
+        var segments = transcriptStore.Segments.ToList();
+        var finalResultIndex = segments.FindIndex(segment => segment.Text == "Final result emitted while switching profiles.");
+        var markerIndex = segments.FindIndex(segment => segment.Text.Contains($"Transcription profile changed to {targetProfile}", StringComparison.Ordinal));
+        Assert.True(finalResultIndex >= 0 && finalResultIndex < markerIndex);
+
+        await coordinator.ToggleAsync(initialProfile, CancellationToken.None).WaitAsync(TimeSpan.FromSeconds(5));
+        await audioSource.WriteAsync(new AudioChunk([1, 0, 2, 0], 16000, 1), CancellationToken.None);
+        await transcriptStore.WaitForTextAsync($"{initialProfile} chunk:4");
+        await coordinator.StopAsync(CancellationToken.None).WaitAsync(TimeSpan.FromSeconds(5));
+        Assert.False(coordinator.CurrentStatus.IsRecording);
     }
 
     [Fact]
@@ -4529,6 +4709,19 @@ public sealed class RecordingCoordinatorTests
         }
     }
 
+    private sealed class TranscriptReadingSummaryPipeline : IMeetingSummaryPipeline
+    {
+        public string? Transcript { get; private set; }
+
+        public async Task<MeetingSummaryRunResult> RunAsync(
+            MeetingSessionArtifacts artifacts,
+            CancellationToken cancellationToken)
+        {
+            Transcript = await File.ReadAllTextAsync(artifacts.TranscriptPath, cancellationToken);
+            return new MeetingSummaryRunResult(artifacts.SummaryPath, "summary ok", true);
+        }
+    }
+
     private sealed class CapturingMeetingSummaryPipeline : IMeetingSummaryPipeline
     {
         private readonly bool succeeded;
@@ -5140,6 +5333,11 @@ public sealed class RecordingCoordinatorTests
 
             drainBlocked.TrySetResult();
             await releaseDrain.Task.WaitAsync(cancellationToken);
+            yield return new TranscriptionSegment(
+                TimeSpan.Zero,
+                TimeSpan.FromSeconds(3),
+                "Unknown",
+                "Final result emitted while switching profiles.");
         }
     }
 

MeetingAssistant.Tests/SummaryAgentRequestTests.cs

@@ -0,0 +1,209 @@
+using System.Threading.Channels;
+using MeetingAssistant.MeetingNotes;
+using MeetingAssistant.Notifications;
+using MeetingAssistant.Summary;
+using Microsoft.Extensions.Logging.Abstractions;
+using MeetingAssistant.Workflow;
+
+namespace MeetingAssistant.Tests;
+
+public sealed class SummaryAgentRequestTests
+{
+    [Theory]
+    [InlineData("denied")]
+    [InlineData("expired")]
+    [InlineData("shutdown")]
+    public async Task WorkflowDenialExpirationAndShutdownRemovePromptWithoutStartingAgent(string outcome)
+    {
+        var prompts = new ControlledPrompts();
+        var editor = new RecordingEditor();
+        var approvals = new AgentApprovalService(prompts, NullLogger<AgentApprovalService>.Instance,
+            outcome == "expired" ? TimeSpan.FromMilliseconds(100) : TimeSpan.FromMinutes(10));
+        using var requests = new WorkflowChangeRequestService(approvals, editor, NullLogger<WorkflowChangeRequestService>.Instance);
+        await requests.StartAsync(CancellationToken.None);
+        try
+        {
+            Assert.StartsWith("Requested", requests.Request("Add association rule", "Given Alpha, then associate Alpha.", "meeting.md"));
+            var prompt = await prompts.NextAsync();
+            if (outcome == "denied") prompt.Response.SetResult(false);
+            if (outcome == "shutdown") await requests.StopAsync(CancellationToken.None);
+            await prompt.Removed.Task.WaitAsync(TimeSpan.FromSeconds(2));
+            prompt.Response.TrySetResult(true);
+        }
+        finally { await requests.StopAsync(CancellationToken.None); }
+        Assert.Empty(editor.Prompts);
+        Assert.StartsWith("Refused", requests.Request("Too late", "Do something", "meeting.md"));
+    }
+
+    [Fact]
+    public async Task InvalidRequestsAreRefusedBeforeNotification()
+    {
+        var fixture = await CreateAsync();
+        var original = await File.ReadAllTextAsync(fixture.Artifacts.MeetingNotePath);
+        var prompts = new ControlledPrompts();
+        var approvals = new AgentApprovalService(prompts, NullLogger<AgentApprovalService>.Instance);
+        using var requests = new WorkflowChangeRequestService(approvals, new RecordingEditor(), NullLogger<WorkflowChangeRequestService>.Instance);
+        var tools = new MeetingSummaryTools(fixture.Artifacts, fixture.Options, approvals: approvals, workflowRequests: requests);
+
+        Assert.StartsWith("Refused", await tools.RequestProjectAssociation("../Alpha", "Relevant"));
+        Assert.StartsWith("Refused", await tools.RequestProjectAssociation("Alpha", new string('a', 101)));
+        Assert.StartsWith("Refused", await tools.RequestProjectAssociation("Alpha", "two\nlines"));
+        Assert.StartsWith("Refused", await tools.RequestProjectAssociation("Alpha", ""));
+        Assert.StartsWith("Refused", tools.RequestWorkflowChange(new string('a', 101), "Detailed scenario"));
+        Assert.StartsWith("Refused", tools.RequestWorkflowChange("Intent", " "));
+        Assert.StartsWith("Refused", tools.RequestWorkflowChange("two\nlines", "Detailed scenario"));
+        Assert.False(prompts.HasMore);
+        Assert.Equal(original, await File.ReadAllTextAsync(fixture.Artifacts.MeetingNotePath));
+    }
+
+    [Fact]
+    public async Task WorkflowRequestReturnsImmediatelyAndApprovalStartsItsDetailedPromptOnce()
+    {
+        var fixture = await CreateAsync();
+        var prompts = new ControlledPrompts();
+        var editor = new RecordingEditor();
+        var approvals = new AgentApprovalService(prompts, NullLogger<AgentApprovalService>.Instance);
+        using var requests = new WorkflowChangeRequestService(approvals, editor, NullLogger<WorkflowChangeRequestService>.Instance);
+        await requests.StartAsync(CancellationToken.None);
+        try
+        {
+            const string detail = "Given a meeting with Alpha in its title, when metadata arrives, then add project Alpha.";
+            var tools = new MeetingSummaryTools(fixture.Artifacts, fixture.Options, workflowRequests: requests);
+
+            var result = tools.RequestWorkflowChange("Associate Alpha meetings automatically", detail);
+
+            Assert.StartsWith("Requested", result);
+            var prompt = await prompts.NextAsync();
+            Assert.Contains("Workflow change requested: Associate Alpha meetings automatically", prompt.Prompt.Title);
+            Assert.Empty(editor.Prompts);
+            await tools.WriteSummary("The summary can finish while approval is pending.", "Summary finished");
+            Assert.True(tools.SummaryWasWritten);
+
+            prompt.Response.SetResult(true);
+            Assert.Equal(detail, await editor.Started.Task.WaitAsync(TimeSpan.FromSeconds(2)));
+            Assert.False(prompt.Response.TrySetResult(true));
+            Assert.Single(editor.Prompts);
+            await prompt.Removed.Task.WaitAsync(TimeSpan.FromSeconds(2));
+        }
+        finally { await requests.StopAsync(CancellationToken.None); }
+    }
+
+    [Theory]
+    [InlineData("denied")]
+    [InlineData("expired")]
+    [InlineData("canceled")]
+    [InlineData("removed")]
+    public async Task UnapprovedOrStaleAssociationNeverChangesNoteOrProjectAccess(string outcome)
+    {
+        var fixture = await CreateAsync();
+        var original = await File.ReadAllTextAsync(fixture.Artifacts.MeetingNotePath);
+        var prompts = new ControlledPrompts();
+        var approvals = new AgentApprovalService(prompts, NullLogger<AgentApprovalService>.Instance,
+            outcome == "expired" ? TimeSpan.FromMilliseconds(100) : TimeSpan.FromMinutes(10));
+        var tools = new MeetingSummaryTools(fixture.Artifacts, fixture.Options, approvals: approvals);
+        using var cancellation = new CancellationTokenSource();
+        var request = tools.RequestProjectAssociation("Alpha", "Relevant project", cancellation.Token);
+        var prompt = await prompts.NextAsync();
+
+        if (outcome == "denied") prompt.Response.SetResult(false);
+        if (outcome == "canceled") await cancellation.CancelAsync();
+        if (outcome == "removed")
+        {
+            Directory.Delete(Path.Combine(fixture.Options.Vault.ProjectsFolder, "Alpha"), recursive: true);
+            prompt.Response.SetResult(true);
+        }
+        if (outcome == "canceled")
+            await Assert.ThrowsAnyAsync<OperationCanceledException>(() => request);
+        else
+            Assert.DoesNotContain("Approved", await request.WaitAsync(TimeSpan.FromSeconds(2)));
+
+        await prompt.Removed.Task.WaitAsync(TimeSpan.FromSeconds(2));
+        prompt.Response.TrySetResult(true);
+        Assert.Equal(original, await File.ReadAllTextAsync(fixture.Artifacts.MeetingNotePath));
+        Assert.Equal("", await tools.ReadProjectFile("Alpha", "AGENTS.md"));
+    }
+
+    [Fact]
+    public async Task AssociationWaitsForApprovalThenPreservesLatestNoteAndUnlocksProjectWithInstructions()
+    {
+        var fixture = await CreateAsync();
+        var prompts = new ControlledPrompts();
+        var approvals = new AgentApprovalService(prompts, NullLogger<AgentApprovalService>.Instance);
+        var tools = new MeetingSummaryTools(fixture.Artifacts, fixture.Options, approvals: approvals);
+        var request = tools.RequestProjectAssociation("alpha", "Transcript discusses the Alpha launch");
+        var prompt = await prompts.NextAsync();
+        Assert.Contains("Alpha Platform", prompt.Prompt.Message);
+        Assert.Contains("Transcript discusses", prompt.Prompt.Message);
+        Assert.Equal(TimeSpan.FromMinutes(10), prompt.Prompt.Timeout);
+        Assert.False(request.IsCompleted);
+        Assert.Equal("", await tools.ReadProjectFile("Alpha", "AGENTS.md"));
+        Assert.StartsWith("Refused:", await tools.WriteProjectFile("Alpha", "notes.md", "unauthorized"));
+        var latestNote = "---\ntitle: Edited by user\nprojects: Existing\ncustom: keep-me\n---\n\nUser's latest notes.";
+        await File.WriteAllTextAsync(fixture.Artifacts.MeetingNotePath, latestNote);
+
+        prompt.Response.SetResult(true);
+        var result = await request.WaitAsync(TimeSpan.FromSeconds(2));
+
+        Assert.StartsWith("Approved", result);
+        Assert.Contains("Alpha instructions", result);
+        Assert.Contains("Alpha Platform", result);
+        var note = await File.ReadAllTextAsync(fixture.Artifacts.MeetingNotePath);
+        Assert.Contains("Edited by user", note);
+        Assert.Contains("custom: keep-me", note);
+        Assert.Contains("User's latest notes.", note);
+        Assert.Contains("Existing", note);
+        Assert.Contains("Alpha", note);
+        Assert.Empty(Directory.EnumerateFiles(Path.GetDirectoryName(fixture.Artifacts.MeetingNotePath)!, "*.tmp"));
+        Assert.Equal("Alpha instructions", await tools.ReadProjectFile("Alpha", "AGENTS.md"));
+        Assert.Equal("Alpha/notes.md", await tools.WriteProjectFile("Alpha", "notes.md", "approved"));
+        Assert.Contains("notes.md:1 approved", await tools.Search("approved", ["Alpha"]));
+        Assert.StartsWith("Approved", await tools.RequestProjectAssociation("Alpha", "Already associated"));
+        Assert.False(prompts.HasMore);
+    }
+
+    private static async Task<(MeetingSessionArtifacts Artifacts, MeetingAssistantOptions Options)> CreateAsync()
+    {
+        var root = Path.Combine(Path.GetTempPath(), "meeting-assistant-tests", Guid.NewGuid().ToString("N"));
+        var project = Path.Combine(root, "Projects", "Alpha");
+        Directory.CreateDirectory(project);
+        var artifacts = new MeetingSessionArtifacts(Path.Combine(root, "meeting.md"), Path.Combine(root, "transcript.md"),
+            Path.Combine(root, "context.md"), Path.Combine(root, "summary.md"));
+        await File.WriteAllTextAsync(artifacts.MeetingNotePath, "---\ntitle: Planning\nprojects: []\n---\nUser notes.");
+        await File.WriteAllTextAsync(Path.Combine(project, "PROJECT.md"),
+            "---\nname: Alpha Platform\ndescription: Meeting automation\n---");
+        await File.WriteAllTextAsync(Path.Combine(project, "AGENTS.md"), "Alpha instructions");
+        return (artifacts, new MeetingAssistantOptions { Vault = { ProjectsFolder = Path.Combine(root, "Projects") } });
+    }
+
+    private sealed class RecordingEditor : IWorkflowRulesEditorWindowService
+    {
+        public List<string> Prompts { get; } = [];
+        public TaskCompletionSource<string> Started { get; } = new(TaskCreationOptions.RunContinuationsAsynchronously);
+        public void Show() { }
+        public void ShowWithPrompt(string initialPrompt)
+        {
+            Prompts.Add(initialPrompt);
+            Started.TrySetResult(initialPrompt);
+        }
+    }
+
+    private sealed class ControlledPrompts : IAgentApprovalPromptService
+    {
+        private readonly Channel<PendingPrompt> requests = Channel.CreateUnbounded<PendingPrompt>();
+        public bool HasMore => requests.Reader.TryPeek(out _);
+        public Task<PendingPrompt> NextAsync() => requests.Reader.ReadAsync().AsTask().WaitAsync(TimeSpan.FromSeconds(2));
+        public async Task<bool> ConfirmAsync(AgentApprovalPrompt prompt, CancellationToken cancellationToken)
+        {
+            var request = new PendingPrompt(prompt, cancellationToken);
+            requests.Writer.TryWrite(request);
+            try { return await request.Response.Task.WaitAsync(cancellationToken); }
+            finally { request.Removed.TrySetResult(); }
+        }
+    }
+
+    private sealed record PendingPrompt(AgentApprovalPrompt Prompt, CancellationToken Cancellation)
+    {
+        public TaskCompletionSource<bool> Response { get; } = new(TaskCreationOptions.RunContinuationsAsynchronously);
+        public TaskCompletionSource Removed { get; } = new(TaskCreationOptions.RunContinuationsAsynchronously);
+    }
+}

MeetingAssistant.Tests/WorkflowRulesEditorTests.cs

@@ -940,6 +940,30 @@ public sealed class WorkflowRulesEditorTests
         AssertCompletedActivity(viewModel, ["Thinking..."], "Updated rules.");
     }
 
+    [Fact]
+    public async Task ApprovedWorkflowPromptStartsImmediatelyInItsOwnConversation()
+    {
+        var existing = new WorkflowRulesEditorChatViewModel(new BlockingRulesEditorPipeline("Other work"))
+        {
+            Draft = "My unfinished draft"
+        };
+        var pipeline = new BlockingRulesEditorPipeline("Workflow updated.");
+        var requested = new WorkflowRulesEditorChatViewModel(pipeline);
+        const string prompt = "Given Alpha in the meeting title, when metadata arrives, then associate project Alpha.";
+
+        var task = requested.SendPromptAsync(prompt);
+        await pipeline.Started.Task.WaitAsync(TimeSpan.FromSeconds(2));
+
+        Assert.True(requested.IsThinking);
+        Assert.Empty(pipeline.LastConversation);
+        Assert.Equal(new WorkflowRulesEditorChatMessage(WorkflowRulesEditorChatRole.User, prompt), requested.Messages[0].Message);
+        Assert.Equal("My unfinished draft", existing.Draft);
+        Assert.Empty(existing.Messages);
+        pipeline.Release.SetResult();
+        await task.WaitAsync(TimeSpan.FromSeconds(2));
+        Assert.False(requested.IsThinking);
+    }
+
     [Fact]
     public async Task ViewModelShowsAgentErrorWhenRequestTimesOut()
     {

MeetingAssistant/Content/Project-AGENTS.md

@@ -32,7 +32,14 @@ Calendar-Feature is refined, Golem feature needs more work.
 
 PROJECT.md should use this structure:
 
+Maintain its YAML `name` as the project's display name and `description` as a grounded description of its purpose in at most 256 characters. These fields help summarizers identify missing project associations. Preserve other frontmatter and body content when updating them.
+
 ```markdown
+---
+name: Project display name
+description: Concise project purpose and distinguishing context.
+---
+
 # Executive Summary
 
 <Elevator Pitch>

MeetingAssistant/MeetingAssistant.csproj

@@ -5,7 +5,7 @@
     <Nullable>enable</Nullable>
     <ImplicitUsings>enable</ImplicitUsings>
     <PreserveCompilationContext>true</PreserveCompilationContext>
-    <MicrosoftSpeechVersion>1.51.1</MicrosoftSpeechVersion>
+    <MicrosoftSpeechVersion>1.51.2</MicrosoftSpeechVersion>
   </PropertyGroup>
 
   <PropertyGroup Condition="$([MSBuild]::GetTargetPlatformIdentifier('$(TargetFramework)')) == 'windows'">
@@ -20,16 +20,16 @@
   </ItemGroup>
 
   <ItemGroup>
-    <PackageReference Include="Microsoft.Agents.AI.OpenAI" Version="1.20.0" />
+    <PackageReference Include="Microsoft.Agents.AI.OpenAI" Version="1.23.0" />
     <PackageReference Include="DiffPlex" Version="1.9.0" />
     <PackageReference Include="Microsoft.CognitiveServices.Speech" Version="$(MicrosoftSpeechVersion)" />
     <PackageReference Include="Microsoft.CognitiveServices.Speech.Extension.MAS" Version="$(MicrosoftSpeechVersion)" ExcludeAssets="build" />
-    <PackageReference Include="Microsoft.EntityFrameworkCore.Sqlite" Version="10.0.11" />
+    <PackageReference Include="Microsoft.EntityFrameworkCore.Sqlite" Version="10.0.12" />
     <PackageReference Include="NAudio" Version="3.1.0" />
-    <PackageReference Include="NCalcSync" Version="7.1.0" />
+    <PackageReference Include="NCalcSync" Version="7.2.0" />
     <PackageReference Include="RazorLight" Version="2.3.1" />
     <PackageReference Include="SQLitePCLRaw.bundle_e_sqlite3" Version="3.0.5" />
-    <PackageReference Include="System.Drawing.Common" Version="10.0.11" />
+    <PackageReference Include="System.Drawing.Common" Version="10.0.12" />
     <PackageReference Include="Whisper.net" Version="1.9.1" />
     <PackageReference Include="Whisper.net.Runtime" Version="1.9.1" />
     <PackageReference Include="YamlDotNet" Version="18.1.0" />

MeetingAssistant/Notifications/AgentApprovalService.cs

@@ -0,0 +1,56 @@
+namespace MeetingAssistant.Notifications;
+
+public sealed record AgentApprovalPrompt(string Title, string Message, TimeSpan Timeout);
+
+public interface IAgentApprovalPromptService
+{
+    Task<bool> ConfirmAsync(AgentApprovalPrompt prompt, CancellationToken cancellationToken);
+}
+
+public sealed class NoopAgentApprovalPromptService : IAgentApprovalPromptService
+{
+    public Task<bool> ConfirmAsync(AgentApprovalPrompt prompt, CancellationToken cancellationToken) => Task.FromResult(false);
+}
+
+public sealed class AgentApprovalService
+{
+    private readonly IAgentApprovalPromptService prompts;
+    private readonly ILogger<AgentApprovalService> logger;
+    private readonly TimeSpan timeout;
+
+    public AgentApprovalService(IAgentApprovalPromptService prompts, ILogger<AgentApprovalService> logger)
+        : this(prompts, logger, TimeSpan.FromMinutes(10)) { }
+
+    internal AgentApprovalService(IAgentApprovalPromptService prompts, ILogger<AgentApprovalService> logger, TimeSpan timeout)
+    {
+        this.prompts = prompts;
+        this.logger = logger;
+        this.timeout = timeout;
+    }
+
+    public async Task<bool> ConfirmAsync(string title, string message, CancellationToken cancellationToken)
+    {
+        using var deadline = CancellationTokenSource.CreateLinkedTokenSource(cancellationToken);
+        deadline.CancelAfter(timeout);
+        try
+        {
+            var accepted = await prompts.ConfirmAsync(new AgentApprovalPrompt(title, message, timeout), deadline.Token)
+                .WaitAsync(deadline.Token);
+            cancellationToken.ThrowIfCancellationRequested();
+            return accepted && !deadline.IsCancellationRequested;
+        }
+        catch (OperationCanceledException) when (!cancellationToken.IsCancellationRequested)
+        {
+            return false;
+        }
+        catch (Exception exception) when (exception is not OperationCanceledException)
+        {
+            logger.LogWarning(exception, "Could not obtain user approval for {Title}", title);
+            return false;
+        }
+        finally
+        {
+            await deadline.CancelAsync();
+        }
+    }
+}

MeetingAssistant/Notifications/WindowsAgentApprovalPromptService.Windows.cs

@@ -0,0 +1,85 @@
+#if WINDOWS
+using System.Collections.Concurrent;
+using CommunityToolkit.WinUI.Notifications;
+using MeetingAssistant.Recording;
+
+namespace MeetingAssistant.Notifications;
+
+public sealed class WindowsAgentApprovalPromptService(ILogger<WindowsAgentApprovalPromptService> logger)
+    : IAgentApprovalPromptService, IDisposable
+{
+    private const string Source = "summary-agent-approval";
+    private readonly ConcurrentDictionary<string, TaskCompletionSource<bool>> pending = new();
+    private readonly object gate = new();
+    private bool registered;
+    private bool disposed;
+
+    public async Task<bool> ConfirmAsync(AgentApprovalPrompt prompt, CancellationToken cancellationToken)
+    {
+        if (!OperatingSystem.IsWindowsVersionAtLeast(10, 0, 17763)) return false;
+        cancellationToken.ThrowIfCancellationRequested();
+        var id = Guid.NewGuid().ToString("N");
+        var response = new TaskCompletionSource<bool>(TaskCreationOptions.RunContinuationsAsynchronously);
+        try
+        {
+            lock (gate)
+            {
+                if (disposed) return false;
+                if (!registered)
+                {
+                    ToastNotificationManagerCompat.OnActivated += OnActivated;
+                    registered = true;
+                }
+                pending[id] = response;
+                new ToastContentBuilder()
+                    .AddArgument("source", Source).AddArgument("requestId", id)
+                    .SetToastScenario(ToastScenario.Reminder)
+                    .SetToastDuration(ToastDuration.Long)
+                    .AddText(prompt.Title)
+                    .AddText(prompt.Message)
+                    .AddButton(new ToastButton().SetContent("Yes")
+                        .AddArgument("source", Source).AddArgument("requestId", id)
+                        .AddArgument("response", "yes").SetBackgroundActivation())
+                    .AddButton(new ToastButton().SetContent("No")
+                        .AddArgument("source", Source).AddArgument("requestId", id)
+                        .AddArgument("response", "no").SetBackgroundActivation())
+                    .Show(toast =>
+                    {
+                        toast.Tag = id;
+                        toast.Group = Source;
+                        toast.ExpirationTime = DateTimeOffset.Now.Add(prompt.Timeout);
+                    });
+            }
+
+            return await response.Task.WaitAsync(cancellationToken);
+        }
+        finally
+        {
+            pending.TryRemove(id, out _);
+            try { ToastNotificationManagerCompat.History.Remove(id, Source); }
+            catch (Exception exception) { logger.LogDebug(exception, "Could not remove approval notification {RequestId}", id); }
+        }
+    }
+
+    private void OnActivated(ToastNotificationActivatedEventArgsCompat args)
+    {
+        var arguments = NotificationActivationArguments.Parse(args.Argument);
+        if (arguments.GetValueOrDefault("source") != Source ||
+            !arguments.TryGetValue("requestId", out var id) ||
+            !pending.TryRemove(id, out var response)) return;
+        response.TrySetResult(arguments.GetValueOrDefault("response") == "yes");
+    }
+
+    public void Dispose()
+    {
+        lock (gate)
+        {
+            disposed = true;
+            if (registered) ToastNotificationManagerCompat.OnActivated -= OnActivated;
+            registered = false;
+            foreach (var response in pending.Values) response.TrySetResult(false);
+            pending.Clear();
+        }
+    }
+}
+#endif

MeetingAssistant/Program.cs

@@ -4,6 +4,7 @@ using MeetingAssistant.Hotkeys;
 using MeetingAssistant.LaunchProfiles;
 using MeetingAssistant.Logging;
 using MeetingAssistant.MeetingNotes;
+using MeetingAssistant.Notifications;
 using MeetingAssistant.Recording;
 using MeetingAssistant.Screenshots;
 using MeetingAssistant.Speakers;
@@ -28,6 +29,9 @@ builder.Services.AddSingleton<IMicrophoneDeviceProvider>(services =>
     services.GetRequiredService<WindowsMicrophoneDeviceProvider>());
 builder.Services.AddSingleton<IMicrophoneCaptureSourceFactory>(services =>
     services.GetRequiredService<WindowsMicrophoneDeviceProvider>());
+builder.Services.AddSingleton<IMicrophoneSwitchPromptService, WindowsMicrophoneSwitchPromptService>();
+builder.Services.AddSingleton<IAgentApprovalPromptService, WindowsAgentApprovalPromptService>();
+builder.Services.AddSingleton<MicrophoneSwitchMonitor>();
 builder.Services.AddSingleton<MicrophoneAudioSource>();
 builder.Services.AddSingleton<SystemAudioSource>();
 builder.Services.AddSingleton<IAcousticEchoCancellerFactory, AdaptiveFilterAcousticEchoCancellerFactory>();
@@ -39,6 +43,8 @@ builder.Services.AddSingleton<IMeetingAudioSource>(services => new CompositeMeet
 builder.Services.AddSingleton<IMeetingMetadataProvider, OutlookClassicMeetingMetadataProvider>();
 #else
 builder.Services.AddSingleton<IMeetingAudioSource, UnavailableMeetingAudioSource>();
+builder.Services.AddSingleton<IMicrophoneSwitchPromptService, NoopMicrophoneSwitchPromptService>();
+builder.Services.AddSingleton<IAgentApprovalPromptService, NoopAgentApprovalPromptService>();
 builder.Services.AddSingleton<IMeetingMetadataProvider, NoopMeetingMetadataProvider>();
 #endif
 builder.Services.AddSingleton<ITranscriptStore, VaultTranscriptStore>();
@@ -132,7 +138,11 @@ builder.Services.AddSingleton<IMeetingSummaryRetryRunner, MeetingSummaryRetryRun
 builder.Services.AddSingleton<IMeetingWorkflowRulesProvider, FileMeetingWorkflowRulesProvider>();
 builder.Services.AddSingleton<IMeetingWorkflowEngine, MeetingWorkflowEngine>();
 builder.Services.AddSingleton<IWorkflowRulesEditorInstructionBuilder, WorkflowRulesEditorInstructionBuilder>();
+#if WINDOWS
 builder.Services.AddSingleton<IWorkflowRulesEditorSamplePlaybackQueue, WorkflowRulesEditorSamplePlaybackQueue>();
+#else
+builder.Services.AddSingleton<IWorkflowRulesEditorSamplePlaybackQueue, UnavailableWorkflowRulesEditorSamplePlaybackQueue>();
+#endif
 builder.Services.AddSingleton<IWorkflowRulesEditorChatPipeline, WorkflowRulesEditorChatPipeline>();
 builder.Services.AddTransient<WorkflowRulesEditorChatViewModel>();
 #if WINDOWS
@@ -142,6 +152,9 @@ builder.Services.AddSingleton<IWorkflowRulesEditorWindowService, WpfWorkflowRule
 #else
 builder.Services.AddSingleton<IWorkflowRulesEditorWindowService, NoopWorkflowRulesEditorWindowService>();
 #endif
+builder.Services.AddSingleton<AgentApprovalService>();
+builder.Services.AddSingleton<WorkflowChangeRequestService>();
+builder.Services.AddHostedService(services => services.GetRequiredService<WorkflowChangeRequestService>());
 builder.Services.AddSingleton<AsrDiagnosticService>();
 builder.Services.AddSingleton<ICommandRunner, ProcessCommandRunner>();
 builder.Services.AddSingleton<IFunAsrBackendReadinessProbe, FunAsrWebSocketBackendReadinessProbe>();

MeetingAssistant/Recording/IMicrophoneCaptureSourceFactory.cs

@@ -2,5 +2,7 @@ namespace MeetingAssistant.Recording;
 
 public interface IMicrophoneCaptureSourceFactory
 {
+    // The caller owns the returned source and disposes it when it implements IDisposable,
+    // including when capture is canceled before enumeration starts.
     IMeetingAudioSource CreateCapture(MeetingAssistantOptions options);
 }

MeetingAssistant/Recording/IMicrophoneSwitchPromptService.cs

@@ -0,0 +1,12 @@
+namespace MeetingAssistant.Recording;
+
+public interface IMicrophoneSwitchPromptService
+{
+    Task<bool> ConfirmSwitchAsync(MicrophoneDevice microphone, CancellationToken cancellationToken);
+}
+
+public sealed class NoopMicrophoneSwitchPromptService : IMicrophoneSwitchPromptService
+{
+    public Task<bool> ConfirmSwitchAsync(MicrophoneDevice microphone, CancellationToken cancellationToken)
+        => Task.FromResult(false);
+}

MeetingAssistant/Recording/ITranscriptStore.cs

@@ -33,6 +33,17 @@ public interface ITranscriptStore
         string line,
         CancellationToken cancellationToken);
 
+    async Task AppendLinesAsync(
+        TranscriptSession session,
+        IReadOnlyList<string> lines,
+        CancellationToken cancellationToken)
+    {
+        foreach (var line in lines)
+        {
+            await AppendLineAsync(session, line, cancellationToken);
+        }
+    }
+
     Task ReplaceLineAsync(
         TranscriptSession session,
         TranscriptLineReference lineReference,

MeetingAssistant/Recording/MeetingRecordingCoordinator.cs

@@ -416,6 +416,12 @@ public sealed class MeetingRecordingCoordinator
         }
         catch (TimeoutException)
         {
+            if (run.ContextState is AssistantContextState.Summarizing or AssistantContextState.Finished or AssistantContextState.Error)
+            {
+                logger.LogInformation("Recording has reached summarization; continuing remaining processing in the background after the stop wait expired");
+                return CurrentStatus;
+            }
+
             if (IsAzureSpeechRun(run))
             {
                 logger.LogWarning("Timed out while draining Azure Speech transcription after recording stop; queueing offline transcription backlog item");
@@ -805,7 +811,9 @@ public sealed class MeetingRecordingCoordinator
             run.RecordTranscriptActivity(segment, inactivityClock.Now);
             if (!string.IsNullOrWhiteSpace(segment.Text))
             {
-                await DismissInactivityPromptsForRunAsync(run, cancellationToken);
+                // 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);
             }
         }
     }
@@ -814,19 +822,26 @@ public sealed class MeetingRecordingCoordinator
         RecordingRun run,
         CancellationToken cancellationToken)
     {
-        await gate.WaitAsync(cancellationToken);
         try
         {
-            if (!ReferenceEquals(currentRun, run) || run.IsCaptureStopping)
+            await gate.WaitAsync(cancellationToken);
+            try
             {
-                return;
-            }
+                if (!ReferenceEquals(currentRun, run) || run.IsCaptureStopping)
+                {
+                    return;
+                }
 
-            await DismissInactivityPromptsAsync(cancellationToken);
+                await DismissInactivityPromptsAsync(cancellationToken);
+            }
+            finally
+            {
+                gate.Release();
+            }
         }
-        finally
+        catch (OperationCanceledException) when (cancellationToken.IsCancellationRequested)
         {
-            gate.Release();
+            // Pending cleanup is no longer needed after this run stops capturing.
         }
     }
 

MeetingAssistant/Recording/MicrophoneAudioSource.cs

@@ -8,22 +8,30 @@ public sealed class MicrophoneAudioSource : IMeetingAudioSource
     private readonly IMicrophoneCaptureSourceFactory captureSources;
     private readonly ILogger<MicrophoneAudioSource> logger;
     private readonly TimeSpan recoveryDelay;
+    private readonly MicrophoneSwitchMonitor? switchMonitor;
+    private readonly MicrophoneDeviceSelection? selection;
 
     public MicrophoneAudioSource(
         IMicrophoneCaptureSourceFactory captureSources,
-        ILogger<MicrophoneAudioSource> logger)
-        : this(captureSources, logger, DefaultRecoveryDelay)
+        ILogger<MicrophoneAudioSource> logger,
+        MicrophoneSwitchMonitor? switchMonitor = null,
+        MicrophoneDeviceSelection? selection = null)
+        : this(captureSources, logger, DefaultRecoveryDelay, switchMonitor, selection)
     {
     }
 
     internal MicrophoneAudioSource(
         IMicrophoneCaptureSourceFactory captureSources,
         ILogger<MicrophoneAudioSource> logger,
-        TimeSpan recoveryDelay)
+        TimeSpan recoveryDelay,
+        MicrophoneSwitchMonitor? switchMonitor = null,
+        MicrophoneDeviceSelection? selection = null)
     {
         this.captureSources = captureSources;
         this.logger = logger;
         this.recoveryDelay = recoveryDelay;
+        this.switchMonitor = switchMonitor;
+        this.selection = selection;
     }
 
     public IAsyncEnumerable<AudioChunk> CaptureAsync(CancellationToken cancellationToken)
@@ -34,21 +42,44 @@ public sealed class MicrophoneAudioSource : IMeetingAudioSource
     public async IAsyncEnumerable<AudioChunk> CaptureAsync(
         MeetingAssistantOptions options,
         [EnumeratorCancellation] CancellationToken cancellationToken)
+    {
+        using var session = new CaptureSession(selection, cancellationToken);
+        var monitoring = switchMonitor?.RunAsync(session.SwitchTo, session.Token) ?? Task.CompletedTask;
+        try
+        {
+            await foreach (var chunk in CaptureWithRecoveryAsync(options, session, session.Token))
+            {
+                yield return chunk;
+            }
+        }
+        finally
+        {
+            session.Stop();
+            await monitoring;
+        }
+    }
+
+    private async IAsyncEnumerable<AudioChunk> CaptureWithRecoveryAsync(
+        MeetingAssistantOptions options,
+        CaptureSession session,
+        [EnumeratorCancellation] CancellationToken cancellationToken)
     {
         var failedAttempts = 0;
         while (!cancellationToken.IsCancellationRequested)
         {
+            var captureToken = session.BeginCapture();
+            IMeetingAudioSource? captureSource = null;
             IAsyncEnumerator<AudioChunk>? capture = null;
             Exception? failure = null;
 
             try
             {
-                capture = captureSources
-                    .CreateCapture(options)
-                    .CaptureAsync(options, cancellationToken)
-                    .GetAsyncEnumerator(cancellationToken);
+                captureSource = captureSources.CreateCapture(options);
+                capture = captureSource
+                    .CaptureAsync(options, captureToken)
+                    .GetAsyncEnumerator(captureToken);
             }
-            catch (OperationCanceledException) when (cancellationToken.IsCancellationRequested)
+            catch (OperationCanceledException) when (captureToken.IsCancellationRequested)
             {
             }
             catch (Exception exception)
@@ -56,6 +87,7 @@ public sealed class MicrophoneAudioSource : IMeetingAudioSource
                 failure = exception;
             }
 
+            using var captureOwner = captureSource as IDisposable;
             if (cancellationToken.IsCancellationRequested)
             {
                 yield break;
@@ -65,14 +97,14 @@ public sealed class MicrophoneAudioSource : IMeetingAudioSource
             {
                 try
                 {
-                    while (!cancellationToken.IsCancellationRequested)
+                    while (!captureToken.IsCancellationRequested)
                     {
                         var hasNext = false;
                         try
                         {
                             hasNext = await capture.MoveNextAsync();
                         }
-                        catch (OperationCanceledException) when (cancellationToken.IsCancellationRequested)
+                        catch (OperationCanceledException) when (captureToken.IsCancellationRequested)
                         {
                         }
                         catch (Exception exception)
@@ -80,7 +112,7 @@ public sealed class MicrophoneAudioSource : IMeetingAudioSource
                             failure = exception;
                         }
 
-                        if (cancellationToken.IsCancellationRequested || failure is not null || !hasNext)
+                        if (captureToken.IsCancellationRequested || failure is not null || !hasNext)
                         {
                             break;
                         }
@@ -102,7 +134,7 @@ public sealed class MicrophoneAudioSource : IMeetingAudioSource
                     {
                         await capture.DisposeAsync();
                     }
-                    catch (OperationCanceledException) when (cancellationToken.IsCancellationRequested)
+                    catch (OperationCanceledException) when (captureToken.IsCancellationRequested)
                     {
                     }
                     catch (Exception exception)
@@ -112,11 +144,19 @@ public sealed class MicrophoneAudioSource : IMeetingAudioSource
                 }
             }
 
+            var switchRequested = captureToken.IsCancellationRequested;
+            session.EndCapture();
             if (cancellationToken.IsCancellationRequested)
             {
                 yield break;
             }
 
+            if (switchRequested)
+            {
+                logger.LogInformation("Replacing microphone capture after an accepted device-switch notification");
+                continue;
+            }
+
             failedAttempts++;
             logger.LogWarning(
                 failure,
@@ -142,4 +182,53 @@ public sealed class MicrophoneAudioSource : IMeetingAudioSource
             return false;
         }
     }
+
+    private sealed class CaptureSession(MicrophoneDeviceSelection? selection, CancellationToken cancellationToken) : IDisposable
+    {
+        private readonly object gate = new();
+        private readonly CancellationTokenSource lifetime = CancellationTokenSource.CreateLinkedTokenSource(cancellationToken);
+        private CancellationTokenSource? capture;
+
+        public CancellationToken Token => lifetime.Token;
+
+        public CancellationToken BeginCapture()
+        {
+            lock (gate)
+            {
+                capture = CancellationTokenSource.CreateLinkedTokenSource(lifetime.Token);
+                return capture.Token;
+            }
+        }
+
+        public void EndCapture()
+        {
+            lock (gate)
+            {
+                capture?.Dispose();
+                capture = null;
+            }
+        }
+
+        public void SwitchTo(MicrophoneDevice device, CancellationToken promptCancellation)
+        {
+            lock (gate)
+            {
+                if (lifetime.IsCancellationRequested || promptCancellation.IsCancellationRequested || selection is null) return;
+                selection.Select(device.Id);
+                capture?.Cancel();
+            }
+        }
+
+        public void Stop()
+        {
+            lock (gate) lifetime.Cancel();
+        }
+
+        public void Dispose()
+        {
+            Stop();
+            EndCapture();
+            lifetime.Dispose();
+        }
+    }
 }

MeetingAssistant/Recording/MicrophoneSwitchMonitor.cs

@@ -0,0 +1,114 @@
+namespace MeetingAssistant.Recording;
+
+public sealed class MicrophoneSwitchMonitor
+{
+    private readonly IMicrophoneDeviceProvider devices;
+    private readonly IMicrophoneSwitchPromptService prompts;
+    private readonly ILogger<MicrophoneSwitchMonitor> logger;
+    private readonly TimeSpan pollInterval;
+    private readonly TimeSpan promptLifetime;
+
+    public MicrophoneSwitchMonitor(
+        IMicrophoneDeviceProvider devices,
+        IMicrophoneSwitchPromptService prompts,
+        ILogger<MicrophoneSwitchMonitor> logger)
+        : this(devices, prompts, logger, TimeSpan.FromSeconds(1), TimeSpan.FromMinutes(1))
+    {
+    }
+
+    internal MicrophoneSwitchMonitor(
+        IMicrophoneDeviceProvider devices,
+        IMicrophoneSwitchPromptService prompts,
+        ILogger<MicrophoneSwitchMonitor> logger,
+        TimeSpan pollInterval,
+        TimeSpan promptLifetime)
+    {
+        this.devices = devices;
+        this.prompts = prompts;
+        this.logger = logger;
+        this.pollInterval = pollInterval;
+        this.promptLifetime = promptLifetime;
+    }
+
+    public async Task RunAsync(Action<MicrophoneDevice, CancellationToken> switchMicrophone, CancellationToken cancellationToken)
+    {
+        var known = (ReadDevices() ?? []).Select(device => device.Id).ToHashSet(StringComparer.OrdinalIgnoreCase);
+        var pending = new Dictionary<string, PendingPrompt>(StringComparer.OrdinalIgnoreCase);
+        try
+        {
+            while (true)
+            {
+                await Task.Delay(pollInterval, cancellationToken);
+                var available = ReadDevices();
+                if (available is null) continue;
+                var availableIds = available.Select(device => device.Id).ToHashSet(StringComparer.OrdinalIgnoreCase);
+                foreach (var (id, prompt) in pending.ToArray())
+                {
+                    if (!availableIds.Contains(id)) await prompt.Cancellation.CancelAsync();
+                    if (prompt.Task.IsCompleted)
+                    {
+                        prompt.Cancellation.Dispose();
+                        pending.Remove(id);
+                    }
+                }
+
+                foreach (var device in available)
+                {
+                    if (known.Add(device.Id))
+                    {
+                        var promptCancellation = CancellationTokenSource.CreateLinkedTokenSource(cancellationToken);
+                        promptCancellation.CancelAfter(promptLifetime);
+                        pending.Add(device.Id, new PendingPrompt(promptCancellation,
+                            OfferAsync(device, switchMicrophone, promptCancellation.Token)));
+                    }
+                }
+            }
+        }
+        catch (OperationCanceledException) when (cancellationToken.IsCancellationRequested)
+        {
+        }
+        finally
+        {
+            foreach (var prompt in pending.Values) await prompt.Cancellation.CancelAsync();
+            await Task.WhenAll(pending.Values.Select(prompt => prompt.Task));
+            foreach (var prompt in pending.Values) prompt.Cancellation.Dispose();
+        }
+    }
+
+    private async Task OfferAsync(MicrophoneDevice device, Action<MicrophoneDevice, CancellationToken> switchMicrophone,
+        CancellationToken cancellationToken)
+    {
+        try
+        {
+            if (await prompts.ConfirmSwitchAsync(device, cancellationToken)
+                && !cancellationToken.IsCancellationRequested
+                && ReadDevices()?.Any(current => current.Id.Equals(device.Id, StringComparison.OrdinalIgnoreCase)) == true
+                && !cancellationToken.IsCancellationRequested)
+            {
+                switchMicrophone(device, cancellationToken);
+            }
+        }
+        catch (OperationCanceledException) when (cancellationToken.IsCancellationRequested)
+        {
+        }
+        catch (Exception exception)
+        {
+            logger.LogWarning(exception, "Could not offer microphone {MicrophoneName}", device.Name);
+        }
+    }
+
+    private IReadOnlyList<MicrophoneDevice>? ReadDevices()
+    {
+        try
+        {
+            return devices.GetAvailableMicrophones();
+        }
+        catch (Exception exception)
+        {
+            logger.LogWarning(exception, "Could not check for newly available microphones");
+            return null;
+        }
+    }
+
+    private sealed record PendingPrompt(CancellationTokenSource Cancellation, Task Task);
+}

MeetingAssistant/Recording/NaudioCaptureSource.cs

@@ -4,11 +4,12 @@ using NAudio.Wave;
 
 namespace MeetingAssistant.Recording;
 
-internal sealed class NaudioCaptureAudioSource : IMeetingAudioSource
+internal sealed class NaudioCaptureAudioSource : IMeetingAudioSource, IDisposable
 {
     private readonly IWaveIn capture;
     private readonly string sourceName;
     private readonly ILogger logger;
+    private int disposed;
 
     public NaudioCaptureAudioSource(
         IWaveIn capture,
@@ -22,13 +23,15 @@ internal sealed class NaudioCaptureAudioSource : IMeetingAudioSource
 
     public IAsyncEnumerable<AudioChunk> CaptureAsync(CancellationToken cancellationToken)
     {
-        return CaptureWith(capture, sourceName, logger, cancellationToken);
+        return CaptureWith(cancellationToken);
     }
 
-    private static async IAsyncEnumerable<AudioChunk> CaptureWith(
-        IWaveIn capture,
-        string sourceName,
-        ILogger logger,
+    public void Dispose()
+    {
+        if (Interlocked.Exchange(ref disposed, 1) == 0) capture.Dispose();
+    }
+
+    private async IAsyncEnumerable<AudioChunk> CaptureWith(
         [System.Runtime.CompilerServices.EnumeratorCancellation] CancellationToken cancellationToken)
     {
         var channel = Channel.CreateUnbounded<AudioChunk>();
@@ -83,7 +86,7 @@ internal sealed class NaudioCaptureAudioSource : IMeetingAudioSource
         }
         finally
         {
-            capture.Dispose();
+            Dispose();
         }
     }
 }

MeetingAssistant/Recording/OfflineTranscriptionBacklogProcessor.cs

@@ -117,8 +117,25 @@ public sealed class OfflineTranscriptionBacklogProcessor
             pipelineOptions,
             cancellationToken);
 
+        if (!finishedSegments.Any(segment =>
+                segment.Kind == TranscriptionSegmentKind.Speech && !string.IsNullOrWhiteSpace(segment.Text)))
+        {
+            throw new InvalidOperationException(
+                "Offline transcription replay returned no speech text; preserving the existing transcript and recovery files.");
+        }
+
         var lines = await TransformTranscriptLinesAsync(artifacts, runOptions, finishedSegments, cancellationToken);
-        await transcriptStore.ReplaceLinesAsync(session, lines, cancellationToken);
+        await transcriptStore.AppendLinesAsync(session,
+        [
+            "",
+            "## Offline transcription recovery",
+            "",
+            "> The following transcript was recovered by replaying the entire recording. "
+                + "It may duplicate earlier transcript passages. "
+                + "Treat repeated passages as the same discussion when summarizing.",
+            "",
+            .. lines
+        ], cancellationToken);
 
         meetingNote.Frontmatter.EndTime = item.InferredEndTime ?? DateTimeOffset.Now;
         var completedMeetingNote = await meetingNoteStore.SaveAsync(meetingNote, runOptions, cancellationToken);

MeetingAssistant/Recording/VaultTranscriptStore.cs

@@ -49,6 +49,25 @@ public sealed class VaultTranscriptStore : ITranscriptStore
             cancellationToken);
     }
 
+    public Task AppendLinesAsync(
+        TranscriptSession session,
+        IReadOnlyList<string> lines,
+        CancellationToken cancellationToken)
+    {
+        if (lines.Count == 0)
+        {
+            return Task.CompletedTask;
+        }
+
+        return WithFileGateAsync(
+            session.TranscriptPath,
+            () => File.AppendAllTextAsync(
+                session.TranscriptPath,
+                string.Concat(lines.Select(line => line + Environment.NewLine)),
+                cancellationToken),
+            cancellationToken);
+    }
+
     public async Task ReplaceLineAsync(
         TranscriptSession session,
         TranscriptLineReference lineReference,

MeetingAssistant/Recording/WindowsMicrophoneSwitchPromptService.Windows.cs

@@ -0,0 +1,96 @@
+#if WINDOWS
+using System.Collections.Concurrent;
+using CommunityToolkit.WinUI.Notifications;
+
+namespace MeetingAssistant.Recording;
+
+public sealed class WindowsMicrophoneSwitchPromptService : IMicrophoneSwitchPromptService, IDisposable
+{
+    private const string Source = "meeting-microphone-switch";
+    private readonly ConcurrentDictionary<string, TaskCompletionSource<bool>> pending = new();
+    private readonly ILogger<WindowsMicrophoneSwitchPromptService> logger;
+    private readonly object gate = new();
+    private bool registered;
+
+    public WindowsMicrophoneSwitchPromptService(ILogger<WindowsMicrophoneSwitchPromptService> logger)
+    {
+        this.logger = logger;
+    }
+
+    public async Task<bool> ConfirmSwitchAsync(MicrophoneDevice microphone, CancellationToken cancellationToken)
+    {
+        if (!OperatingSystem.IsWindowsVersionAtLeast(10, 0, 17763)) return false;
+        cancellationToken.ThrowIfCancellationRequested();
+        var id = Guid.NewGuid().ToString("N");
+        var response = new TaskCompletionSource<bool>(TaskCreationOptions.RunContinuationsAsynchronously);
+        try
+        {
+            lock (gate)
+            {
+                if (!registered)
+                {
+                    ToastNotificationManagerCompat.OnActivated += OnActivated;
+                    registered = true;
+                }
+
+                pending[id] = response;
+                new ToastContentBuilder()
+                    .AddArgument("source", Source)
+                    .AddArgument("promptId", id)
+                    .SetToastScenario(ToastScenario.Reminder)
+                    .SetToastDuration(ToastDuration.Long)
+                    .AddText("New microphone available")
+                    .AddText($"Switch this meeting to {microphone.Name}?")
+                    .AddButton(new ToastButton().SetContent("Yes")
+                        .AddArgument("source", Source).AddArgument("promptId", id)
+                        .AddArgument("response", "yes").SetBackgroundActivation())
+                    .AddButton(new ToastButton().SetContent("No")
+                        .AddArgument("source", Source).AddArgument("promptId", id)
+                        .AddArgument("response", "no").SetBackgroundActivation())
+                    .Show(toast =>
+                    {
+                        toast.Tag = id;
+                        toast.Group = Source;
+                        toast.ExpirationTime = DateTimeOffset.Now.AddMinutes(1);
+                    });
+            }
+
+            logger.LogInformation("Offered newly available microphone {MicrophoneName}", microphone.Name);
+            return await response.Task.WaitAsync(cancellationToken);
+        }
+        finally
+        {
+            pending.TryRemove(id, out _);
+            try
+            {
+                ToastNotificationManagerCompat.History.Remove(id, Source);
+            }
+            catch (Exception exception)
+            {
+                logger.LogDebug(exception, "Could not remove microphone notification {PromptId}", id);
+            }
+        }
+    }
+
+    private void OnActivated(ToastNotificationActivatedEventArgsCompat args)
+    {
+        var arguments = NotificationActivationArguments.Parse(args.Argument);
+        if (arguments.GetValueOrDefault("source") != Source ||
+            !arguments.TryGetValue("promptId", out var id) ||
+            !pending.TryRemove(id, out var response)) return;
+
+        response.TrySetResult(arguments.GetValueOrDefault("response") == "yes");
+    }
+
+    public void Dispose()
+    {
+        lock (gate)
+        {
+            if (registered) ToastNotificationManagerCompat.OnActivated -= OnActivated;
+            registered = false;
+            foreach (var response in pending.Values) response.TrySetResult(false);
+            pending.Clear();
+        }
+    }
+}
+#endif

MeetingAssistant/Summary/BoundMeetingProjectResolver.cs

@@ -18,6 +18,12 @@ public sealed class BoundMeetingProjectResolver
 
     public string ProjectsRoot => VaultPath.Resolve(options.Vault, options.Vault.ProjectsFolder);
 
+    public List<BoundMeetingProject> GetAllProjects() => !Directory.Exists(ProjectsRoot) ? [] :
+        Directory.EnumerateDirectories(ProjectsRoot)
+            .Select(path => new BoundMeetingProject(Path.GetFileName(path), path))
+            .OrderBy(project => project.Name, StringComparer.OrdinalIgnoreCase)
+            .ToList();
+
     public async Task<List<BoundMeetingProject>> GetBoundProjectsAsync(
         MeetingSessionArtifacts artifacts,
         CancellationToken cancellationToken = default)
@@ -33,10 +39,8 @@ public sealed class BoundMeetingProjectResolver
             return [];
         }
 
-        return Directory.EnumerateDirectories(ProjectsRoot)
-            .Select(path => new BoundMeetingProject(Path.GetFileName(path), path))
+        return GetAllProjects()
             .Where(project => projectNames.Contains(project.Name))
-            .OrderBy(project => project.Name, StringComparer.OrdinalIgnoreCase)
             .ToList();
     }
 

MeetingAssistant/Summary/LiteLlmResponsesChatClient.cs

@@ -7,7 +7,6 @@ using System.Text.Json.Nodes;
 using Microsoft.Agents.AI.Compaction;
 using Microsoft.Extensions.AI;
 using Microsoft.Extensions.Logging;
-using OpenAI;
 using OpenAI.Responses;
 
 namespace MeetingAssistant.Summary;
@@ -798,7 +797,7 @@ public sealed class LiteLlmResponsesChatClient : IChatClient
         string apiKey,
         AsyncLocal<string?> requestInitiator)
     {
-        var options = new OpenAIClientOptions
+        var options = new ResponsesClientOptions
         {
             Endpoint = httpClient.BaseAddress
                 ?? throw new InvalidOperationException("LiteLLM HTTP client requires a base address."),

MeetingAssistant/Summary/MeetingSummaryInstructionBuilder.cs

@@ -20,12 +20,20 @@ public sealed class MeetingSummaryInstructionBuilder : IMeetingSummaryInstructio
         Use override_speaker only when you are very certain that a transcript speaker label belongs to a named person, for example from user notes, OCR evidence with a matching timestamp, or very clear context cues. Provide the exact speaker label from the transcript and the replacement speaker name. If the replacement speaker already exists in the transcript, use merge=true only when you are certain both speaker labels are the same identity; otherwise do not merge them.
         Use delete_identity only when you are certain that an existing speaker identity was wrongfully matched. Provide the exact identity name currently used in the transcript.
         After writing the summary, update existing project files when the meeting produced durable project knowledge, decisions, next steps, or context.
-        Use list_projects first to see which projects are bound to this meeting. Use search, list_past_project_meetings, read_past_project_meeting_summary, and read_projectfile before changing existing project files. search includes both project files and past meeting summaries for the requested current-meeting project scope.
+        Use search, list_past_project_meetings, read_past_project_meeting_summary, and read_projectfile before changing existing project files. search includes both project files and past meeting summaries for the requested current-meeting project scope.
         The summary note should contain concise sections for summary, decisions, open questions, and next steps.
         If the assistant context contains cropped screenshot markdown links, include only the most relevant cropped screenshots in the summary by markdown-linking them near the related summary text. When embedding them, encode spaces in image-link targets as `%20`; never leave literal spaces in the link target. Do not include every cropped screenshot by default, and do not link uncropped screenshots unless no cropped version exists and the image is important.
         Keep the output grounded in the source material and explicitly say when a section has no known items.
         """;
 
+    private const string ProjectAndRequestInstructions = """
+        Project discovery and approval:
+        list_projects returns every configured project's id, displayname, and description; only projects in the current meeting note's projects frontmatter are accessible for reads, writes, search, and historical summaries. Catalog visibility does not grant file access.
+        Before finalizing the summary, use the catalog when meeting evidence suggests a missing project association. Call request_project_association with its exact id and a short evidence-based reason (one line, at most 100 characters). It waits for user approval for up to ten minutes. A denial or timeout grants no access; continue with the existing scope. Approval adds the project to the meeting and returns its current project instructions; follow them immediately.
+        For each associated project, maintain a root PROJECT.md with YAML frontmatter name (display name) and description (at most 256 characters). Describe the project's purpose and distinguishing context so future summarizers can select it. Read existing content first and use write_projectfile to create missing metadata or update it from grounded knowledge, preserving other fields and body notes. Do not invent facts or write unassociated projects.
+        If a workflow improvement would help, use request_workflow_change with a short one-line intention (at most 100 characters) and a detailed self-contained change prompt, preferably a scenario/specification with expected behavior. This returns requested immediately and does not mean approved or implemented. Continue summarizing; only user approval starts the separate settings agent. You cannot change workflows directly.
+        """;
+
     private readonly MeetingAssistantOptions options;
     private readonly BoundMeetingProjectResolver projectResolver;
 
@@ -50,6 +58,7 @@ public sealed class MeetingSummaryInstructionBuilder : IMeetingSummaryInstructio
         var instructions = string.IsNullOrWhiteSpace(options.Agent.InitialPrompt)
             ? DefaultInitialPrompt
             : options.Agent.InitialPrompt.Trim();
+        instructions = instructions.TrimEnd() + "\n\n" + ProjectAndRequestInstructions;
         var projectInstructions = await BuildProjectInstructionsAsync(artifacts, options, cancellationToken);
         return string.IsNullOrWhiteSpace(projectInstructions)
             ? instructions
@@ -60,44 +69,15 @@ public sealed class MeetingSummaryInstructionBuilder : IMeetingSummaryInstructio
         MeetingSessionArtifacts artifacts,
         MeetingAssistantOptions options,
         CancellationToken cancellationToken)
-    {
-        var projects = await GetBoundProjectsWithInstructionsAsync(artifacts, options, cancellationToken);
-        if (projects.Count == 0)
-        {
-            return "";
-        }
-
-        var blocks = projects.Select(project =>
-            $"# {project.Name}\n\n{project.Instructions.Trim()}");
-        return "---\nprojects:\n\n" + string.Join("\n\n", blocks);
-    }
-
-    private async Task<List<ProjectInstructions>> GetBoundProjectsWithInstructionsAsync(
-        MeetingSessionArtifacts artifacts,
-        MeetingAssistantOptions options,
-        CancellationToken cancellationToken)
     {
         var resolver = ReferenceEquals(options, this.options)
             ? projectResolver
             : new BoundMeetingProjectResolver(options);
-        var projects = new List<ProjectInstructions>();
+        var blocks = new List<string>();
         foreach (var project in await resolver.GetBoundProjectsAsync(artifacts, cancellationToken))
         {
-            var agentsPath = Path.Combine(project.Path, "AGENTS.md");
-            if (!File.Exists(agentsPath))
-            {
-                continue;
-            }
-
-            var content = await File.ReadAllTextAsync(agentsPath, cancellationToken);
-            if (!string.IsNullOrWhiteSpace(content))
-            {
-                projects.Add(new ProjectInstructions(project.Name, content));
-            }
+            blocks.Add(await ProjectMetadata.BuildContextAsync(project, cancellationToken));
         }
-
-        return projects;
+        return blocks.Count == 0 ? "" : "---\nprojects:\n\n" + string.Join("\n\n", blocks);
     }
-
-    private sealed record ProjectInstructions(string Name, string Instructions);
 }

MeetingAssistant/Summary/MeetingSummaryTools.cs

@@ -2,6 +2,9 @@ using MeetingAssistant.MeetingNotes;
 using MeetingAssistant.Speakers;
 using MeetingAssistant.Transcription;
 using MeetingAssistant.Workflow;
+using System.Text.Json;
+using MeetingAssistant.Notifications;
+using YamlDotNet.RepresentationModel;
 using YamlDotNet.Serialization;
 
 namespace MeetingAssistant.Summary;
@@ -16,6 +19,8 @@ public sealed class MeetingSummaryTools
     private readonly SummaryAgentWriteAudit? writeAudit;
     private readonly IMeetingWorkflowEngine meetingWorkflowEngine;
     private readonly BoundMeetingProjectResolver projectResolver;
+    private readonly AgentApprovalService? approvals;
+    private readonly WorkflowChangeRequestService? workflowRequests;
 
     public MeetingSummaryTools(MeetingSessionArtifacts artifacts)
         : this(artifacts, new MeetingAssistantOptions(), null)
@@ -27,7 +32,9 @@ public sealed class MeetingSummaryTools
         MeetingAssistantOptions options,
         IDictationWordStore? dictationWordStore = null,
         SummaryAgentWriteAudit? writeAudit = null,
-        IMeetingWorkflowEngine? meetingWorkflowEngine = null)
+        IMeetingWorkflowEngine? meetingWorkflowEngine = null,
+        AgentApprovalService? approvals = null,
+        WorkflowChangeRequestService? workflowRequests = null)
     {
         this.artifacts = artifacts;
         this.options = options;
@@ -35,6 +42,8 @@ public sealed class MeetingSummaryTools
         this.writeAudit = writeAudit;
         this.meetingWorkflowEngine = meetingWorkflowEngine ?? NoopMeetingWorkflowEngine.Instance;
         projectResolver = new BoundMeetingProjectResolver(options);
+        this.approvals = approvals;
+        this.workflowRequests = workflowRequests;
     }
 
     public Task<string> ReadTranscript(int? @from = null, int? to = null, int? tail = null)
@@ -291,8 +300,71 @@ public sealed class MeetingSummaryTools
 
     public async Task<string> ListProjects()
     {
-        var projects = await GetBoundProjectsAsync();
-        return string.Join('\n', projects.Select(project => project.Name));
+        var projects = await Task.WhenAll(projectResolver.GetAllProjects().Select(project => ProjectMetadata.ReadAsync(project)));
+        return JsonSerializer.Serialize(projects.Select(project => new
+        {
+            id = project.Id, displayname = project.DisplayName, description = project.Description
+        }));
+    }
+
+    public async Task<string> RequestProjectAssociation(string project_id, string reason, CancellationToken cancellationToken = default)
+    {
+        if (string.IsNullOrWhiteSpace(reason) || reason.Length > 100 || reason.Contains('\n') || reason.Contains('\r'))
+            return "Refused: reason must be a nonempty single line of at most 100 characters.";
+        var project = projectResolver.GetAllProjects()
+            .FirstOrDefault(candidate => string.Equals(candidate.Name, project_id, StringComparison.OrdinalIgnoreCase));
+        if (project is null) return "Refused: unknown project ID.";
+        var associated = await projectResolver.ReadMeetingProjectNamesAsync(artifacts, cancellationToken);
+        if (!associated.Contains(project.Name))
+        {
+            var metadata = await ProjectMetadata.ReadAsync(project, cancellationToken);
+            if (approvals is null || !await approvals.ConfirmAsync("Project association requested",
+                $"Associate {metadata.DisplayName} ({metadata.Id}) with {Path.GetFileName(artifacts.MeetingNotePath)}?\n{reason}",
+                cancellationToken))
+                return "Denied: project association was not approved.";
+
+            cancellationToken.ThrowIfCancellationRequested();
+            if (!Directory.Exists(project.Path) || !File.Exists(artifacts.MeetingNotePath))
+                return "Refused: the project or meeting note no longer exists.";
+            await AddProjectAssociationAsync(project.Name, cancellationToken);
+        }
+
+        return "Approved: project is associated with this meeting.\n\n"
+            + await ProjectMetadata.BuildContextAsync(project, cancellationToken);
+    }
+
+    public string RequestWorkflowChange(string intention, string detailed_prompt)
+        => workflowRequests?.Request(intention, detailed_prompt, artifacts.MeetingNotePath)
+            ?? "Refused: workflow change requests are unavailable.";
+
+    private async Task AddProjectAssociationAsync(string projectId, CancellationToken cancellationToken)
+    {
+        var content = await File.ReadAllTextAsync(artifacts.MeetingNotePath, cancellationToken);
+        var document = MarkdownDocumentParser.SplitRequired(content,
+            "Meeting note requires frontmatter.", "Meeting note frontmatter is not closed.");
+        var yaml = new YamlStream();
+        yaml.Load(new StringReader(document.Frontmatter));
+        var mapping = (YamlMappingNode)yaml.Documents.Single().RootNode;
+        mapping.Children.TryGetValue(new YamlScalarNode("projects"), out var existing);
+        var projects = existing as YamlSequenceNode ?? new YamlSequenceNode();
+        if (existing is YamlScalarNode scalar && !string.IsNullOrWhiteSpace(scalar.Value))
+            projects.Add(new YamlScalarNode(scalar.Value));
+        if (!projects.Children.OfType<YamlScalarNode>().Any(value => string.Equals(value.Value, projectId, StringComparison.OrdinalIgnoreCase)))
+            projects.Add(new YamlScalarNode(projectId));
+        mapping.Children[new YamlScalarNode("projects")] = projects;
+        using var writer = new StringWriter();
+        yaml.Save(writer, assignAnchors: false);
+        var pendingPath = artifacts.MeetingNotePath + "." + Guid.NewGuid().ToString("N") + ".tmp";
+        try
+        {
+            await File.WriteAllTextAsync(pendingPath, "---\n" + writer + "---\n\n" + document.Body, cancellationToken);
+            cancellationToken.ThrowIfCancellationRequested();
+            File.Replace(pendingPath, artifacts.MeetingNotePath, destinationBackupFileName: null);
+        }
+        finally
+        {
+            File.Delete(pendingPath);
+        }
     }
 
     public async Task<string> ListProjectFiles(string project)
@@ -375,10 +447,18 @@ public sealed class MeetingSummaryTools
             return "Refused: supply either both from and to for replacement, insert for insertion, or no line arguments for append; set replace_file=true only for whole-file replacement.";
         }
 
-        var target = ResolveExistingProjectFilePath(project, path);
+        var target = await ResolveBoundProjectFileTargetAsync(project, path);
         if (target is null)
         {
-            return "Refused: project does not exist or the path escapes the project folder.";
+            return "Refused: project is not assigned to this meeting, does not exist, or the path escapes the project folder.";
+        }
+
+        var existingContent = File.Exists(target.Path) ? await File.ReadAllTextAsync(target.Path) : "";
+        var updatedContent = AgentFileToolContent.ApplyLineEdit(existingContent, content, editMode);
+        if (string.Equals(Path.GetRelativePath(target.Project.Path, target.Path), "PROJECT.md", StringComparison.OrdinalIgnoreCase)
+            && !ProjectMetadata.IsValidContent(updatedContent))
+        {
+            return "Refused: PROJECT.md requires YAML frontmatter name and description; description must be at most 256 characters.";
         }
 
         Directory.CreateDirectory(Path.GetDirectoryName(target.Path)!);
@@ -386,11 +466,11 @@ public sealed class MeetingSummaryTools
         {
             await writeAudit.CaptureFileWriteAsync(
                 target.Path,
-                () => AgentFileToolContent.WriteFileContentAsync(target.Path, content, editMode));
+                () => File.WriteAllTextAsync(target.Path, updatedContent));
         }
         else
         {
-            await AgentFileToolContent.WriteFileContentAsync(target.Path, content, editMode);
+            await File.WriteAllTextAsync(target.Path, updatedContent);
         }
 
         return $"{target.Project.Name}/{AgentFileToolContent.ToToolPath(path)}";
@@ -589,7 +669,7 @@ public sealed class MeetingSummaryTools
         return AgentFileToolContent.IsWithinDirectory(projectRoot, fullPath) ? fullPath : null;
     }
 
-    private ProjectFileTarget? ResolveExistingProjectFilePath(string project, string path)
+    private async Task<ProjectFileTarget?> ResolveBoundProjectFileTargetAsync(string project, string path)
     {
         if (string.IsNullOrWhiteSpace(project) ||
             string.IsNullOrWhiteSpace(path) ||
@@ -598,15 +678,7 @@ public sealed class MeetingSummaryTools
             return null;
         }
 
-        var projectsRoot = GetProjectsRoot();
-        if (!Directory.Exists(projectsRoot))
-        {
-            return null;
-        }
-
-        var projectFolder = Directory.EnumerateDirectories(projectsRoot)
-            .Select(candidate => new BoundMeetingProject(Path.GetFileName(candidate), candidate))
-            .FirstOrDefault(candidate => string.Equals(candidate.Name, project, StringComparison.OrdinalIgnoreCase));
+        var projectFolder = await ResolveBoundProjectAsync(project);
         if (projectFolder is null)
         {
             return null;

MeetingAssistant/Summary/OpenAiMeetingSummaryAgentPipeline.cs

@@ -1,4 +1,5 @@
 using MeetingAssistant.MeetingNotes;
+using MeetingAssistant.Notifications;
 using MeetingAssistant.Transcription;
 using MeetingAssistant.Workflow;
 using Microsoft.Agents.AI;
@@ -19,6 +20,8 @@ public sealed class OpenAiMeetingSummaryAgentPipeline : IMeetingSummaryPipeline
     private readonly IMeetingSummaryInstructionBuilder instructionBuilder;
     private readonly IDictationWordStore dictationWordStore;
     private readonly IMeetingWorkflowEngine meetingWorkflowEngine;
+    private readonly AgentApprovalService approvals;
+    private readonly WorkflowChangeRequestService workflowRequests;
 
     public OpenAiMeetingSummaryAgentPipeline(
         IOptions<MeetingAssistantOptions> options,
@@ -28,7 +31,9 @@ public sealed class OpenAiMeetingSummaryAgentPipeline : IMeetingSummaryPipeline
         IMeetingSummaryFailureWriter failureWriter,
         IMeetingSummaryInstructionBuilder instructionBuilder,
         IDictationWordStore dictationWordStore,
-        IMeetingWorkflowEngine meetingWorkflowEngine)
+        IMeetingWorkflowEngine meetingWorkflowEngine,
+        AgentApprovalService approvals,
+        WorkflowChangeRequestService workflowRequests)
     {
         this.options = options.Value;
         this.loggerFactory = loggerFactory;
@@ -38,6 +43,8 @@ public sealed class OpenAiMeetingSummaryAgentPipeline : IMeetingSummaryPipeline
         this.instructionBuilder = instructionBuilder;
         this.dictationWordStore = dictationWordStore;
         this.meetingWorkflowEngine = meetingWorkflowEngine;
+        this.approvals = approvals;
+        this.workflowRequests = workflowRequests;
     }
 
     public async Task<MeetingSummaryRunResult> RunAsync(
@@ -60,7 +67,9 @@ public sealed class OpenAiMeetingSummaryAgentPipeline : IMeetingSummaryPipeline
             options,
             dictationWordStore,
             writeAudit,
-            meetingWorkflowEngine);
+            meetingWorkflowEngine,
+            approvals,
+            workflowRequests);
         var tools = CreateTools(meetingTools);
         var instructions = await instructionBuilder.BuildAsync(artifacts, options, cancellationToken);
         using var compactionSummaryClient = LiteLlmResponsesChatClient.Create(
@@ -80,7 +89,11 @@ public sealed class OpenAiMeetingSummaryAgentPipeline : IMeetingSummaryPipeline
             .AsBuilder()
             .UseFunctionInvocation(
                 loggerFactory,
-                client => client.FunctionInvoker = FunctionInvocationGuard.InvokeAsync)
+                client =>
+                {
+                    client.FunctionInvoker = FunctionInvocationGuard.InvokeAsync;
+                    client.AllowConcurrentInvocation = false;
+                })
             .Build()
             .AsAIAgent(
                 instructions,
@@ -176,7 +189,15 @@ public sealed class OpenAiMeetingSummaryAgentPipeline : IMeetingSummaryPipeline
             AIFunctionFactory.Create(
                 tools.ListProjects,
                 "list_projects",
-                "List the configured project folders bound to the current meeting note frontmatter."),
+                "List all configured projects with id, displayname and description. Catalog visibility does not grant access; project files require current meeting association."),
+            AIFunctionFactory.Create(
+                tools.RequestProjectAssociation,
+                "request_project_association",
+                "Request user approval to associate a project_id with this meeting. reason must be one line and at most 100 characters. Waits up to ten minutes; approval adds the project and returns its AGENTS.md if present."),
+            AIFunctionFactory.Create(
+                tools.RequestWorkflowChange,
+                "request_workflow_change",
+                "Request a workflow change with a one-line intention (maximum 100 characters) and a detailed_prompt describing the desired scenario/specification. Returns requested immediately; user approval separately opens and starts the settings agent."),
             AIFunctionFactory.Create(
                 tools.ListProjectFiles,
                 "list_projectfiles",
@@ -188,7 +209,7 @@ public sealed class OpenAiMeetingSummaryAgentPipeline : IMeetingSummaryPipeline
             AIFunctionFactory.Create(
                 tools.WriteProjectFile,
                 "write_projectfile",
-                "Write a file inside an existing project folder. With no line arguments, append or create the file. Set replace_file=true only when intentionally replacing the whole file. With from and to, replace that inclusive 1-based line range. With insert, insert content at that 1-based line position."),
+                "Write a file inside a project associated with the current meeting. Root PROJECT.md requires YAML name and description (maximum 256 characters). With no line arguments, append or create. Set replace_file=true only for intentional whole-file replacement. With from and to, replace that inclusive 1-based line range; with insert, insert at that line."),
             AIFunctionFactory.Create(
                 tools.ListPastProjectMeetings,
                 "list_past_project_meetings",

MeetingAssistant/Summary/ProjectMetadata.cs

@@ -0,0 +1,55 @@
+using MeetingAssistant.MeetingNotes;
+using YamlDotNet.Core;
+using YamlDotNet.Serialization;
+
+namespace MeetingAssistant.Summary;
+
+public sealed record ProjectMetadata(string Id, string DisplayName, string Description)
+{
+    public static async Task<string> BuildContextAsync(BoundMeetingProject project, CancellationToken cancellationToken = default)
+    {
+        var metadata = await ReadAsync(project, cancellationToken);
+        var context = $"# {metadata.Id}\nDisplay name: {metadata.DisplayName}\nDescription: {metadata.Description}";
+        var agentsPath = Path.Combine(project.Path, "AGENTS.md");
+        if (File.Exists(agentsPath))
+        {
+            var instructions = await File.ReadAllTextAsync(agentsPath, cancellationToken);
+            if (!string.IsNullOrWhiteSpace(instructions)) context += "\n\n" + instructions.Trim();
+        }
+        return context;
+    }
+
+    public static bool IsValidContent(string content) => Parse(content) is not null;
+
+    public static async Task<ProjectMetadata> ReadAsync(BoundMeetingProject project, CancellationToken cancellationToken = default)
+    {
+        var path = Path.Combine(project.Path, "PROJECT.md");
+        var metadata = File.Exists(path) ? Parse(await File.ReadAllTextAsync(path, cancellationToken)) : null;
+        return new(project.Name,
+            string.IsNullOrWhiteSpace(metadata?.Name) ? project.Name : metadata.Name.Trim(),
+            metadata?.Description?.Trim() ?? "");
+    }
+
+    private static Frontmatter? Parse(string content)
+    {
+        try
+        {
+            var document = MarkdownDocumentParser.SplitOptional(content);
+            if (!document.HasFrontmatter) return null;
+            var metadata = FrontmatterYamlDeserializer.Create().Deserialize<Frontmatter>(document.Frontmatter);
+            return string.IsNullOrWhiteSpace(metadata?.Name) || metadata.Description is null || metadata.Description.Length > 256
+                ? null
+                : metadata;
+        }
+        catch (YamlException) { return null; }
+        catch (InvalidDataException) { return null; }
+    }
+
+    private sealed class Frontmatter
+    {
+        [YamlMember(Alias = "name")]
+        public string? Name { get; set; }
+        [YamlMember(Alias = "description")]
+        public string? Description { get; set; }
+    }
+}

MeetingAssistant/Summary/WorkflowChangeRequestService.cs

@@ -0,0 +1,70 @@
+using MeetingAssistant.Notifications;
+using MeetingAssistant.Workflow;
+using System.Threading.Channels;
+
+namespace MeetingAssistant.Summary;
+
+public sealed class WorkflowChangeRequestService(
+    AgentApprovalService approvals,
+    IWorkflowRulesEditorWindowService editor,
+    ILogger<WorkflowChangeRequestService> logger) : BackgroundService
+{
+    private readonly Channel<RequestDetails> requests = Channel.CreateUnbounded<RequestDetails>(
+        new UnboundedChannelOptions { SingleReader = true });
+
+    public string Request(string intention, string detailedPrompt, string meetingNotePath)
+    {
+        if (string.IsNullOrWhiteSpace(intention) || intention.Length > 100 || intention.Contains('\r') || intention.Contains('\n'))
+            return "Refused: intention must be a nonempty single line of at most 100 characters.";
+        if (string.IsNullOrWhiteSpace(detailedPrompt))
+            return "Refused: supply a detailed change prompt, preferably a scenario or specification.";
+        var request = new RequestDetails(Guid.NewGuid().ToString("N"), intention, detailedPrompt, meetingNotePath);
+        return requests.Writer.TryWrite(request) ? $"Requested: {request.Id}. User approval is pending."
+            : "Refused: application is stopping.";
+    }
+
+    protected override async Task ExecuteAsync(CancellationToken stoppingToken)
+    {
+        var pending = new List<Task>();
+        try
+        {
+            await foreach (var request in requests.Reader.ReadAllAsync(stoppingToken))
+            {
+                pending.RemoveAll(task => task.IsCompleted);
+                pending.Add(HandleAsync(request, stoppingToken));
+            }
+        }
+        catch (OperationCanceledException) when (stoppingToken.IsCancellationRequested) { }
+        finally
+        {
+            await Task.WhenAll(pending);
+        }
+    }
+
+    private async Task HandleAsync(RequestDetails request, CancellationToken cancellationToken)
+    {
+        try
+        {
+            if (await approvals.ConfirmAsync($"Workflow change requested: {request.Intention}",
+                $"The summarizer for {Path.GetFileName(request.MeetingNotePath)} requests a workflow change. Open the settings agent to apply it?",
+                cancellationToken))
+            {
+                cancellationToken.ThrowIfCancellationRequested();
+                editor.ShowWithPrompt(request.DetailedPrompt);
+            }
+        }
+        catch (OperationCanceledException) when (cancellationToken.IsCancellationRequested) { }
+        catch (Exception exception)
+        {
+            logger.LogWarning(exception, "Workflow request {RequestId} could not be handled", request.Id);
+        }
+    }
+
+    public override Task StopAsync(CancellationToken cancellationToken)
+    {
+        requests.Writer.TryComplete();
+        return base.StopAsync(cancellationToken);
+    }
+
+    private sealed record RequestDetails(string Id, string Intention, string DetailedPrompt, string MeetingNotePath);
+}

MeetingAssistant/Workflow/IWorkflowRulesEditorWindowService.cs

@@ -3,6 +3,7 @@ namespace MeetingAssistant.Workflow;
 public interface IWorkflowRulesEditorWindowService
 {
     void Show();
+    void ShowWithPrompt(string initialPrompt);
 }
 
 public sealed class NoopWorkflowRulesEditorWindowService : IWorkflowRulesEditorWindowService
@@ -18,4 +19,6 @@ public sealed class NoopWorkflowRulesEditorWindowService : IWorkflowRulesEditorW
     {
         logger.LogInformation("Workflow rules editor UI is only available on Windows");
     }
+
+    public void ShowWithPrompt(string initialPrompt) => Show();
 }

MeetingAssistant/Workflow/WorkflowRulesEditorChatViewModel.cs

@@ -25,9 +25,11 @@ public sealed class WorkflowRulesEditorChatViewModel
 
     public event EventHandler? Changed;
 
-    public async Task SendAsync(CancellationToken cancellationToken = default)
+    public Task SendAsync(CancellationToken cancellationToken = default) => SendPromptAsync(Draft, cancellationToken);
+
+    public async Task SendPromptAsync(string prompt, CancellationToken cancellationToken = default)
     {
-        var prompt = Draft.Trim();
+        prompt = prompt.Trim();
         if (string.IsNullOrWhiteSpace(prompt) || IsThinking)
         {
             return;

MeetingAssistant/Workflow/WorkflowRulesEditorSamplePlaybackQueue.cs

@@ -8,6 +8,7 @@ public interface IWorkflowRulesEditorSamplePlaybackQueue
     Task<string> QueueAsync(int sampleId, byte[] wavBytes, CancellationToken cancellationToken = default);
 }
 
+#if WINDOWS
 public sealed class WorkflowRulesEditorSamplePlaybackQueue : IWorkflowRulesEditorSamplePlaybackQueue, IDisposable
 {
     private readonly Channel<QueuedSample> channel = Channel.CreateUnbounded<QueuedSample>();
@@ -98,3 +99,13 @@ public sealed class WorkflowRulesEditorSamplePlaybackQueue : IWorkflowRulesEdito
 
     private sealed record QueuedSample(int SampleId, byte[] WavBytes);
 }
+#else
+public sealed class UnavailableWorkflowRulesEditorSamplePlaybackQueue : IWorkflowRulesEditorSamplePlaybackQueue
+{
+    public Task<string> QueueAsync(int sampleId, byte[] wavBytes, CancellationToken cancellationToken = default)
+    {
+        cancellationToken.ThrowIfCancellationRequested();
+        return Task.FromResult("Speaker sample playback requires the Windows build of Meeting Assistant.");
+    }
+}
+#endif

MeetingAssistant/Workflow/WpfWorkflowRulesEditorWindowService.Windows.cs

@@ -37,6 +37,26 @@ internal sealed class WpfWorkflowRulesEditorWindowService : IWorkflowRulesEditor
         dispatcher?.BeginInvoke(ShowOnUiThread);
     }
 
+    public void ShowWithPrompt(string initialPrompt)
+    {
+        EnsureUiThread();
+        dispatcher?.BeginInvoke(new Action(async () =>
+        {
+            try
+            {
+                var viewModel = services.GetRequiredService<WorkflowRulesEditorChatViewModel>();
+                var requestedWindow = new WorkflowRulesEditorWpfWindow(viewModel, linkResolver, () => { });
+                requestedWindow.Show();
+                requestedWindow.Activate();
+                await viewModel.SendPromptAsync(initialPrompt);
+            }
+            catch (Exception exception)
+            {
+                logger.LogError(exception, "Could not start settings agent for an approved workflow request");
+            }
+        }));
+    }
+
     private void EnsureUiThread()
     {
         lock (sync)

README.md

@@ -60,12 +60,16 @@ Pausing transcription keeps the active recognition pipeline and meeting session
 
 During an active run, microphone creation failures and disconnects are retried every second with fresh endpoint selection. The meeting and system-loopback capture stay active, with microphone silence mixed in until capture resumes. This recovery does not cover a failed system-loopback source.
 
+A newly available microphone during a meeting triggers a Windows notification with its name and Yes/No actions, including while transcription is paused. Yes switches the current microphone within the same meeting; No or no response keeps capture unchanged. Each device is offered once per meeting, and unanswered prompts expire after one minute.
+
 Outlook enrichment selects an unambiguous current or imminent appointment. A scheduled prompt shown during an active recording can apply that exact appointment's title, eligible attendees, agenda, and scheduled end without interrupting capture; explicit prompt metadata wins over a slower background lookup.
 
 ## Data And Side Effects
 
 Meeting Assistant writes meeting notes, transcripts, assistant context, summaries, and project knowledge into the configured Obsidian vault. Assistant context is persistent meeting-specific memory: the summarizer records problems and assumptions, and the interactive agent can read it and append later repairs and conclusions.
 
+Project discovery uses the `name` and short `description` in each project's `PROJECT.md`. The summarizer can request missing associations through a Yes/No notification that waits up to ten minutes; only approval adds the project and enables its file access. Workflow-change requests return immediately and, when approved, open a separate settings-agent conversation with the proposed change.
+
 Agents are intentionally stateful. Depending on the invoked tools, they can change workflow rules and appsettings, create or update project and meeting files, change frontmatter, merge or delete speaker identities and samples, run diagnostics, and trigger transcription or summary work. Screenshot OCR can add recognized attendee names to the meeting note after workflow transformation; OCR of images already embedded in the meeting note does not add attendees or modify that note.
 
 Local runtime state outside the vault includes:

docs/meeting-assistant-configuration.md

@@ -136,7 +136,9 @@ The tray's fine-grained controls expose `Pause transcription` while a meeting is
 
 On Windows, `Recording:MicrophoneDeviceId` can pin capture to a specific active microphone endpoint id. Leave it blank to follow the Windows default capture endpoint. The tray icon menu also exposes `Microphone`, listing active microphone endpoints with the effective endpoint checked. Selecting a microphone there overrides the configured/default microphone for later recording starts until another microphone is selected or the process exits.
 
-`Recording:MicrophoneMixGain` and `Recording:SystemAudioMixGain` are applied during the final mix and default to `1`. `Recording:TemporaryRecordingsFolder` controls where the temporary mixed WAV is written while the run is active. Temporary WAV files are deleted after the run completes, and stale temporary recordings from interrupted runs are deleted when the application starts. If an Azure Speech meeting cannot drain transcription before `Recording:StopProcessingTimeout`, Meeting Assistant keeps the WAV and writes a durable backlog item under `TemporaryRecordingsFolder\offline-transcription-backlog`. The background backlog worker retries those queued meetings, replays each WAV through a fresh speech pipeline, rewrites the original transcript, completes meeting metadata and summary generation, then removes the backlog item and WAV.
+During active capture, including paused transcription, active microphone endpoints are checked once per second. A newly available endpoint produces a Windows notification naming the microphone with Yes/No actions; endpoints already present when capture starts are not offered. Yes changes the shared runtime microphone selection and replaces the current microphone capture, preserving the meeting, system audio, transcription session, and pause state. The selection also applies to later recordings until changed or the process exits. No or an unanswered prompt leaves capture unchanged. Each endpoint is offered at most once per meeting. Prompts become invalid after one minute, when the endpoint disappears, or when that recording stops; a stale notification cannot change a later recording.
+
+`Recording:MicrophoneMixGain` and `Recording:SystemAudioMixGain` are applied during the final mix and default to `1`. `Recording:TemporaryRecordingsFolder` controls where the temporary mixed WAV is written while the run is active. Temporary WAV files are deleted after the run completes, and stale temporary recordings from interrupted runs are deleted when the application starts. If an Azure Speech meeting cannot drain transcription before `Recording:StopProcessingTimeout`, Meeting Assistant keeps the WAV and writes a durable backlog item under `TemporaryRecordingsFolder\offline-transcription-backlog`. The background backlog worker retries those queued meetings and replays each WAV through a fresh speech pipeline. A replay without non-blank speech text leaves the artifacts unchanged and retains the backlog item and WAV for another retry. A usable replay preserves the existing transcript body and appends a recovery section explaining that the full recording was replayed and may duplicate earlier passages; the summary agent receives both the original and recovered text with that explanation. The worker then completes meeting metadata and summary generation and removes the backlog item and WAV.
 
 `Recording:MaxMetadataAttendeeImportCount` limits how many attendees Outlook metadata enrichment imports into meeting-note frontmatter. The default is `30`; when an appointment has more attendees than that, Meeting Assistant still imports title, agenda, and scheduled end time, but leaves attendees empty because large invites are usually presentation-style meetings.
 
@@ -387,11 +389,30 @@ When enabled on Windows, Meeting Assistant periodically syncs today's Outlook Cl
 | `EnableCompaction` | Enables conversation compaction before requests exceed the configured context budget. |
 | `CompactionRemainingRatio` | Remaining-context ratio that triggers compaction. |
 | `ResponsesCompactPath` | Relative Responses compaction path, usually `responses/compact`. |
-| `InitialPrompt` | Optional complete replacement for the default summary-agent system instructions. |
+| `InitialPrompt` | Optional replacement for the default base summary instructions. Project metadata and approval guidance is appended to both default and custom prompts. |
 
 After transcription has fully finished, Meeting Assistant automatically runs the summary pipeline for the meeting. The summary agent writes the full markdown summary through `write_summary` and must provide a required `oneliner` value, which is stored in summary frontmatter and must not contain line breaks.
 
-The built-in summary-agent instructions treat assistant context as persistent meeting-specific memory. When the agent encounters an unexpected problem, missing information, or an assumption while summarizing, it appends a concise note through `write_context` so later work on the same meeting can use that history. A configured `Agent:InitialPrompt` completely replaces the built-in instructions, so custom prompts must include equivalent guidance when this behavior is desired.
+The built-in summary-agent instructions treat assistant context as persistent meeting-specific memory. When the agent encounters an unexpected problem, missing information, or an assumption while summarizing, it appends a concise note through `write_context` so later work on the same meeting can use that history. A configured `Agent:InitialPrompt` replaces the built-in base instructions, so custom prompts must include equivalent memory guidance when this behavior is desired. Project metadata and approval guidance is always appended.
+
+Every direct subfolder of `Vault:ProjectsFolder` is a project whose ID is its folder name. The summarizer maintains a root `PROJECT.md` for associated projects with YAML frontmatter such as:
+
+```yaml
+---
+name: Alpha Platform
+description: Meeting automation and shared project knowledge.
+---
+```
+
+The display name comes from `name`; `description` is limited to 256 characters. Missing or malformed metadata falls back to the folder ID and an empty description. Bound project metadata is included in the initial prompt beside any root `AGENTS.md`, including when no instructions file exists. Both default and custom prompts instruct the agent to keep this metadata grounded and current while preserving other frontmatter and body notes.
+
+`list_projects` returns the complete catalog as JSON entries with `id`, `displayname`, and `description`. This grants no file access. Reading, writing, searching, and retrieving historical summaries remain scoped to the meeting note's `projects` field. The summarizer uses its existing `write_projectfile` tool to maintain `PROJECT.md`; invalid resulting metadata is refused before writing.
+
+`request_project_association(project_id, reason)` asks the user through a native Yes/No notification. The reason must be one nonempty line of at most 100 characters. The tool blocks the summarizer until the decision or a ten-minute timeout. Approval adds the canonical ID to the latest meeting note, preserves other metadata and notes, immediately enables project access, and returns the project's metadata and optional `AGENTS.md`. No, timeout, cancellation, or unavailable notifications grant no access. Expired notifications are removed and late actions have no effect. Already associated projects return context without another prompt.
+
+`request_workflow_change(intention, detailed_prompt)` returns requested immediately. The intention is a nonempty single line of at most 100 characters; the detailed prompt should be a self-contained scenario or specification. Its native notification remains valid for ten minutes and can be accepted after the summary completes. Approval opens a separate settings-agent conversation and submits the complete prompt automatically. Declining or expiration opens nothing. Requests are held in memory and canceled on application shutdown. The summarizer itself receives no workflow-editing tools.
+
+Once a stopped meeting reaches summarization, expiration of `Recording:StopProcessingTimeout` returns control while that run continues in the background. It does not cancel a summary waiting for project approval or queue that already-transcribed meeting for offline replay. The approval's own ten-minute deadline remains in effect.
 
 The summary agent can add and remove meeting-note attendees when transcript or OCR evidence is clear. It can override transcript speaker labels only when the evidence is very certain, and it can delete wrongfully matched identities. Final speaker identity learning and candidate updates run after the summary pipeline finishes so they use the summary-refined attendee list and any recorded speaker identity changes.
 

docs/meeting-workflow-engine.md

@@ -1,5 +1,7 @@
 # Meeting Workflow Engine
 
+The interactive rules and identities editor can queue speaker samples for playback in the Windows build. The neutral build reports that playback requires the Windows build; it does not enqueue audio or initialize Windows audio devices.
+
 Meeting Assistant has a small local workflow engine for meeting-specific automation. It is intended for rules that are too personal or environment-specific to hard-code, such as adding default attendees, cleaning meeting titles, binding projects, or adding context notes when known speakers are detected.
 
 The workflow engine is deliberately narrow. It runs from a local YAML file, evaluates rules against the current meeting note read from disk, and applies a small set of meeting-safe mutations.
@@ -24,6 +26,10 @@ If the configured path is empty, missing, or points to a blank file, the workflo
 
 The tray menu includes `Open agent`, which opens the `Meeting Summary Agent` chat window for this configured rules file, the local speaker identity database, appsettings configuration, and application logs. The assistant uses the summarizer agent configuration by default and can be overridden through `MeetingAssistant:WorkflowRulesEditor`.
 
+The automatic summarizer can propose changes through `request_workflow_change(intention, detailed_prompt)` but has no direct workflow write tool. `intention` is one nonempty line of at most 100 characters; `detailed_prompt` contains the complete desired change, preferably as a scenario/specification. A Windows notification displays `Workflow change requested: ...` with Yes/No actions. The tool returns requested immediately so summarization continues. Yes opens a separate settings-agent window and automatically submits the complete detailed prompt; existing conversations and drafts are left intact. No or ten minutes without approval discards the request and removes the notification. Workflow requests can be approved after their summary finishes but are not persisted across application restarts. The settings agent applies approved requests through its normal validated tools.
+
+Project association requests follow a separate blocking path. `request_project_association` waits up to ten minutes before the summarizer continues; approval appends the project ID to meeting frontmatter and returns its instructions. This does not emit a new workflow trigger or change the YAML rule schema. See the configuration guide for project catalog metadata and access rules.
+
 ```json
 {
   "MeetingAssistant": {
@@ -93,6 +99,8 @@ For every event, the engine:
 
 For `transcript_line` events, the engine returns the possibly updated transcript line to the caller. Live transcript appends first write the original formatted line and keep a reference to that exact body line, then run transcript-line rules out of band. Later transcript segments can continue to be appended while the workflow runs. If rules return a changed line, Meeting Assistant rewrites the referenced line in the transcript file. If a transcript-line rule fails during live recording, Meeting Assistant logs the failure and keeps the original line so later transcript segments can continue to be written.
 
+Offline transcription recovery applies `transcript_line` transformations to the recovered lines before appending them to the existing transcript. Earlier transcript content is preserved and is not transformed again. Each appended recovery section starts with a visible marker explaining that replaying the entire recording may produce duplicate passages, which the summary agent should treat as the same discussion. The marker bypasses transcript-line rules so the recovery explanation remains intact. A replay without non-blank speech text skips workflow events, transcript writes, and summarization, and retains its backlog item and WAV for another retry.
+
 Rules are best-effort automation for live transcript persistence. The settings/logs write tool rejects invalid YAML, unknown steps, unsupported set-property fields, trigger or condition entries without a supported key, and step value Razor templates that fail against the workflow template model before writing the rules file. Invalid NCalc expressions can still fail at workflow runtime. Workflow execution logs every triggered rule with its rule name and event type, logs completion with whether the note or transcript line changed, and logs rule failures with the rule name and event type.
 
 ## YAML Shape

openspec/changes/add-summary-agent-requests/.openspec.yaml

@@ -0,0 +1,2 @@
+schema: spec-driven
+created: 2026-09-25

openspec/changes/add-summary-agent-requests/design.md

@@ -0,0 +1,35 @@
+## Context
+
+Project IDs are direct subfolder names. BoundMeetingProjectResolver reads the meeting note on each access. The summarizer already has project read/write tools and an initial section for bound AGENTS.md instructions, but writes currently accept any existing project. Native actionable toasts and a WPF settings-agent window already exist.
+
+## Goals / Non-Goals
+
+**Goals:** Discover projects using compact metadata, extend project access only after approval, maintain metadata through the agent, and forward approved workflow requests to the interactive settings agent.
+
+**Non-Goals:** Bulk-generate metadata for unassociated projects, let the summarizer edit workflows directly, change project IDs, migrate UI frameworks, or deploy/restart the workstation service.
+
+## Decisions
+
+- Store `name` and `description` in the root `PROJECT.md` frontmatter; `name` is the display name, and the directory name remains the stable ID. Missing/invalid metadata falls back to the ID and an empty description. Catalog results contain metadata, never AGENTS.md or arbitrary project content.
+- Reuse write_projectfile for metadata maintenance. Validate resulting PROJECT.md frontmatter (name and description, maximum 256 description characters) before writing. Preserve ordinary file edit modes. Restrict writes to associated projects, matching existing read/search permissions.
+- Append metadata and AGENTS.md at the existing initial project section. Add mandatory capability guidance even when a custom base prompt is configured. Instruct the agent to maintain metadata using grounded project knowledge and propose missing associations before finalizing the summary.
+- Project approval is an awaited tool call, with cancellation and a ten-minute deadline. Return approval plus project metadata and AGENTS.md only after updating the latest meeting note. Preserve other frontmatter and body content; recheck target and cancellation before writing. Write to a temporary file in the same directory and replace the note only after that write completes, so cancellation or a partial write cannot truncate the note. Existing associations return current context without another prompt.
+- Use an application-owned background request queue for workflow approvals. The tool returns requested immediately; the queue outlives a summary run. Requests also expire after ten minutes. Only acceptance opens a new settings-agent window and automatically submits the complete detailed prompt. A new conversation avoids overwriting drafts or interrupting an existing agent run.
+- Reuse the installed native toast toolkit behind a testable approval-prompt interface. Timeouts and cancellation remove pending toasts and invalidate late actions. Shutdown cancels pending approvals; requests are not persisted across process restarts.
+- Keep tool execution sequential so a blocking project approval cannot be bypassed by concurrent tool execution in the same model response.
+
+## Risks / Trade-offs
+
+- [User ignores project approval] → continue after ten minutes as denied; no project scope or note change.
+- [User edits the note while a request is pending] → read again after acceptance and append only the project field, retaining all other current fields and notes.
+- [Project disappears or becomes invalid while waiting] → refuse the association without expanding access.
+- [Native UI cannot run in automated tests] → test approval, timeout, scope and handoff through controlled prompt/window services and build the Windows target; record hardware/UI verification limits.
+- [Summarizer completes before workflow approval] → the application queue retains the request until decision, timeout, or shutdown.
+
+## Migration Plan
+
+No bulk migration. Existing folders remain discoverable without PROJECT.md, and associated projects gain metadata as the summarizer maintains them. Rollback removes the tools; PROJECT.md and normal meeting associations remain ordinary vault content.
+
+## Open Questions
+
+None. Workflow notifications use the same ten-minute validity as project notifications; workflow notification intentions are limited to 100 characters for readability.

openspec/changes/add-summary-agent-requests/proposal.md

@@ -0,0 +1,25 @@
+## Why
+
+The summarizer cannot currently discover missing project associations or propose workflow improvements with explicit user approval. Project folder names alone do not provide enough context for selecting the right project.
+
+## What Changes
+
+- Maintain `PROJECT.md` frontmatter with `name` and a description of at most 256 characters through the summarizer's existing project-file tools.
+- Include available project metadata alongside bound project instructions and expose the full project metadata catalog through `list_projects`.
+- Add `request_project_association` with a project ID and a reason of at most 100 characters. Wait up to ten minutes for a native Yes/No notification; approval adds the association and returns project instructions.
+- Enforce meeting association for summarizer project-file writes as well as reads. Catalog visibility alone does not grant project access.
+- Add nonblocking `request_workflow_change` with a short intention and detailed scenario/specification. Approval opens a settings-agent conversation and immediately submits the detailed request; the summarizer cannot edit workflows directly.
+
+## Capabilities
+
+### New Capabilities
+- `summary-agent-requests`: User approval for blocking project association and asynchronous workflow-change handoff.
+
+### Modified Capabilities
+- `project-knowledge`: Project identity and discovery metadata in `PROJECT.md`.
+- `agent-project-tools`: Full metadata catalog and association-scoped writes.
+- `meeting-summary`: Project metadata in initial instructions and guidance for metadata maintenance and requests.
+
+## Impact
+
+Summary tools and agent instructions, project lookup and meeting frontmatter, native Windows notifications, the settings-agent window/prompt submission, DI registration, tests, and workflow/configuration documentation. Existing project IDs remain directory names; no bulk vault migration or live service restart is required.

openspec/changes/add-summary-agent-requests/specs/agent-project-tools/spec.md

@@ -0,0 +1,91 @@
+## MODIFIED Requirements
+### Requirement: Agents can use project context tools
+Meeting Assistant SHALL expose tools that allow agents to look up project information, retrieve keyword-relevant context, and inspect meeting-derived knowledge.
+
+Project tools SHALL treat each direct subfolder of the configured projects folder as one project. A meeting note binds projects by listing those subfolder names in the `projects` frontmatter field.
+
+The summary agent SHALL expose these project tools:
+
+- `list_projects`
+- `request_project_association`
+- `request_workflow_change`
+- `list_projectfiles`
+- `read_projectfile`
+- `write_projectfile`
+- `list_past_project_meetings`
+- `read_past_project_meeting_summary`
+- `search`
+
+The `search` tool SHALL search the requested current-meeting project scope, or all projects assigned to the current meeting when no project scope is supplied.
+
+The `search` tool SHALL search both configured project files for the scoped projects and past meeting summary notes in the configured summaries folder whose frontmatter projects intersect the scoped projects.
+
+The `search` tool SHALL refuse requested project scopes that are not assigned to the current meeting.
+
+#### Scenario: Agent looks up meeting project context
+- **WHEN** a meeting note identifies a project
+- **THEN** the agent can retrieve relevant project context through Meeting Assistant tools
+
+#### Scenario: Agent discovers the full project catalog
+- **WHEN** the agent calls `list_projects`
+- **THEN** it receives every configured project with ID, display name, and description
+- **AND** this catalog does not grant access to unassociated project files or AGENTS.md
+
+#### Scenario: Agent reads a clamped project file range
+- **WHEN** the agent reads a project file with optional line bounds outside the file length
+- **THEN** `read_projectfile` clamps the requested range to the available file lines without failing
+
+#### Scenario: Agent searches project knowledge
+- **WHEN** the agent calls `search` with .NET regular expression keywords
+- **THEN** Meeting Assistant runs the search against the requested projects or the meeting-bound projects and returns matches as `filename:line text`
+
+#### Scenario: Agent searches past project meeting summaries
+- **GIVEN** the current meeting note is assigned to `Project X`
+- **AND** a prior summary note in the configured summaries folder is assigned to `Project X`
+- **WHEN** the summary agent searches for a keyword
+- **THEN** Meeting Assistant returns matches from both `Project X` project files and matching past summary notes
+
+#### Scenario: Agent search rejects out-of-scope project
+- **GIVEN** the current meeting note is assigned to `Project X`
+- **WHEN** the summary agent searches with project scope `Project Z`
+- **THEN** Meeting Assistant refuses the request because `Project Z` is not assigned to the current meeting
+
+### Requirement: Agents can write files in existing projects
+Meeting Assistant SHALL expose a `write_projectfile` tool that can create or update files inside an existing project folder.
+
+The target project SHALL be an existing direct subfolder of the configured projects folder and SHALL be associated with the current meeting. The target file path SHALL stay inside that project folder. Newly approved associations SHALL take effect immediately for all project tools.
+
+When no line edit arguments are supplied and `replace_file` is not true, `write_projectfile` SHALL append the supplied content to the file and SHALL create the file when it does not exist.
+
+When `replace_file` is true, `write_projectfile` SHALL replace the whole file with the supplied content.
+
+When both `from` and `to` are supplied, `write_projectfile` SHALL replace the inclusive 1-based line range with the supplied content.
+
+When `insert` is supplied, `write_projectfile` SHALL insert the supplied content at that 1-based line position.
+
+Meeting Assistant SHALL refuse ambiguous writes that combine `replace_file` with line edit arguments.
+
+#### Scenario: Project file is appended or created
+- **WHEN** the agent writes a project file without line edit arguments
+- **THEN** Meeting Assistant appends the supplied content to an existing file
+- **AND** creates the file with the supplied content when it does not exist
+
+#### Scenario: Project file is explicitly replaced
+- **WHEN** the agent writes a project file with `replace_file` set to true
+- **THEN** Meeting Assistant writes the supplied content as the complete file content
+
+#### Scenario: Project file line range is replaced
+- **WHEN** the agent writes a project file with `from` and `to` line numbers
+- **THEN** Meeting Assistant replaces the inclusive line range with the supplied content
+
+#### Scenario: Project file content is inserted
+- **WHEN** the agent writes a project file with an `insert` line number
+- **THEN** Meeting Assistant inserts the supplied content at that line position
+
+#### Scenario: Project file write target is invalid
+- **WHEN** the target project is missing, is not associated with the meeting, or the target path escapes the project folder
+- **THEN** Meeting Assistant refuses the project file write
+
+#### Scenario: Project file write mode is ambiguous
+- **WHEN** the agent combines `replace_file` with `from`, `to`, or `insert`
+- **THEN** Meeting Assistant refuses the project file write

openspec/changes/add-summary-agent-requests/specs/meeting-summary/spec.md

@@ -0,0 +1,23 @@
+## MODIFIED Requirements
+
+### Requirement: Summary agent receives bound project instructions
+Meeting Assistant SHALL append a project section for projects bound to the meeting note frontmatter. Each entry SHALL identify the project ID and include its display name and description from PROJECT.md when available. For each bound project with a root AGENTS.md, the entry SHALL also include that file's content. Metadata SHALL appear even when AGENTS.md is absent. Unassociated project instructions SHALL NOT be appended.
+
+#### Scenario: Project AGENTS files are appended
+- **GIVEN** the meeting note frontmatter lists projects Alpha and Beta with root AGENTS.md files
+- **WHEN** the summary agent is created
+- **THEN** its project section includes both project IDs and their instructions
+
+#### Scenario: Project metadata without instructions is appended
+- **GIVEN** a bound project has PROJECT.md metadata but no AGENTS.md
+- **WHEN** the summary agent is created
+- **THEN** its entry contains ID, display name and description
+
+## ADDED Requirements
+
+### Requirement: Summarizer maintains project metadata and proposes missing associations
+Both default and custom summary-agent instructions SHALL explain the full metadata catalog, the distinction between catalog visibility and project access, and the approval process. They SHALL instruct the agent to propose plausible missing associations with concise evidence before finalizing the summary and to maintain associated PROJECT.md name and description (maximum 256 characters). They SHALL explain that workflow improvements require a short intention and a detailed request and are executed only by the settings agent after user approval.
+
+#### Scenario: Custom base prompt still receives capability guidance
+- **WHEN** a custom summary base prompt is configured
+- **THEN** the resulting instructions still explain metadata maintenance, association approvals and workflow-change requests

openspec/changes/add-summary-agent-requests/specs/project-knowledge/spec.md

@@ -0,0 +1,18 @@
+## ADDED Requirements
+
+### Requirement: Projects have compact discovery metadata
+Each project SHALL use a root `PROJECT.md` with YAML frontmatter `name` and `description` for agent-maintained discovery metadata. `name` SHALL be the display name; the project ID SHALL remain its direct subfolder name. The summarizer SHALL be instructed to create and maintain this metadata for associated projects from grounded project knowledge, preserving other frontmatter and body content. The description SHALL contain at most 256 characters.
+
+Catalog lookup SHALL tolerate missing or malformed metadata by falling back to the ID as display name and an empty description. Metadata lookup SHALL NOT grant access to project files or instructions.
+
+#### Scenario: Project has metadata
+- **WHEN** a project has valid name and description frontmatter
+- **THEN** catalog lookup exposes its ID, display name, and description
+
+#### Scenario: Legacy project has no metadata
+- **WHEN** a project has no PROJECT.md or no usable frontmatter
+- **THEN** it remains discoverable with its ID as display name and an empty description
+
+#### Scenario: Agent writes invalid metadata
+- **WHEN** the summarizer attempts a PROJECT.md update without valid name/description or with a description longer than 256 characters
+- **THEN** the write is refused without changing the existing file

openspec/changes/add-summary-agent-requests/specs/summary-agent-requests/spec.md

@@ -0,0 +1,56 @@
+## ADDED Requirements
+
+### Requirement: Summarizer can request project association
+The summarizer SHALL expose `request_project_association` accepting an existing project ID and a nonempty single-line reason of at most 100 characters. Invalid requests SHALL be refused without a notification or file changes.
+
+The tool SHALL show a native notification identifying the meeting and project, explaining the association request and reason, with Yes/No actions. Tool completion and further summarizer work SHALL wait for the decision for up to ten minutes. No, expiration, notification unavailability, or canceled summarization SHALL NOT add the project. Expiration SHALL remove the notification, invalidate late activation, and return denial.
+
+Once a stopped run has reached summarization, the recording stop-processing deadline SHALL return control while summary processing continues in the background. It SHALL NOT cancel a summary awaiting approval or queue an already-transcribed recording for offline replay.
+
+On Yes, the tool SHALL append the canonical project ID to the latest meeting-note projects frontmatter without duplicates, preserving other fields and body. Project tools SHALL immediately honor the updated scope, and the result SHALL report approval with project metadata and the root AGENTS.md content when present. No unapproved AGENTS.md content SHALL be returned. Already associated projects SHALL return their current context without prompting.
+
+#### Scenario: Approval extends scope during the same summary
+- **GIVEN** a catalog project is not associated with the meeting
+- **WHEN** the summarizer requests association and the user chooses Yes
+- **THEN** the meeting note gains that project and the same agent can read/write it
+- **AND** the result includes its AGENTS.md if present
+
+#### Scenario: Denial or timeout preserves scope
+- **WHEN** the user chooses No or ten minutes elapse
+- **THEN** the waiting tool reports denial, the notification disappears, and scope and meeting note remain unchanged
+
+#### Scenario: User edits note during approval
+- **WHEN** the user changes other meeting frontmatter or notes while an association request waits
+- **AND** then approves the project
+- **THEN** the project is added without losing those edits
+
+#### Scenario: Invalid or stale request cannot grant access
+- **WHEN** the ID is unknown, reason exceeds 100 characters, the target disappears, or summarization is canceled
+- **THEN** the request cannot expand project access
+
+#### Scenario: Stop wait expires while summary approval is pending
+- **GIVEN** transcription has completed and summarization is waiting for a user decision
+- **WHEN** the recording stop-processing timeout expires
+- **THEN** stopping returns with summarization still active
+- **AND** the summary continues with its own approval deadline without an offline transcription backlog item
+
+### Requirement: Summarizer can request workflow changes without editing workflows
+The summarizer SHALL expose `request_workflow_change` accepting a nonempty single-line intention of at most 100 characters and a nonempty detailed change prompt, preferably a scenario or specification. The tool SHALL return requested without waiting for approval, and the summarizer SHALL continue normally without direct workflow-editing capabilities.
+
+A native notification SHALL show `Workflow change requested: ...` with the intention and Yes/No actions. The detailed prompt SHALL be retained by the application independently of summary completion. No or ten-minute expiration SHALL discard the request without opening the editor or changing workflows. Late activation SHALL have no effect.
+
+Yes SHALL open a new settings-agent conversation and immediately submit the full detailed prompt once. An existing open conversation or draft SHALL remain intact. Application shutdown SHALL cancel and remove pending notifications.
+
+#### Scenario: Workflow request does not block the summary
+- **WHEN** the agent requests a workflow change
+- **THEN** the tool returns requested while approval remains pending
+- **AND** the summary can complete without opening the settings agent
+
+#### Scenario: Approved workflow request starts settings agent
+- **GIVEN** the summary run has completed and its workflow request is pending
+- **WHEN** the user chooses Yes
+- **THEN** the settings-agent window opens and starts the detailed prompt exactly once
+
+#### Scenario: Denied or expired workflow request does nothing
+- **WHEN** the user declines or ignores a workflow request for ten minutes
+- **THEN** its notification disappears and no editor or workflow change is started

openspec/changes/add-summary-agent-requests/tasks.md

@@ -0,0 +1,35 @@
+## 1. Project catalog and metadata
+
+- [x] 1.1 Test and implement full metadata catalog with legacy/malformed fallback and scoped file access.
+- [x] 1.2 Test PROJECT.md metadata writes and enforce the description limit without damaging existing files.
+- [x] 1.3 Include bound metadata beside AGENTS.md and instruct default/custom agents to maintain it and request missing associations.
+
+## 2. Project approval
+
+- [x] 2.1 Test blocking approval, immediate scope update, returned AGENTS.md and preservation of concurrent user note edits.
+- [x] 2.2 Handle invalid IDs/reasons, existing associations, denial, timeout, cancellation and stale actions.
+- [x] 2.3 Register the tool and native Yes/No notification with ten-minute validity and sequential summary tool execution.
+- [x] 2.4 Keep summarization alive after the recording stop wait expires so approval does not trigger transcription cancellation or offline replay.
+
+## 3. Workflow-change requests
+
+- [x] 3.1 Test and implement nonblocking application-owned workflow requests that survive summary completion.
+- [x] 3.2 Open a separate settings-agent conversation and automatically submit approved detail; preserve existing drafts and runs.
+- [x] 3.3 Cover rejection, expiration, shutdown, invalid requests and exactly-once acceptance.
+
+## 4. Verification
+
+- [x] 4.1 Update workflow and configuration documentation.
+- [x] 4.2 Review changed code and surrounding integration; fix actionable findings.
+- [x] 4.3 Run relevant tests, full solution tests, Windows build and strict OpenSpec validation.
+- [x] 4.4 Verify through the safest direct operational surface and document native UI/live-provider limits.
+
+Verification (2026-09-25): all 552 solution tests pass, including 20 focused project/catalog/request tests. The solution builds the Windows target successfully with the four existing NAudio obsolete-API warnings. Strict validation passes for this change and the existing microphone change; `git diff --check` is clean.
+
+Two independent review passes covered project metadata/access and notification/queue/UI lifecycle, including surrounding recording-stop integration. Incomplete metadata now consistently falls back to the project ID, and traversal coverage uses an associated project so it actually exercises path containment. Project association writes prepare a same-directory temporary file before replacing the meeting note; successful requests leave no temporary file behind.
+
+Public-tool behavior tests inspect real generated meeting and project files with controlled approval/window services. They verify latest-note preservation, immediate scope changes, returned instructions, rejection/expiry/cancellation, nonblocking workflow requests, and automatic submission of approved detail to a fresh settings-agent conversation. A coordinator regression test verifies that the stop wait cannot cancel a summary awaiting approval or enqueue unnecessary offline replay.
+
+The running application's recording-status endpoint was checked read-only and reported idle. The service was not updated or restarted. Native toast activation/removal, actual WPF window isolation, and a live model invoking these tools were not exercised, because those require running the new Windows build and interacting with its notifications. Sequential tool execution is configured and compiled; the model pipeline itself was not exercised with simultaneous tool calls. These operational checks remain required before acceptance or archival.
+
+Authorized local start (2026-09-25): after confirming idle status and logs, the documented restart helper published and started the Release build in `tmp/meeting-assistant-runtime/run-20260925-115711`. `/health` reports `ok`, `/recording/status` reports idle, the tray icon was created, and Resemblyzer warm-up completed without stderr errors. The published application DLL matches the Release output by SHA-256. This verifies startup of the new build; native approval interactions and live-model tool invocation remain unverified.

openspec/changes/add-transcription-pause-controls/design.md

@@ -46,6 +46,8 @@ The inactivity safeguard will skip transcript-inactivity prompting and its ordin
 
 The coordinator will call dismissal only after a non-empty live segment has been durably appended, matching the user's observable meaning of a new transcription being written. Notification callbacks will verify that their originating run is still current before changing recording state.
 
+Transcript processing requests notification dismissal without awaiting it. Profile switching holds the coordinator gate while draining the old transcript reader, so awaiting dismissal from that reader would create a circular wait on the same gate. Deferred cleanup retains the gate and current-run check, uses the capture cancellation token, and handles cancellation when capture stops. Durable transcript activity still invalidates stale notification actions immediately, before deferred cleanup runs.
+
 ### Model pause as one toggling tray action
 
 The active-recording tray menu will show `Pause transcription` while running and `Unpause transcription` while paused. It will stay in the fine-grained controls section below the dedicated `Finish meeting` section. The inactivity toast will add `Pause transcription` alongside the existing Yes/No stop controls.

openspec/changes/add-transcription-pause-controls/specs/meeting-recording/spec.md

@@ -121,6 +121,8 @@ If the user selects pause from the stop prompt, Meeting Assistant SHALL pause tr
 
 When a new non-empty live transcript segment is written, Meeting Assistant SHALL dismiss all outstanding transcript-inactivity notifications and invalidate their pending actions.
 
+Notification dismissal SHALL NOT block processing the final transcript segments emitted while switching launch profiles. Any deferred dismissal SHALL recheck that its originating run is still the active recording before dismissing notifications.
+
 While transcription is intentionally paused, Meeting Assistant SHALL NOT show transcript-inactivity prompts and SHALL NOT apply the ordinary transcript-inactivity auto-stop threshold.
 
 Meeting Assistant SHALL normally stop a meeting that remains continuously paused for the configured maximum pause duration, defaulting to 4 hours, without first showing a transcript-inactivity notification. This maximum continuous-pause cutoff SHALL remain active when ordinary transcript-inactivity prompting and auto-stop are disabled.
@@ -205,6 +207,15 @@ When a recording stops normally and its meeting note, transcript, and assistant
 - **WHEN** the older meeting writes a late transcript segment
 - **THEN** the newer meeting's notification and pending actions remain active
 
+#### Scenario: Final transcript during a profile switch dismisses notifications without blocking the switch
+- **GIVEN** a meeting is actively recording with either the `default` or `english` profile
+- **WHEN** the user switches to the other profile
+- **AND** the old recognizer emits a final non-empty transcript segment while draining
+- **THEN** Meeting Assistant writes that final segment before the profile-switch marker
+- **AND** completes the switch and transcribes buffered audio in the same meeting
+- **AND** dismisses the originating active run's outstanding inactivity notifications
+- **AND** subsequent profile switches and normal meeting completion remain available
+
 #### Scenario: Empty stopped recording is cleaned up
 - **GIVEN** a recording is active
 - **AND** the meeting note, transcript, and assistant context only contain generated default content

openspec/changes/add-transcription-pause-controls/tasks.md

@@ -36,3 +36,14 @@
 - [x] 6.2 Scope notification dismissal to the active run and move activity invalidation after durable transcript append, with overlapping-run and blocked-write regression tests.
 - [x] 6.3 Make pause-notification activity validation atomic and make tray pause/unpause actions intent-specific, with race and stale-menu tests.
 - [x] 6.4 Complete an independent simplification review and rerun all required validation before commit.
+
+## 7. Profile-switch deadlock repair
+
+- [x] 7.1 Reproduce final transcript delivery during profile switching in both directions through the coordinator's public interface.
+- [x] 7.2 Decouple notification dismissal from transcript draining while preserving current-run checks and cancellation handling.
+- [x] 7.3 Verify buffered transcription, subsequent controls, notification lifecycle tests, the full suite, Windows build, and strict OpenSpec validation.
+- [x] 7.4 Deploy with explicit restart authorization, verify the live health/control endpoints, and record the operational verification limits.
+
+Verification on 2026-09-16: both profile-switch regression cases failed with the original circular wait and passed after the repair. All 520 solution tests passed on the final run. An unchanged audio-mixing timing test failed during the first full run, then passed alone and in the final full run. Strict OpenSpec validation and the Windows Release publish passed. The executable is staged at `tmp/meeting-assistant-runtime/run-20260916-142827-profile-switch-fix`.
+
+Operational verification on 2026-09-16: after explicit user authorization, the deadlocked process was killed and the staged Windows release started as PID 48716. `/health` returned `ok`, `/recording/status` returned idle, and the process path confirmed the fixed release. The old meeting's summary was requested through `/meetings/summary/retry`. Profile-switch behavior was verified through the public coordinator regression tests rather than recording a new live meeting. The existing 25,092,144-byte WAV and meeting artifacts were backed up under `tmp/profile-switch-recovery-20260916`; audio held only in the killed process after the switch was not recovered. The meeting context records that transcription gap.

openspec/changes/archive/2026-06-26-azure-speech-offline-resilience/design.md

@@ -24,4 +24,8 @@ After configured reconnect attempts are exhausted, Azure should emit a longer di
 
 If a stopped Azure Speech meeting cannot finish draining before `Recording:StopProcessingTimeout`, the coordinator queues the completed temporary WAV and artifact paths in a persisted offline backlog, releases the active recording slot, and keeps the WAV from startup cleanup. This lets the user start more meetings while Azure or the network is still unavailable.
 
-The backlog processor retries queued items in the background. Each item creates a fresh speech recognition pipeline for the original launch profile, streams the queued WAV into that pipeline, rewrites the original transcript file with the finished lines, updates meeting-note and transcript metadata, runs transcript-line workflow transformations, transitions the assistant context through summarizing to finished/error, runs the normal summary pipeline, then removes the backlog item and deletes the temporary WAV. Failed processing leaves the backlog item and WAV in place for a later retry.
+The backlog processor retries queued items in the background. Each item creates a fresh speech recognition pipeline for the original launch profile and streams the queued WAV into that pipeline. Results without non-blank speech text leave all artifacts and recovery files unchanged for a later retry.
+
+A usable replay preserves the existing transcript body and appends a visible recovery section before updating meeting metadata and running the normal summary pipeline. The recovery marker explains that the full recording was replayed, earlier passages may be duplicated, and repeated content should be treated as the same discussion when summarizing. Recovered lines still receive transcript-line workflow transformations; the explanatory marker is written directly so it remains visible. The application does not try to deduplicate or reconcile live and recovered recognition results.
+
+After appending, the processor updates meeting-note and transcript metadata, transitions the assistant context through summarizing to finished/error, and runs the normal summary pipeline. Completed processing removes the backlog item and temporary WAV. Failed processing leaves both in place for a later retry; an additional replay may append another clearly marked recovery section without discarding earlier content.

openspec/changes/archive/2026-06-26-azure-speech-offline-resilience/specs/meeting-transcription/spec.md

@@ -27,7 +27,11 @@ When Azure Speech is still unavailable after recording stops and transcription c
 
 When a stopped meeting is persisted to the durable transcription backlog, Meeting Assistant SHALL release the active recording slot so another meeting can be recorded while the stopped meeting waits for Azure Speech to become available.
 
-When Azure Speech becomes available again, Meeting Assistant SHALL retry durable backlog items, rewrite the transcript from the recorded WAV, run the normal post-transcription meeting completion and summary flow, and remove the backlog item after successful completion.
+When Azure Speech becomes available again, Meeting Assistant SHALL retry durable backlog items, append the recovered transcript from the recorded WAV without replacing the existing transcript body, run the normal post-transcription meeting completion and summary flow, and remove the backlog item after successful completion.
+
+Before appending recovered lines, Meeting Assistant SHALL insert a visible recovery marker explaining that the following section was recovered by replaying the entire recording and may duplicate earlier transcript passages. The marker SHALL tell the summarizer to treat repeated passages as the same discussion. The marker and appended lines SHALL be available to the summary agent together with the preserved earlier transcript. Existing transcript text, speaker labels, and user edits SHALL remain unchanged.
+
+An offline replay that returns no speech segments with non-blank text SHALL be treated as an unsuccessful attempt. This includes empty results, blank speech segments, and results containing only status markers. Meeting Assistant SHALL preserve the existing transcript and meeting artifacts unchanged, SHALL skip meeting completion and summarization, and SHALL retain the durable backlog item and its WAV for a later retry.
 
 When Meeting Assistant starts, it SHALL preserve WAV files that are referenced by durable transcription backlog items instead of deleting them as stale temporary recordings.
 
@@ -73,6 +77,24 @@ When Meeting Assistant starts, it SHALL preserve WAV files that are referenced b
 #### Scenario: Durable Azure backlog resumes after connectivity returns
 - **GIVEN** a stopped Azure meeting exists in the durable transcription backlog
 - **WHEN** Azure Speech can transcribe the recorded WAV
-- **THEN** Meeting Assistant rewrites the transcript from the recorded WAV
+- **THEN** Meeting Assistant preserves the existing transcript body and appends a recovery marker followed by the transcript from the recorded WAV
+- **AND** the marker explains the recovery and possible duplicates to the summary agent
 - **AND** runs meeting completion and summarization
 - **AND** removes the durable backlog item and its temporary WAV after successful completion
+
+#### Scenario: Empty offline replay preserves the live transcript and recovery files
+- **GIVEN** a stopped Azure meeting has an existing live transcript and a durable backlog item referencing its WAV
+- **WHEN** the offline replay returns no transcript segments
+- **THEN** Meeting Assistant leaves the transcript and meeting artifacts unchanged
+- **AND** does not run meeting completion or summarization
+- **AND** retains the backlog item and WAV for the next retry
+- **WHEN** a later retry produces a transcript from the WAV
+- **THEN** Meeting Assistant appends the recovery marker and recovered transcript without replacing earlier content and completes the meeting normally
+- **AND** removes the backlog item and WAV only after that successful completion
+
+#### Scenario: Offline status markers or blank speech do not count as successful transcription
+- **GIVEN** a stopped Azure meeting has an existing live transcript and a durable backlog item referencing its WAV
+- **WHEN** the offline replay returns only status markers or speech segments with blank text
+- **THEN** Meeting Assistant preserves the existing transcript and meeting artifacts
+- **AND** skips meeting completion and summarization
+- **AND** retains the backlog item and WAV for another retry

openspec/changes/archive/2026-06-26-azure-speech-offline-resilience/tasks.md

@@ -9,3 +9,17 @@
 - [x] Run focused tests, full solution tests, and `openspec validate azure-speech-offline-resilience --strict`.
 - [x] Add a durable offline backlog for stopped Azure meetings across process restarts.
 - [x] Replay queued WAV files through a fresh speech pipeline and finish transcript metadata, meeting context state, summary generation, and backlog cleanup.
+
+## Bug-fix addendum: Preserve transcripts during offline replay
+
+- [x] Specify that replay without speech text preserves the transcript, backlog, and WAV until a successful retry.
+- [x] Reproduce the data-loss bug with real transcript and backlog files, then reject empty, blank-text, and marker-only replay results before any artifact writes.
+- [x] Verify retained files survive repeated retries and a later successful replay still completes and cleans up normally.
+- [x] Run focused regression tests, full solution tests, and strict OpenSpec validation.
+
+- [x] Preserve existing transcript content on successful replay and append a recovery marker explaining possible duplicates before the recovered text.
+- [x] Verify the summary agent receives earlier text, the recovery explanation, and appended text together, then rerun the relevant tests and strict validation.
+
+Verification: the regression cases exercise the backlog processor with real WAV, transcript, meeting-note, and durable JSON files. Each case checks byte-for-byte preservation through two unsuccessful attempts and reloads the backlog from disk. A later usable replay preserves the original body, including a user correction without a trailing newline, and appends the marker and recovered text. A transcript-reading summary stub verifies that both versions, including an intentional duplicate passage, are available with the explanation before backlog/WAV cleanup. All 525 solution tests and strict validation of this change and the accepted transcription spec pass; independent review found no actionable issues. The Azure response is deterministic test input; no live Azure outage was induced and the running workstation service was not restarted.
+
+Authorized local start (2026-09-25): the Release build containing this fix was subsequently published and started after confirming the workstation instance was idle. Health and startup logs are successful; the full solution now has 552 passing tests. No live Azure outage was induced.

openspec/changes/prompt-for-new-microphone/.openspec.yaml

@@ -0,0 +1,2 @@
+schema: spec-driven
+created: 2026-09-25

openspec/changes/prompt-for-new-microphone/design.md

@@ -0,0 +1,33 @@
+## Context
+
+MicrophoneAudioSource already retries failed capture sources without ending the composite microphone/system-audio stream. WindowsMicrophoneDeviceProvider enumerates active endpoints on demand. Native actionable Windows notifications already use CommunityToolkit.WinUI.Notifications.
+
+## Goals / Non-Goals
+
+**Goals:** Discover newly available microphones during active capture, ask before switching, and replace only the microphone capture lifetime when accepted. Preserve the recording, paused state, transcription session, and system audio.
+
+**Non-Goals:** Change tray selection semantics, automatically prefer newly connected hardware, introduce a new notification framework, or restart the service.
+
+## Decisions
+
+- Poll active endpoints once per second within each microphone capture session. This reuses existing enumeration and works independently of incoming audio chunks. An OS-specific device-event subscription would add another platform lifecycle without improving the current requirement materially.
+- Establish the initial endpoint IDs as the baseline and offer each newly seen ID at most once per meeting. Declining or ignoring a prompt does not interrupt audio and does not cause repeated prompts.
+- Keep discovery/prompt handling in a separate monitor with a narrow prompt-service boundary. The microphone source owns replacement of its current capture token; the shared runtime selection is updated only on a still-valid affirmative response.
+- Bind monitoring and prompt cancellation to the originating capture session. Cancel prompts when their device disappears or the session ends. Prompts expire after one minute and stale actions cannot alter another meeting.
+- Use the existing native toast toolkit and a neutral no-op prompt implementation. Display the device name with explicit Yes/No actions.
+- Recheck prompt cancellation after device lookup and at the selection update. Capture sources that own native resources are disposed even when a switch cancels their stream before enumeration starts.
+
+## Risks / Trade-offs
+
+- Device discovery can lag by one polling interval. Capture continues during discovery and while waiting for a response.
+- Hardware can disappear after acceptance. The existing capture-recovery loop handles creation or capture failures and keeps system audio running.
+- Switching has an unavoidable short microphone gap. Only microphone capture is canceled; the enclosing recording and transcription are retained.
+- Windows controls actual notification display duration. One-minute expiration controls action validity; it does not guarantee on-screen persistence.
+
+## Migration Plan
+
+No data migration or new configuration is needed. Verify through deterministic capture sources and a Windows build, with native UI/device verification only when it can avoid interrupting a real meeting.
+
+## Open Questions
+
+None.

openspec/changes/prompt-for-new-microphone/proposal.md

@@ -0,0 +1,24 @@
+## Why
+
+A microphone connected during a healthy recording is currently only discovered on later device enumeration or capture recovery. Users need an explicit choice to use a newly connected headset without ending the meeting.
+
+## What Changes
+
+- Watch active microphone endpoints while microphone capture is running, including paused transcription.
+- Offer a native Windows notification naming each newly available microphone with Yes/No actions.
+- Switch only the microphone capture source when accepted, preserving system audio, transcription, and meeting artifacts.
+- Ignore declined, expired, disconnected-device, and ended-meeting prompts.
+
+## Capabilities
+
+### New Capabilities
+
+None.
+
+### Modified Capabilities
+
+- `meeting-recording`: prompt for newly available microphones and safely switch the active microphone on acceptance.
+
+## Impact
+
+Microphone capture orchestration, Windows notifications, dependency registration, recording documentation, and deterministic capture/notification tests. Reuses the existing Windows notification toolkit; no new UI framework or configuration migration.

openspec/changes/prompt-for-new-microphone/specs/meeting-recording/spec.md

@@ -0,0 +1,41 @@
+## ADDED Requirements
+
+### Requirement: Newly available microphones can be selected during a meeting
+While microphone capture for a meeting is active, including while transcription is paused, Meeting Assistant SHALL monitor newly available microphone endpoints and show a native Windows notification naming each newly discovered microphone and offering affirmative and negative actions.
+
+Devices already available when capture starts SHALL NOT trigger a notification. Each device ID SHALL be offered at most once per meeting. Discovery and unanswered prompts SHALL NOT block audio capture.
+
+An affirmative response SHALL select the named microphone and replace only the active microphone capture source. The meeting, transcript session, artifacts, transcription pause state, and system-audio capture SHALL remain active. The selection SHALL also be used by later recording starts until another runtime selection or application exit.
+
+A negative response or expiration SHALL leave microphone selection and capture unchanged. Prompts SHALL expire after one minute and SHALL become invalid when the originating capture ends or the target device disappears. A stale response SHALL NOT change a later meeting's microphone selection.
+
+#### Scenario: Newly connected microphone is offered
+- **GIVEN** a meeting is recording from an existing microphone
+- **WHEN** another microphone becomes available
+- **THEN** a notification names that microphone and offers Yes and No
+- **AND** audio continues while the notification is unanswered
+- **AND** repeated observations of the same device do not produce more notifications
+
+#### Scenario: User accepts the new microphone
+- **GIVEN** the notification refers to a still-available microphone in the active meeting
+- **WHEN** the user chooses Yes
+- **THEN** subsequent microphone audio comes from that microphone
+- **AND** the existing meeting, system audio, and transcription session continue
+
+#### Scenario: User declines or ignores the new microphone
+- **WHEN** the user chooses No or the prompt expires
+- **THEN** capture and selection remain on the existing microphone
+
+#### Scenario: Device disappears or meeting ends before acceptance
+- **GIVEN** a new-microphone prompt is pending
+- **WHEN** its device disappears or its meeting capture ends
+- **THEN** the prompt is canceled and later activation cannot switch the microphone
+
+#### Scenario: Existing devices do not prompt on start
+- **WHEN** a meeting starts with multiple available microphones
+- **THEN** the initial device list becomes the discovery baseline without showing notifications
+
+#### Scenario: Paused transcription still offers a new microphone
+- **GIVEN** a meeting's transcription is paused while audio capture remains active
+- **WHEN** a microphone becomes available and the user accepts its notification
+- **THEN** the microphone source changes while transcription remains paused

openspec/changes/prompt-for-new-microphone/tasks.md

@@ -0,0 +1,22 @@
+## 1. Discovery and prompt lifetime
+
+- [x] 1.1 Add behavior tests and a monitor that offers newly available endpoints once per capture session without blocking capture.
+- [x] 1.2 Test and handle rejection, expiration, disappearance, and ended-session responses safely.
+
+## 2. Capture switching and native UI
+
+- [x] 2.1 Test and implement accepted microphone switches within the existing capture stream, retaining disconnect recovery.
+- [x] 2.2 Add native Windows Yes/No notifications and register the monitor and prompt service.
+- [x] 2.3 Cover cancellation during confirmation lookup and switching or ending the meeting during capture creation; reject stale confirmation and dispose abandoned capture resources.
+
+## 3. Verification and documentation
+
+- [x] 3.1 Document discovery, prompt validity, and active switching.
+- [x] 3.2 Review the implementation, run focused and full solution tests, build Windows, and validate this change strictly.
+- [x] 3.3 Verify through the safest available operational surface and record any native hardware/UI verification limits.
+
+Verification: all 11 focused microphone tests and all 534 solution tests pass. The solution build includes the Windows target and succeeds with the four existing NAudio obsolete-API warnings. Strict OpenSpec validation passes. Independent review identified confirmation-cancellation and capture-ownership races; regression tests reproduced them before the fixes, and the follow-up review confirmed both are resolved.
+
+The capture behavior tests exercise the public audio stream and shared selection with controlled devices and prompts: acceptance replaces samples in the same stream, while decline, expiry, removal, and ended sessions prevent a switch. The running application's recording-status endpoint was checked read-only and reported idle. A physical microphone connection and native toast activation were not tested: no controllable hardware hotplug was available in this session, and the running service was not updated or restarted. Native hardware/UI verification remains a follow-up before operational acceptance or archival.
+
+Authorized local start (2026-09-25): the current Release build was subsequently published and started using the documented restart helper after another idle check. Health, idle status, tray creation, and model warm-up are successful. The complete solution now has 552 passing tests. Physical microphone hotplug and toast activation remain unverified.

openspec/specs/meeting-session/spec.md

@@ -285,6 +285,8 @@ The rules and identities editor agent SHALL receive speaker identity tools to se
 
 The rules and identities editor agent SHALL receive speaker sample tools to list, read, delete, and queue playback of samples linked to identities. The delete sample tool SHALL refuse to delete the last remaining sample for an identity.
 
+Speaker sample playback SHALL use the Windows audio implementation only in the Windows-targeted build. The neutral build SHALL return an actionable unavailable response instead of reporting a sample as queued for playback.
+
 The first model request caused by each user-submitted chat turn SHALL send the `X-Initiator: user` header, while follow-up model requests within that same turn, such as tool-call continuations, SHALL send `X-Initiator: agent`.
 
 Meeting Assistant SHALL provide a diagnostic endpoint that opens the workflow rules editor through the same window service used by the tray menu.
@@ -337,6 +339,12 @@ Meeting Assistant SHALL provide a diagnostic endpoint that opens the workflow ru
 - **AND** it can list, read, delete, and queue playback of identity samples
 - **AND** deleting the last sample for an identity is refused
 
+#### Scenario: Neutral build refuses speaker playback
+- **GIVEN** Meeting Assistant runs from its neutral target build
+- **WHEN** an agent requests playback of a speaker sample
+- **THEN** the application reports that playback requires the Windows build
+- **AND** does not report that the sample was queued
+
 #### Scenario: User sends a rules-editing chat turn
 - **GIVEN** the rules editor chat window is open
 - **WHEN** the user types a prompt and presses Enter

openspec/specs/meeting-transcription/spec.md

@@ -139,7 +139,11 @@ When Azure Speech is still unavailable after recording stops and transcription c
 
 When a stopped meeting is persisted to the durable transcription backlog, Meeting Assistant SHALL release the active recording slot so another meeting can be recorded while the stopped meeting waits for Azure Speech to become available.
 
-When Azure Speech becomes available again, Meeting Assistant SHALL retry durable backlog items, rewrite the transcript from the recorded WAV, run the normal post-transcription meeting completion and summary flow, and remove the backlog item after successful completion.
+When Azure Speech becomes available again, Meeting Assistant SHALL retry durable backlog items, append the recovered transcript from the recorded WAV without replacing the existing transcript body, run the normal post-transcription meeting completion and summary flow, and remove the backlog item after successful completion.
+
+Before appending recovered lines, Meeting Assistant SHALL insert a visible recovery marker explaining that the following section was recovered by replaying the entire recording and may duplicate earlier transcript passages. The marker SHALL tell the summarizer to treat repeated passages as the same discussion. The marker and appended lines SHALL be available to the summary agent together with the preserved earlier transcript. Existing transcript text, speaker labels, and user edits SHALL remain unchanged.
+
+An offline replay that returns no speech segments with non-blank text SHALL be treated as an unsuccessful attempt. This includes empty results, blank speech segments, and results containing only status markers. Meeting Assistant SHALL preserve the existing transcript and meeting artifacts unchanged, SHALL skip meeting completion and summarization, and SHALL retain the durable backlog item and its WAV for a later retry.
 
 When Meeting Assistant starts, it SHALL preserve WAV files that are referenced by durable transcription backlog items instead of deleting them as stale temporary recordings.
 
@@ -185,10 +189,28 @@ When Meeting Assistant starts, it SHALL preserve WAV files that are referenced b
 #### Scenario: Durable Azure backlog resumes after connectivity returns
 - **GIVEN** a stopped Azure meeting exists in the durable transcription backlog
 - **WHEN** Azure Speech can transcribe the recorded WAV
-- **THEN** Meeting Assistant rewrites the transcript from the recorded WAV
+- **THEN** Meeting Assistant preserves the existing transcript body and appends a recovery marker followed by the transcript from the recorded WAV
+- **AND** the marker explains the recovery and possible duplicates to the summary agent
 - **AND** runs meeting completion and summarization
 - **AND** removes the durable backlog item and its temporary WAV after successful completion
 
+#### Scenario: Empty offline replay preserves the live transcript and recovery files
+- **GIVEN** a stopped Azure meeting has an existing live transcript and a durable backlog item referencing its WAV
+- **WHEN** the offline replay returns no transcript segments
+- **THEN** Meeting Assistant leaves the transcript and meeting artifacts unchanged
+- **AND** does not run meeting completion or summarization
+- **AND** retains the backlog item and WAV for the next retry
+- **WHEN** a later retry produces a transcript from the WAV
+- **THEN** Meeting Assistant appends the recovery marker and recovered transcript without replacing earlier content and completes the meeting normally
+- **AND** removes the backlog item and WAV only after that successful completion
+
+#### Scenario: Offline status markers or blank speech do not count as successful transcription
+- **GIVEN** a stopped Azure meeting has an existing live transcript and a durable backlog item referencing its WAV
+- **WHEN** the offline replay returns only status markers or speech segments with blank text
+- **THEN** Meeting Assistant preserves the existing transcript and meeting artifacts
+- **AND** skips meeting completion and summarization
+- **AND** retains the backlog item and WAV for another retry
+
 ### Requirement: FunASR can provide speaker-attributed streaming transcription
 Meeting Assistant SHALL provide a FunASR speech recognition pipeline that streams PCM audio to a configured FunASR WebSocket endpoint.