Archive completed meeting assistant changes

MeetingAssistant.Tests/CalendarRecordingPromptSchedulerTests.cs

@@ -1,4 +1,5 @@
 using MeetingAssistant.Calendar;
+using MeetingAssistant.MeetingNotes;
 using MeetingAssistant.Recording;
 using Microsoft.Extensions.Logging.Abstractions;
 using Microsoft.Extensions.Options;
@@ -22,6 +23,94 @@ public sealed class CalendarRecordingPromptSchedulerTests
         Assert.Equal(0, harness.Recorder.StopCount);
     }
 
+    [Fact]
+    public async Task AcceptedPromptStartsRecordingWithPromptedMeetingMetadata()
+    {
+        var harness = CreateHarness(isRecording: false);
+        var selectedMetadata = new MeetingMetadata(
+            "Selected planning",
+            ["Ada"],
+            "Selected agenda",
+            DateTimeOffset.Parse("2026-06-03T10:30:00+00:00"));
+        var otherMetadata = new MeetingMetadata(
+            "Other planning",
+            ["Grace"],
+            "Other agenda",
+            DateTimeOffset.Parse("2026-06-03T10:40:00+00:00"));
+        var selectedMeeting = CreateMeeting(
+            harness.Clock,
+            id: "teams-selected",
+            subject: "Selected planning",
+            metadata: selectedMetadata);
+        var otherMeeting = CreateMeeting(
+            harness.Clock,
+            id: "teams-other",
+            subject: "Other planning",
+            startOffset: TimeSpan.FromMinutes(40),
+            metadata: otherMetadata);
+        harness.Provider.Meetings = [selectedMeeting, otherMeeting];
+
+        await SyncThenPromptAsync(harness, selectedMeeting);
+
+        Assert.Equal(1, harness.Recorder.StartCount);
+        Assert.Same(selectedMetadata, harness.Recorder.StartMetadata.Single());
+        Assert.Equal(1, harness.Recorder.PromptStartCount);
+    }
+
+    [Fact]
+    public async Task AcceptedPromptWithoutMetadataStillUsesPromptStartPath()
+    {
+        var harness = CreateHarness(isRecording: false);
+        var meeting = CreateMeeting(
+            harness.Clock,
+            id: "teams-without-metadata",
+            subject: "No metadata",
+            metadata: null);
+        harness.Provider.Meetings = [meeting];
+
+        await SyncThenPromptAsync(harness, meeting);
+
+        Assert.Equal(1, harness.Recorder.StartCount);
+        Assert.Null(harness.Recorder.StartMetadata.Single());
+        Assert.Equal(1, harness.Recorder.PromptStartCount);
+    }
+
+    [Fact]
+    public async Task AcceptingDisplayedPromptsOutOfOrderUsesAcceptedPromptMetadata()
+    {
+        var harness = CreateHarness(isRecording: false, autoAcceptPrompts: false);
+        var firstMetadata = new MeetingMetadata(
+            "First planning",
+            ["Ada"],
+            "First agenda",
+            DateTimeOffset.Parse("2026-06-03T10:30:00+00:00"));
+        var secondMetadata = new MeetingMetadata(
+            "Second planning",
+            ["Grace"],
+            "Second agenda",
+            DateTimeOffset.Parse("2026-06-03T10:30:00+00:00"));
+        var firstMeeting = CreateMeeting(
+            harness.Clock,
+            id: "teams-first",
+            subject: "First planning",
+            metadata: firstMetadata);
+        var secondMeeting = CreateMeeting(
+            harness.Clock,
+            id: "teams-second",
+            subject: "Second planning",
+            metadata: secondMetadata);
+        harness.Provider.Meetings = [firstMeeting, secondMeeting];
+
+        await harness.Scheduler.SyncOnceAsync(CancellationToken.None);
+        harness.Clock.Now = firstMeeting.Start;
+        await harness.Scheduler.CheckDuePromptsAsync(CancellationToken.None);
+        await harness.PromptService.RespondAsync(secondMeeting, MeetingStartPromptResponse.Record);
+
+        Assert.Equal([firstMeeting, secondMeeting], harness.PromptService.PromptedMeetings);
+        Assert.Equal(1, harness.Recorder.StartCount);
+        Assert.Same(secondMetadata, harness.Recorder.StartMetadata.Single());
+    }
+
     [Fact]
     public async Task AcceptedPromptStopsActiveRecordingBeforeStartingNewRecording()
     {
@@ -34,6 +123,25 @@ public sealed class CalendarRecordingPromptSchedulerTests
         Assert.Equal(["stop", "start"], harness.Recorder.Commands);
     }
 
+    [Fact]
+    public async Task CanceledCachedMeetingDoesNotPromptRecording()
+    {
+        var harness = CreateHarness(isRecording: false);
+        var canceledMeeting = CreateMeeting(
+            harness.Clock,
+            id: "teams-canceled",
+            subject: "Canceled project sync",
+            isCanceled: true);
+        harness.Provider.Meetings = [canceledMeeting];
+
+        await harness.Scheduler.SyncOnceAsync(CancellationToken.None);
+        harness.Clock.Now = canceledMeeting.Start;
+        await harness.Scheduler.CheckDuePromptsAsync(CancellationToken.None);
+
+        Assert.Empty(harness.PromptService.PromptedMeetings);
+        Assert.Equal(0, harness.Recorder.StartCount);
+    }
+
     [Fact]
     public async Task DisabledCalendarPromptsDoNotQueryCalendar()
     {
@@ -115,23 +223,28 @@ public sealed class CalendarRecordingPromptSchedulerTests
         string id = "teams-1",
         string subject = "Project sync",
         TimeSpan? startOffset = null,
-        TimeSpan? duration = null)
+        TimeSpan? duration = null,
+        MeetingMetadata? metadata = null,
+        bool isCanceled = false)
     {
         var start = clock.Now.Add(startOffset ?? TimeSpan.FromMinutes(30));
         return new CalendarMeeting(
             id,
             subject,
             start,
-            start.Add(duration ?? TimeSpan.FromMinutes(30)));
+            start.Add(duration ?? TimeSpan.FromMinutes(30)),
+            metadata,
+            isCanceled);
     }
 
     private static SchedulerHarness CreateHarness(
         bool isRecording = false,
-        bool enabled = true)
+        bool enabled = true,
+        bool autoAcceptPrompts = true)
     {
         var clock = new ManualCalendarPromptClock(new DateTimeOffset(2026, 6, 3, 9, 30, 0, TimeSpan.Zero));
         var provider = new RecordingCalendarMeetingProvider([]);
-        var promptService = new AcceptingMeetingStartPromptService();
+        var promptService = new CapturingMeetingStartPromptService(autoAcceptPrompts);
         var recorder = new RecordingPromptRecorder(isRecording);
         var scheduler = new CalendarRecordingPromptScheduler(
             Options.Create(new MeetingAssistantOptions
@@ -155,7 +268,7 @@ public sealed class CalendarRecordingPromptSchedulerTests
     private sealed record SchedulerHarness(
         CalendarRecordingPromptScheduler Scheduler,
         RecordingCalendarMeetingProvider Provider,
-        AcceptingMeetingStartPromptService PromptService,
+        CapturingMeetingStartPromptService PromptService,
         RecordingPromptRecorder Recorder,
         ManualCalendarPromptClock Clock);
 
@@ -179,8 +292,16 @@ public sealed class CalendarRecordingPromptSchedulerTests
         }
     }
 
-    private sealed class AcceptingMeetingStartPromptService : IMeetingStartPromptService
+    private sealed class CapturingMeetingStartPromptService : IMeetingStartPromptService
     {
+        private readonly bool autoAccept;
+        private readonly List<PendingPrompt> pendingPrompts = [];
+
+        public CapturingMeetingStartPromptService(bool autoAccept)
+        {
+            this.autoAccept = autoAccept;
+        }
+
         public List<CalendarMeeting> PromptedMeetings { get; } = [];
 
         public async Task ShowPromptAsync(
@@ -189,8 +310,24 @@ public sealed class CalendarRecordingPromptSchedulerTests
             CancellationToken cancellationToken)
         {
             PromptedMeetings.Add(request.Meeting);
-            await handleResponseAsync(MeetingStartPromptResponse.Record, cancellationToken);
+            pendingPrompts.Add(new PendingPrompt(request.Meeting, handleResponseAsync));
+            if (autoAccept)
+            {
+                await handleResponseAsync(MeetingStartPromptResponse.Record, cancellationToken);
+            }
         }
+
+        public Task RespondAsync(
+            CalendarMeeting meeting,
+            MeetingStartPromptResponse response)
+        {
+            var prompt = pendingPrompts.Single(pending => ReferenceEquals(pending.Meeting, meeting));
+            return prompt.HandleResponseAsync(response, CancellationToken.None);
+        }
+
+        private sealed record PendingPrompt(
+            CalendarMeeting Meeting,
+            Func<MeetingStartPromptResponse, CancellationToken, Task> HandleResponseAsync);
     }
 
     private sealed class RecordingPromptRecorder : IMeetingPromptRecordingController
@@ -206,16 +343,35 @@ public sealed class CalendarRecordingPromptSchedulerTests
 
         public int StopCount { get; private set; }
 
+        public int PromptStartCount { get; private set; }
+
         public List<string> Commands { get; } = [];
 
+        public List<MeetingMetadata?> StartMetadata { get; } = [];
+
         public Task<RecordingStatus> StartAsync(CancellationToken cancellationToken)
+        {
+            return StartRecordingAsync(null);
+        }
+
+        private Task<RecordingStatus> StartRecordingAsync(
+            MeetingMetadata? metadata)
         {
             StartCount++;
             Commands.Add("start");
+            StartMetadata.Add(metadata);
             CurrentStatus = Status(isRecording: true);
             return Task.FromResult(CurrentStatus);
         }
 
+        public Task<RecordingStatus> StartFromPromptAsync(
+            MeetingMetadata? metadata,
+            CancellationToken cancellationToken)
+        {
+            PromptStartCount++;
+            return StartRecordingAsync(metadata);
+        }
+
         public Task<RecordingStatus> StopAsync(CancellationToken cancellationToken)
         {
             StopCount++;