Save the after-Stop diarizer notes, end the worker when the window closes, and kill helpers on app exit

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01GUzvd3VYM6n8xTXtBdDt5f

Author: claude

src/PrimeDictate.Desktop/MainWindow.axaml.cs

@@ -110,6 +110,8 @@ public MainWindow()
         this.AddHandler(DragDrop.DropEvent, this.OnDrop);
         this.Opened += async (_, _) => await this.InitializeWorkspaceAsync();
         this.Closing += (_, _) => this.workspace.DiscardLiveAsync().GetAwaiter().GetResult();
+        // Closing the window ends the speech worker too; left running it keeps the GPU's memory.
+        this.Closed += (_, _) => this.workspace.DisposeAsync().AsTask().Wait(TimeSpan.FromSeconds(10));
     }
 
     /// <summary>Selects the newest session; used by the smoke screenshot.</summary>
@@ -249,22 +251,13 @@ private void Attach(SessionDocumentHost? newHost)
     }
 
     /// <summary>Redraws a finished meeting's speaker timeline from the whole-file diarizer, so overlapping speech shows.</summary>
-    private async Task RefineTimelineAsync(Guid sessionId)
+    private async Task RefineTimelineAsync(SessionDocumentHost target)
     {
-        var (overlay, reason) = await this.workspace.BuildOverlayAsync(sessionId, CancellationToken.None);
-        if (this.host is not { } current || current.Document.SessionId != sessionId)
+        var overlay = await this.workspace.RefineSpeakerTimelineAsync(target, CancellationToken.None);
+        if (overlay is not null && ReferenceEquals(this.host, target))
         {
-            return;
-        }
-
-        if (overlay is null)
-        {
-            current.AddNote($"Speaker timeline was not redrawn: {reason}");
-            return;
+            this.Timeline.SetOverlay(overlay.MapTo(target.Document));
         }
-
-        this.Timeline.SetOverlay(overlay.MapTo(current.Document));
-        current.AddNote($"Speaker timeline redrawn from the diarizer: {overlay.SpeakerCount} system speakers, {overlay.OverlapSeconds:0.#} s of overlapping speech.");
     }
 
     private void OnDocumentChanged(TranscriptDocument _)
@@ -756,10 +749,10 @@ private async Task StopRecordingAsync()
         this.EndJob();
         this.Say(target?.Document.Status == TranscriptSessionStatus.Completed ? "Saved." : $"Stopped: {target?.Document.Status}. What was captured is kept.");
         await this.ReloadSessionsAsync(target?.Document.SessionId);
-        if (target is { Document.SourceType: TranscriptSourceType.Meeting } meeting && meeting.Document.Status == TranscriptSessionStatus.Completed)
+        if (target is { Document.SourceType: TranscriptSourceType.Meeting } meeting)
         {
             this.Say("Saved. Redrawing the speaker timeline…");
-            await this.RunSafelyAsync(() => this.RefineTimelineAsync(meeting.Document.SessionId));
+            await this.RunSafelyAsync(() => this.RefineTimelineAsync(meeting));
             this.Say("Saved.");
         }
     }

src/PrimeDictate.Platforms/Nemotron/ChildProcessJob.cs

@@ -6,17 +6,64 @@ namespace PrimeDictate.Platforms.Nemotron;
 /// <summary>
 /// Ties helper processes to this app on Windows: they go into a job object that kills them when the app's last handle
 /// to it closes, which includes a crash or a force-kill (a rebuild, Task Manager). Without it a killed app leaves the
-/// GPU-holding <c>nemo-speech</c> worker running. Other platforms have no equivalent here and return false; there the
-/// worker still dies when the app disposes it normally.
+/// GPU-holding <c>nemo-speech</c> worker running. Every platform also kills the helpers when the app exits normally or
+/// after an unhandled error; only a force-kill on Linux or macOS can still leave one behind.
 /// </summary>
 public static class ChildProcessJob
 {
     private static readonly object Gate = new();
     private static IntPtr job;
+    private static readonly List<Process> Started = [];
 
-    /// <returns>True when the process is now tied to this app.</returns>
+    static ChildProcessJob() => AppDomain.CurrentDomain.ProcessExit += (_, _) => KillAll();
+
+    /// <summary>Kills every helper still running. Runs when the app exits on any platform, including after an unhandled error.</summary>
+    public static void KillAll()
+    {
+        Process[] running;
+        lock (Gate)
+        {
+            running = [.. Started];
+            Started.Clear();
+        }
+
+        foreach (var process in running)
+        {
+            try
+            {
+                if (!IsGone(process))
+                {
+                    process.Kill(entireProcessTree: true);
+                }
+            }
+            catch (Exception ex) when (ex is InvalidOperationException or System.ComponentModel.Win32Exception)
+            {
+            }
+        }
+    }
+
+    /// <summary>True when the process ended or its object was already disposed.</summary>
+    private static bool IsGone(Process process)
+    {
+        try
+        {
+            return process.HasExited;
+        }
+        catch (InvalidOperationException)
+        {
+            return true;
+        }
+    }
+
+    /// <returns>True when the process is now tied to this app by the operating system (Windows job object).</returns>
     public static bool TryAdd(Process process)
     {
+        lock (Gate)
+        {
+            Started.RemoveAll(IsGone);
+            Started.Add(process);
+        }
+
         if (!OperatingSystem.IsWindows())
         {
             return false;

src/PrimeDictate.Platforms/TranscriptionWorkspaceService.cs

@@ -465,6 +465,51 @@ public async Task StopLiveAsync(CancellationToken cancellationToken)
         return (overlay, error);
     }
 
+    /// <summary>
+    /// Runs the whole-file diarizer for a finished meeting and always says what happened in the session's notes, saved to
+    /// the database: that it started, and then that it worked or why it did not. The notes are saved here because nothing
+    /// else writes the session again after Stop.
+    /// </summary>
+    public async Task<DiarizationOverlay?> RefineSpeakerTimelineAsync(SessionDocumentHost host, CancellationToken cancellationToken)
+    {
+        async Task NoteAsync(string text)
+        {
+            host.AddNote(text);
+            await host.CheckpointAsync(CancellationToken.None).ConfigureAwait(false);
+        }
+
+        var document = host.Document;
+        if (document.SourceType != TranscriptSourceType.Meeting)
+        {
+            return null;
+        }
+
+        if (document.Status != TranscriptSessionStatus.Completed)
+        {
+            await NoteAsync($"Speaker timeline was not redrawn: the session ended as {document.Status}, not Completed.").ConfigureAwait(false);
+            return null;
+        }
+
+        try
+        {
+            await NoteAsync("Redrawing the speaker timeline from the diarizer (running)…").ConfigureAwait(false);
+            var (overlay, reason) = await this.BuildOverlayAsync(document.SessionId, cancellationToken).ConfigureAwait(false);
+            if (overlay is null)
+            {
+                await NoteAsync($"Speaker timeline was not redrawn: {reason}").ConfigureAwait(false);
+                return null;
+            }
+
+            await NoteAsync($"Speaker timeline redrawn from the diarizer: {overlay.SpeakerCount} system speakers, {overlay.OverlapSeconds:0.#} s of overlapping speech.").ConfigureAwait(false);
+            return overlay;
+        }
+        catch (Exception ex) when (ex is not OperationCanceledException)
+        {
+            await NoteAsync($"Speaker timeline was not redrawn: {ex.Message}").ConfigureAwait(false);
+            return null;
+        }
+    }
+
     public async Task DiscardLiveAsync()
     {
         var session = Interlocked.Exchange(ref this.live, null);
@@ -501,14 +546,21 @@ public static async Task ExportAsync(TranscriptDocument document, string path, E
     public async ValueTask DisposeAsync()
     {
         await this.DiscardLiveAsync().ConfigureAwait(false);
-        foreach (var provider in this.providers.Values)
+        // Stop the worker first: it holds the GPU, and the providers' sockets then close quickly instead of waiting on it.
+        if (this.nemotronWorker is not null)
         {
-            await provider.DisposeAsync().ConfigureAwait(false);
+            await this.nemotronWorker.DisposeAsync().ConfigureAwait(false);
         }
 
-        if (this.nemotronWorker is not null)
+        foreach (var provider in this.providers.Values)
         {
-            await this.nemotronWorker.DisposeAsync().ConfigureAwait(false);
+            try
+            {
+                await provider.DisposeAsync().AsTask().WaitAsync(TimeSpan.FromSeconds(3)).ConfigureAwait(false);
+            }
+            catch (Exception ex) when (ex is TimeoutException or ObjectDisposedException or InvalidOperationException)
+            {
+            }
         }
 
         await this.store.DisposeAsync().ConfigureAwait(false);

tests/PrimeDictate.Core.Tests/NemotronLogTests.cs

@@ -45,6 +45,26 @@ public void The_debug_variable_that_prints_word_pieces_is_removed_from_a_childs_
         Assert.True(info.Environment.ContainsKey("KEEP_ME"));
     }
 
+    [Fact]
+    public void Tracking_a_process_that_was_already_disposed_does_not_throw_and_helpers_are_killed_on_request()
+    {
+        if (!OperatingSystem.IsLinux())
+        {
+            return;
+        }
+
+        var gone = System.Diagnostics.Process.Start("/bin/true")!;
+        gone.WaitForExit();
+        gone.Dispose();
+        var sleeper = System.Diagnostics.Process.Start("/bin/sleep", "60")!;
+
+        ChildProcessJob.TryAdd(gone);
+        ChildProcessJob.TryAdd(sleeper);
+        ChildProcessJob.KillAll();
+
+        Assert.True(sleeper.WaitForExit(5000));
+    }
+
     [Fact]
     public void Long_lines_are_cut_short()
     {

tests/PrimeDictate.Core.Tests/StorageTests.cs

@@ -30,6 +30,30 @@ private async Task<SqliteTranscriptionSessionStore> OpenStoreAsync()
         return store;
     }
 
+    [Fact]
+    public async Task Segments_saved_in_finish_order_load_sorted_by_start_and_a_late_note_needs_its_own_checkpoint()
+    {
+        await using var store = await this.OpenStoreAsync();
+        var doc = NewDocument();
+        doc = TranscriptDocumentReducer.Apply(doc, new SessionStarted(doc.SessionId, Run()), Now);
+        // The two meeting streams finish in any order, so segments are stored in the order they were finalized.
+        foreach (var (id, start) in new[] { ("us0.0", 5.0), ("um0.0", 1.0), ("us0.1", 3.0) })
+        {
+            doc = TranscriptDocumentReducer.Apply(doc, new SegmentFinalized(doc.SessionId, Segment(id, id, start, start + 1)), Now);
+        }
+
+        var host = new PrimeDictate.Core.Pipeline.SessionDocumentHost(doc, store);
+        await host.CheckpointAsync();
+        host.AddNote("added after the session was already saved");
+
+        Assert.DoesNotContain("added after the session was already saved", (await store.LoadAsync(doc.SessionId, default))!.Notes);
+        await host.CheckpointAsync();
+        var loaded = (await store.LoadAsync(doc.SessionId, default))!;
+
+        Assert.Equal(["um0.0", "us0.1", "us0.0"], loaded.Segments.Select(s => s.Id));
+        Assert.Contains("added after the session was already saved", loaded.Notes);
+    }
+
     [Fact]
     public async Task Checkpoint_round_trips_final_content_but_not_partials()
     {