From 4f91f84f3f8f648e2dfc33693c651b6f0ff45c85 Mon Sep 17 00:00:00 2001
From: devjenjen <devjenjen@gmail.com>
Date: Mon, 26 Oct 2026 18:53:58 +0100
Subject: [PATCH 1/9] feat(hud): rainbow rim around pill while transcribing

---
 .../src/Murmur.App/Styles/MurmurTokens.axaml  | 15 ++++
 windows/src/Murmur.App/Views/HudWindow.axaml  | 31 ++++++++-
 .../src/Murmur.App/Views/HudWindow.axaml.cs   | 69 +++++++++++++++++++
 .../Murmur.Platform.Windows/Native/Win32.cs   | 11 +++
 .../tests/Murmur.App.Tests/HudWindowTests.cs  | 67 ++++++++++++++++++
 5 files changed, 192 insertions(+), 1 deletion(-)

diff --git a/windows/src/Murmur.App/Styles/MurmurTokens.axaml b/windows/src/Murmur.App/Styles/MurmurTokens.axaml
index 59a38f4..1bafe6e 100644
--- a/windows/src/Murmur.App/Styles/MurmurTokens.axaml
+++ b/windows/src/Murmur.App/Styles/MurmurTokens.axaml
@@ -872,6 +872,21 @@
         </Setter>
     </Style>
 
+    <Style Selector="Panel.hudRainbowRim">
+        <Setter Property="Opacity" Value="0" />
+        <Setter Property="Transitions">
+            <Transitions>
+                <DoubleTransition Property="Opacity"
+                                  Duration="0:0:0.28"
+                                  Easing="CubicEaseOut" />
+            </Transitions>
+        </Setter>
+    </Style>
+
+    <Style Selector="Panel.hudRainbowRim.active">
+        <Setter Property="Opacity" Value="1" />
+    </Style>
+
     <Style Selector="TextBlock.hudTranscript">
         <Setter Property="Transitions">
             <Transitions>
diff --git a/windows/src/Murmur.App/Views/HudWindow.axaml b/windows/src/Murmur.App/Views/HudWindow.axaml
index 597e636..926cdcc 100644
--- a/windows/src/Murmur.App/Views/HudWindow.axaml
+++ b/windows/src/Murmur.App/Views/HudWindow.axaml
@@ -27,7 +27,36 @@
                 BorderBrush="{DynamicResource HudHairlineBrush}"
                 BorderThickness="{DynamicResource HudBorderThickness}"
                 CornerRadius="{DynamicResource HudOrbRadius}"
-                RenderTransformOrigin="50%,50%" />
+                RenderTransformOrigin="50%,50%">
+            <!-- Rainbow rim shown only while transcribing (Finishing). Margin cancels
+                 HudBorderThickness so the stroke traces the outer pill silhouette, which
+                 stays inside the native window region. -->
+            <Panel x:Name="RainbowRim"
+                   Classes="hudRainbowRim"
+                   Margin="-1"
+                   IsHitTestVisible="False">
+                <Panel.Resources>
+                    <ConicGradientBrush x:Key="HudRainbowBrush" Center="50%,50%" Angle="-90">
+                        <GradientStop Offset="0" Color="#FFFF5E7E" />
+                        <GradientStop Offset="0.14" Color="#FFFF9F0A" />
+                        <GradientStop Offset="0.28" Color="#FFFFD60A" />
+                        <GradientStop Offset="0.42" Color="#FF30D158" />
+                        <GradientStop Offset="0.57" Color="#FF64D2FF" />
+                        <GradientStop Offset="0.71" Color="#FF0A84FF" />
+                        <GradientStop Offset="0.86" Color="#FFBF5AF2" />
+                        <GradientStop Offset="1" Color="#FFFF5E7E" />
+                    </ConicGradientBrush>
+                </Panel.Resources>
+                <!-- Soft inner wash; an outer glow would be clipped by the native region. -->
+                <Border CornerRadius="{Binding #HudSurface.CornerRadius}"
+                        BorderThickness="4"
+                        BorderBrush="{StaticResource HudRainbowBrush}"
+                        Opacity="0.2" />
+                <Border CornerRadius="{Binding #HudSurface.CornerRadius}"
+                        BorderThickness="1.5"
+                        BorderBrush="{StaticResource HudRainbowBrush}" />
+            </Panel>
+        </Border>
 
         <Border x:Name="HudContentSurface"
                 Classes="hudContentSurface"
diff --git a/windows/src/Murmur.App/Views/HudWindow.axaml.cs b/windows/src/Murmur.App/Views/HudWindow.axaml.cs
index e463665..425344c 100644
--- a/windows/src/Murmur.App/Views/HudWindow.axaml.cs
+++ b/windows/src/Murmur.App/Views/HudWindow.axaml.cs
@@ -40,11 +40,24 @@ public partial class HudWindow : Window
     private int _levelUpdatePending;
     private float _pendingLevel;
     private DictationStatus _pendingLevelStatus;
+    private readonly ConicGradientBrush _rainbowBrush;
+    private bool _rainbowAnimating;
+    private bool _rainbowFrameRequested;
+
+    private const double RainbowRestAngle = -90;
+    private const double RainbowDegreesPerSecond = 120;
+
+    /// <summary>Reports whether Windows animation effects are off; replaceable in tests.</summary>
+    internal Func<bool> IsReducedMotion { get; set; } = ReadSystemReducedMotion;
+
+    /// <summary>True while the rainbow rim is requesting animation frames.</summary>
+    internal bool IsRainbowAnimating => _rainbowAnimating;
 
     /// <summary>Initializes a new instance of HudWindow.</summary>
     public HudWindow()
     {
         InitializeComponent();
+        _rainbowBrush = (ConicGradientBrush)RainbowRim.Resources["HudRainbowBrush"]!;
         ApplyPlacementAlignment();
         LayoutUpdated += OnLayoutUpdated;
     }
@@ -347,6 +360,7 @@ private void StartProcessingAnimation()
         };
         _processingTimer.Tick += OnProcessingTick;
         _processingTimer.Start();
+        StartRainbowRim();
     }
 
     private void OnProcessingTick(object? sender, EventArgs e)
@@ -363,10 +377,65 @@ private static void SetDotOpacity(Ellipse dot, double phase, double offset)
         dot.Opacity = 0.35 + (pulse * 0.65);
     }
 
+    private void StartRainbowRim()
+    {
+        RainbowRim.Classes.Set("active", true);
+        _rainbowAnimating = !IsReducedMotion();
+        if (_rainbowAnimating)
+        {
+            RequestRainbowFrame();
+        }
+        else
+        {
+            // Reduced motion: calm, static rainbow.
+            _rainbowBrush.Angle = RainbowRestAngle;
+        }
+    }
+
+    private void StopRainbowRim()
+    {
+        _rainbowAnimating = false;
+        RainbowRim.Classes.Set("active", false);
+    }
+
+    private void RequestRainbowFrame()
+    {
+        if (_rainbowFrameRequested) return;
+        _rainbowFrameRequested = true;
+        RequestAnimationFrame(OnRainbowFrame);
+    }
+
+    private void OnRainbowFrame(TimeSpan time)
+    {
+        _rainbowFrameRequested = false;
+        if (!_rainbowAnimating || !IsVisible)
+        {
+            _rainbowAnimating = false;
+            return;
+        }
+
+        _rainbowBrush.Angle = RainbowRestAngle + (time.TotalSeconds * RainbowDegreesPerSecond % 360);
+        RequestRainbowFrame();
+    }
+
+    private static bool ReadSystemReducedMotion()
+    {
+        try
+        {
+            return Win32.SystemParametersInfoW(Win32.SPI_GETCLIENTAREAANIMATION, 0, out var enabled, 0)
+                && !enabled;
+        }
+        catch (Exception ex) when (ex is DllNotFoundException or EntryPointNotFoundException)
+        {
+            return false;
+        }
+    }
+
     private void StopProcessingAnimation()
     {
         _processingTimer?.Stop();
         _processingTimer = null;
+        StopRainbowRim();
         ProcessingDots.IsVisible = false;
         ProcessingDot1.Opacity = 0.35;
         ProcessingDot2.Opacity = 0.35;
diff --git a/windows/src/Murmur.Platform.Windows/Native/Win32.cs b/windows/src/Murmur.Platform.Windows/Native/Win32.cs
index aa45c48..efd2ff6 100644
--- a/windows/src/Murmur.Platform.Windows/Native/Win32.cs
+++ b/windows/src/Murmur.Platform.Windows/Native/Win32.cs
@@ -150,6 +150,17 @@ public struct RECT
     [return: MarshalAs(UnmanagedType.Bool)]
     public static extern bool GetWindowRect(nint hWnd, out RECT rect);
 
+    /// <summary>SPI_GETCLIENTAREAANIMATION: false when Windows "Animation effects" is off (reduced motion).</summary>
+    public const uint SPI_GETCLIENTAREAANIMATION = 0x1042;
+
+    [DllImport("user32.dll", SetLastError = true)]
+    [return: MarshalAs(UnmanagedType.Bool)]
+    public static extern bool SystemParametersInfoW(
+        uint uiAction,
+        uint uiParam,
+        [MarshalAs(UnmanagedType.Bool)] out bool pvParam,
+        uint fWinIni);
+
     [DllImport("user32.dll", SetLastError = true)]
     public static extern nint SetWindowLongPtrW(nint hWnd, int nIndex, nint dwNewLong);
 
diff --git a/windows/tests/Murmur.App.Tests/HudWindowTests.cs b/windows/tests/Murmur.App.Tests/HudWindowTests.cs
index a06ef96..881c4d0 100644
--- a/windows/tests/Murmur.App.Tests/HudWindowTests.cs
+++ b/windows/tests/Murmur.App.Tests/HudWindowTests.cs
@@ -672,6 +672,73 @@ public void HudWindow_FinishingUsesBoundedTranscriptPreview()
         transcript.Text.ShouldStartWith("… ");
     }
 
+    [AvaloniaFact]
+    public void HudWindow_RainbowRim_OnlyDuringFinishing()
+    {
+        var hud = new HudWindow { IsReducedMotion = () => false };
+        var rim = hud.FindControl<Panel>("RainbowRim")!;
+
+        hud.UpdateState(new DictationState(DictationStatus.Starting), 0, "");
+        Dispatcher.UIThread.RunJobs();
+        rim.Classes.ShouldNotContain("active");
+
+        hud.UpdateState(new DictationState(DictationStatus.Listening), 0.5f, "words");
+        Dispatcher.UIThread.RunJobs();
+        rim.Classes.ShouldNotContain("active");
+        hud.IsRainbowAnimating.ShouldBeFalse();
+
+        hud.UpdateState(new DictationState(DictationStatus.Finishing), 0, "words");
+        Dispatcher.UIThread.RunJobs();
+        rim.Classes.ShouldContain("active");
+        hud.IsRainbowAnimating.ShouldBeTrue();
+
+        hud.UpdateState(new DictationState(DictationStatus.Error, "boom"), 0, "");
+        Dispatcher.UIThread.RunJobs();
+        rim.Classes.ShouldNotContain("active");
+        hud.IsRainbowAnimating.ShouldBeFalse();
+    }
+
+    [AvaloniaFact]
+    public void HudWindow_RainbowRim_StopsOnIdleAndClose()
+    {
+        var hud = new HudWindow { IsReducedMotion = () => false };
+        var rim = hud.FindControl<Panel>("RainbowRim")!;
+
+        hud.UpdateState(new DictationState(DictationStatus.Finishing), 0, "");
+        Dispatcher.UIThread.RunJobs();
+        hud.IsRainbowAnimating.ShouldBeTrue();
+
+        hud.UpdateState(DictationState.Idle, 0, "");
+        Dispatcher.UIThread.RunJobs();
+        rim.Classes.ShouldNotContain("active");
+        hud.IsRainbowAnimating.ShouldBeFalse();
+
+        hud.UpdateState(new DictationState(DictationStatus.Finishing), 0, "");
+        Dispatcher.UIThread.RunJobs();
+        hud.IsRainbowAnimating.ShouldBeTrue();
+
+        hud.Close();
+        Dispatcher.UIThread.RunJobs();
+        rim.Classes.ShouldNotContain("active");
+        hud.IsRainbowAnimating.ShouldBeFalse();
+    }
+
+    [AvaloniaFact]
+    public void HudWindow_RainbowRim_ReducedMotionIsStatic()
+    {
+        var hud = new HudWindow { IsReducedMotion = () => true };
+        var rim = hud.FindControl<Panel>("RainbowRim")!;
+        var brush = (ConicGradientBrush)rim.Resources["HudRainbowBrush"]!;
+        brush.Angle = 42;
+
+        hud.UpdateState(new DictationState(DictationStatus.Finishing), 0, "");
+        Dispatcher.UIThread.RunJobs();
+
+        rim.Classes.ShouldContain("active");
+        hud.IsRainbowAnimating.ShouldBeFalse();
+        brush.Angle.ShouldBe(-90);
+    }
+
     [AvaloniaFact]
     public void HudWindow_LongSingleWordDoesNotOverflowSurface()
     {

From a3e923b075c075b2df9763d9bcb262da7df5e0c3 Mon Sep 17 00:00:00 2001
From: devjenjen <devjenjen@gmail.com>
Date: Mon, 26 Oct 2026 20:37:13 +0100
Subject: [PATCH 2/9] feat(hud): refine studio pill and reduced motion behavior

---
 .../src/Murmur.App/Controls/VUMeterControl.cs |  87 +++-
 .../src/Murmur.App/Styles/MurmurTokens.axaml  |  30 +-
 windows/src/Murmur.App/Views/HudWindow.axaml  |  87 ++--
 .../src/Murmur.App/Views/HudWindow.axaml.cs   | 126 +++++-
 .../Murmur.App.Tests/SettingsWindowTests.cs   |   5 +-
 .../tests/Murmur.App.Tests/StudioHudTests.cs  | 403 ++++++++++++++++++
 6 files changed, 668 insertions(+), 70 deletions(-)
 create mode 100644 windows/tests/Murmur.App.Tests/StudioHudTests.cs

diff --git a/windows/src/Murmur.App/Controls/VUMeterControl.cs b/windows/src/Murmur.App/Controls/VUMeterControl.cs
index e5e746a..3f501bd 100644
--- a/windows/src/Murmur.App/Controls/VUMeterControl.cs
+++ b/windows/src/Murmur.App/Controls/VUMeterControl.cs
@@ -3,12 +3,12 @@
 using Avalonia.Controls;
 using Avalonia.Media;
 using Avalonia.Threading;
+using System.Diagnostics;
 
 namespace Murmur.App.Controls;
 
 /// <summary>
-/// Analog VU meter with damped spring ballistics (300ms attack, 420ms release, 6% overshoot)
-/// and discrete 16-segment instrumentation bar.
+/// Sixteen-segment meter with studio HUD envelope or legacy settings spring ballistics.
 /// </summary>
 public sealed class VUMeterControl : Control
 {
@@ -55,12 +55,28 @@ public bool UseHudPalette
 
     private double _position;
     private double _velocity;
+    private double _holdRemaining;
+    private long _lastTick;
+    private bool _reducedMotion;
     private DispatcherTimer? _timer;
     private bool _isAttached;
     private int _lastReportedLevelBucket = -1;
 
     /// <summary>Internal flag indicating if animation timer is running (for tests only).</summary>
     internal bool IsAnimationRunning => _timer?.IsEnabled == true;
+    internal double CurrentPosition => _position;
+    internal double HoldRemainingSeconds => _holdRemaining;
+
+    internal bool ReducedMotion
+    {
+        get => _reducedMotion;
+        set
+        {
+            if (_reducedMotion == value) return;
+            _reducedMotion = value;
+            OnLevelOrActiveChanged();
+        }
+    }
 
     internal const int SegmentCount = 16;
     private static readonly IBrush UnlitBrush = new SolidColorBrush(Color.Parse("#262422"));
@@ -121,6 +137,9 @@ private double ResolveDouble(string key, double fallback)
     private void OnPaletteModeChanged()
     {
         _paletteDirty = true;
+        _holdRemaining = 0;
+        _velocity = 0;
+        EvaluateTimerState();
         InvalidateVisual();
     }
 
@@ -204,7 +223,7 @@ private void OnLevelOrActiveChanged()
     {
         UpdateItemStatus();
         EvaluateTimerState();
-        if (!_isAttached || !IsVisible)
+        if (!_isAttached || !IsVisible || (UseHudPalette && ReducedMotion))
         {
             InvalidateVisual();
         }
@@ -223,6 +242,15 @@ private void UpdateItemStatus()
 
     private void EvaluateTimerState()
     {
+        if (UseHudPalette && ReducedMotion)
+        {
+            StopTimer();
+            _position = IsActive ? Math.Clamp((double)Level, 0, 1) : 0;
+            _velocity = 0;
+            _holdRemaining = 0;
+            return;
+        }
+
         if (!_isAttached || !IsVisible)
         {
             StopTimer();
@@ -230,7 +258,9 @@ private void EvaluateTimerState()
         }
 
         var target = IsActive ? Math.Clamp((double)Level, 0.0, 1.0) : 0.0;
-        var needsAnimation = IsActive || _position > 0.001 || Math.Abs(target - _position) > 0.001 || Math.Abs(_velocity) > 0.0001;
+        var needsAnimation = UseHudPalette
+            ? Math.Abs(target - _position) > 0.001
+            : IsActive || _position > 0.001 || Math.Abs(target - _position) > 0.001 || Math.Abs(_velocity) > 0.0001;
 
         if (needsAnimation)
         {
@@ -248,13 +278,19 @@ private void StartTimer()
         {
             _timer = new DispatcherTimer(TimeSpan.FromMilliseconds(1000.0 / 60.0), DispatcherPriority.Render, (_, _) =>
             {
-                AdvanceNeedle();
+                var now = Stopwatch.GetTimestamp();
+                if (UseHudPalette)
+                    StepBallistics(Stopwatch.GetElapsedTime(_lastTick, now).TotalSeconds);
+                else
+                    AdvanceNeedle();
+                _lastTick = now;
                 InvalidateVisual();
             });
         }
 
         if (!_timer.IsEnabled)
         {
+            _lastTick = Stopwatch.GetTimestamp();
             _timer.Start();
         }
     }
@@ -297,6 +333,47 @@ private void AdvanceNeedle()
         }
     }
 
+    internal void ResetBallistics()
+    {
+        StopTimer();
+        _position = _velocity = _holdRemaining = 0;
+        InvalidateVisual();
+    }
+
+    internal void StepBallistics(double dtSeconds)
+    {
+        if (!double.IsFinite(dtSeconds) || dtSeconds <= 0) return;
+        var target = IsActive ? Math.Clamp((double)Level, 0, 1) : 0;
+        if (ReducedMotion)
+        {
+            _position = target;
+            _holdRemaining = 0;
+            StopTimer();
+            return;
+        }
+
+        var rising = target >= _position;
+        if (rising)
+        {
+            _holdRemaining = .180;
+        }
+        else
+        {
+            if (!IsActive) _holdRemaining = 0;
+            var heldTime = Math.Min(_holdRemaining, dtSeconds);
+            _holdRemaining -= heldTime;
+            dtSeconds -= heldTime;
+        }
+
+        // Exact exponential response: 95% in 90/400ms, monotone even after a delayed frame.
+        _position = target + (_position - target) * Math.Exp(-3 * dtSeconds / (rising ? .090 : .400));
+        if (Math.Abs(target - _position) < .001)
+        {
+            _position = target;
+            StopTimer();
+        }
+    }
+
     /// <inheritdoc />
     public override void Render(DrawingContext context)
     {
diff --git a/windows/src/Murmur.App/Styles/MurmurTokens.axaml b/windows/src/Murmur.App/Styles/MurmurTokens.axaml
index 1bafe6e..5ec6fd6 100644
--- a/windows/src/Murmur.App/Styles/MurmurTokens.axaml
+++ b/windows/src/Murmur.App/Styles/MurmurTokens.axaml
@@ -86,7 +86,12 @@
                     <SolidColorBrush x:Key="HudChassisBrush" Color="#551C1C1E" />
                     <SolidColorBrush x:Key="HudSolidFallbackBrush" Color="#FF1C1C1E" />
                     <SolidColorBrush x:Key="HudHairlineBrush" Color="#40FFFFFF" />
-                    <SolidColorBrush x:Key="HudRecordingEdgeBrush" Color="#FFFF453A" />
+                    <SolidColorBrush x:Key="HudRecordingEdgeBrush" Color="{StaticResource RecordLampColor}" />
+                    <LinearGradientBrush x:Key="HudSpecularHairlineBrush" StartPoint="50%,0%" EndPoint="50%,100%">
+                        <GradientStop Offset="0" Color="#38E4DED0" />
+                        <GradientStop Offset="0.3" Color="#20FFFFFF" />
+                        <GradientStop Offset="1" Color="#08FFFFFF" />
+                    </LinearGradientBrush>
                     <SolidColorBrush x:Key="HudProcessingBrush" Color="#FF0A84FF" />
                     <SolidColorBrush x:Key="HudErrorBrush" Color="#FFFF9F0A" />
                     <SolidColorBrush x:Key="HudIdleLampBrush" Color="#3DFFFFFF" />
@@ -209,7 +214,12 @@
                     <SolidColorBrush x:Key="HudChassisBrush" Color="#55FAFAFC" />
                     <SolidColorBrush x:Key="HudSolidFallbackBrush" Color="#FFFAFAFC" />
                     <SolidColorBrush x:Key="HudHairlineBrush" Color="#40000000" />
-                    <SolidColorBrush x:Key="HudRecordingEdgeBrush" Color="#FFFF3B30" />
+                    <SolidColorBrush x:Key="HudRecordingEdgeBrush" Color="{StaticResource RecordLampColor}" />
+                    <LinearGradientBrush x:Key="HudSpecularHairlineBrush" StartPoint="50%,0%" EndPoint="50%,100%">
+                        <GradientStop Offset="0" Color="#40000000" />
+                        <GradientStop Offset="0.4" Color="#18000000" />
+                        <GradientStop Offset="1" Color="#05000000" />
+                    </LinearGradientBrush>
                     <SolidColorBrush x:Key="HudProcessingBrush" Color="#FF007AFF" />
                     <SolidColorBrush x:Key="HudErrorBrush" Color="#FFC25E00" />
                     <SolidColorBrush x:Key="HudIdleLampBrush" Color="#55000000" />
@@ -317,7 +327,7 @@
             <x:Double x:Key="HudRecordingMinWidth">245</x:Double>
             <x:Double x:Key="HudRecordingMaxWidth">416</x:Double>
             <x:Double x:Key="HudProcessingWidth">301</x:Double>
-            <x:Double x:Key="HudProcessingHeight">38</x:Double>
+            <x:Double x:Key="HudProcessingHeight">44</x:Double>
             <x:Double x:Key="HudErrorWidth">488</x:Double>
             <x:Double x:Key="HudErrorHeight">83</x:Double>
             <x:Double x:Key="HudTranscriptMaxWidth">288</x:Double>
@@ -336,8 +346,8 @@
             <x:Double x:Key="HudEntryScale">0.96</x:Double>
             <x:Double x:Key="HudRestingScale">1</x:Double>
             <CornerRadius x:Key="HudRadiusArmed">22</CornerRadius>
-            <CornerRadius x:Key="HudRadiusRecording">26</CornerRadius>
-            <CornerRadius x:Key="HudRadiusProcessing">19</CornerRadius>
+            <CornerRadius x:Key="HudRadiusRecording">22</CornerRadius>
+            <CornerRadius x:Key="HudRadiusProcessing">22</CornerRadius>
             <CornerRadius x:Key="HudRadiusError">14</CornerRadius>
             <Thickness x:Key="HudPadding">12,8</Thickness>
             <Thickness x:Key="HudBorderThickness">1</Thickness>
@@ -872,18 +882,18 @@
         </Setter>
     </Style>
 
-    <Style Selector="Panel.hudRainbowRim">
+    <Style Selector="Panel.hudRainbowRim, Panel.hudRecordingRim">
         <Setter Property="Opacity" Value="0" />
         <Setter Property="Transitions">
             <Transitions>
                 <DoubleTransition Property="Opacity"
-                                  Duration="0:0:0.28"
+                                  Duration="0:0:0.20"
                                   Easing="CubicEaseOut" />
             </Transitions>
         </Setter>
     </Style>
 
-    <Style Selector="Panel.hudRainbowRim.active">
+    <Style Selector="Panel.hudRainbowRim.active, Panel.hudRecordingRim.active">
         <Setter Property="Opacity" Value="1" />
     </Style>
 
@@ -899,4 +909,8 @@
             </Transitions>
         </Setter>
     </Style>
+
+    <Style Selector="Border.hudSurface.motionOff, Border.hudContentSurface.motionOff, Panel.hudRainbowRim.motionOff, Panel.hudRecordingRim.motionOff, TextBlock.hudTranscript.motionOff">
+        <Setter Property="Transitions" Value="{x:Null}" />
+    </Style>
 </Styles>
diff --git a/windows/src/Murmur.App/Views/HudWindow.axaml b/windows/src/Murmur.App/Views/HudWindow.axaml
index 926cdcc..c4e1d5d 100644
--- a/windows/src/Murmur.App/Views/HudWindow.axaml
+++ b/windows/src/Murmur.App/Views/HudWindow.axaml
@@ -24,37 +24,52 @@
                 HorizontalAlignment="Center"
                 VerticalAlignment="Center"
                 Background="{DynamicResource HudChassisBrush}"
-                BorderBrush="{DynamicResource HudHairlineBrush}"
+                BorderBrush="{DynamicResource HudSpecularHairlineBrush}"
                 BorderThickness="{DynamicResource HudBorderThickness}"
                 CornerRadius="{DynamicResource HudOrbRadius}"
                 RenderTransformOrigin="50%,50%">
-            <!-- Rainbow rim shown only while transcribing (Finishing). Margin cancels
-                 HudBorderThickness so the stroke traces the outer pill silhouette, which
-                 stays inside the native window region. -->
-            <Panel x:Name="RainbowRim"
-                   Classes="hudRainbowRim"
-                   Margin="-1"
-                   IsHitTestVisible="False">
-                <Panel.Resources>
-                    <ConicGradientBrush x:Key="HudRainbowBrush" Center="50%,50%" Angle="-90">
-                        <GradientStop Offset="0" Color="#FFFF5E7E" />
-                        <GradientStop Offset="0.14" Color="#FFFF9F0A" />
-                        <GradientStop Offset="0.28" Color="#FFFFD60A" />
-                        <GradientStop Offset="0.42" Color="#FF30D158" />
-                        <GradientStop Offset="0.57" Color="#FF64D2FF" />
-                        <GradientStop Offset="0.71" Color="#FF0A84FF" />
-                        <GradientStop Offset="0.86" Color="#FFBF5AF2" />
-                        <GradientStop Offset="1" Color="#FFFF5E7E" />
-                    </ConicGradientBrush>
-                </Panel.Resources>
-                <!-- Soft inner wash; an outer glow would be clipped by the native region. -->
-                <Border CornerRadius="{Binding #HudSurface.CornerRadius}"
-                        BorderThickness="4"
-                        BorderBrush="{StaticResource HudRainbowBrush}"
-                        Opacity="0.2" />
-                <Border CornerRadius="{Binding #HudSurface.CornerRadius}"
-                        BorderThickness="1.5"
-                        BorderBrush="{StaticResource HudRainbowBrush}" />
+            <Panel>
+                <Panel x:Name="RecordingRim"
+                       Classes="hudRecordingRim"
+                       Margin="-1"
+                       IsHitTestVisible="False">
+                    <Border CornerRadius="{Binding #HudSurface.CornerRadius}"
+                            BorderThickness="4"
+                            BorderBrush="{DynamicResource RecordLampBrush}"
+                            Opacity="0.12" />
+                    <Border CornerRadius="{Binding #HudSurface.CornerRadius}"
+                            BorderThickness="1.5"
+                            BorderBrush="{DynamicResource RecordLampBrush}"
+                            Opacity="0.65" />
+                </Panel>
+                <!-- Rainbow rim shown only while transcribing (Finishing). Margin cancels
+                     HudBorderThickness so the stroke traces the outer pill silhouette, which
+                     stays inside the native window region. -->
+                <Panel x:Name="RainbowRim"
+                       Classes="hudRainbowRim"
+                       Margin="-1"
+                       IsHitTestVisible="False">
+                    <Panel.Resources>
+                        <ConicGradientBrush x:Key="HudRainbowBrush" Center="50%,50%" Angle="-90">
+                            <GradientStop Offset="0" Color="#FFFF5E7E" />
+                            <GradientStop Offset="0.14" Color="#FFFF9F0A" />
+                            <GradientStop Offset="0.28" Color="#FFFFD60A" />
+                            <GradientStop Offset="0.42" Color="#FF30D158" />
+                            <GradientStop Offset="0.57" Color="#FF64D2FF" />
+                            <GradientStop Offset="0.71" Color="#FF0A84FF" />
+                            <GradientStop Offset="0.86" Color="#FFBF5AF2" />
+                            <GradientStop Offset="1" Color="#FFFF5E7E" />
+                        </ConicGradientBrush>
+                    </Panel.Resources>
+                    <!-- Soft inner wash; an outer glow would be clipped by the native region. -->
+                    <Border CornerRadius="{Binding #HudSurface.CornerRadius}"
+                            BorderThickness="4"
+                            BorderBrush="{StaticResource HudRainbowBrush}"
+                            Opacity="0.2" />
+                    <Border CornerRadius="{Binding #HudSurface.CornerRadius}"
+                            BorderThickness="1.5"
+                            BorderBrush="{StaticResource HudRainbowBrush}" />
+                </Panel>
             </Panel>
         </Border>
 
@@ -74,11 +89,17 @@
                             Orientation="Horizontal"
                             Spacing="{DynamicResource HudLampBadgeSpacing}"
                             VerticalAlignment="Center">
-                    <Ellipse x:Name="RecordLamp"
-                             Width="{DynamicResource LampDiameter}"
-                             Height="{DynamicResource LampDiameter}"
-                             Fill="{DynamicResource HudIdleLampBrush}"
-                             VerticalAlignment="Center" />
+                    <Border Padding="1.5" CornerRadius="6"
+                            BorderThickness="0.75"
+                            BorderBrush="{DynamicResource SeamBrush}"
+                            Background="{DynamicResource PanelShadeBrush}"
+                            VerticalAlignment="Center">
+                        <Ellipse x:Name="RecordLamp"
+                                 Width="{DynamicResource LampDiameter}"
+                                 Height="{DynamicResource LampDiameter}"
+                                 Fill="{DynamicResource HudIdleLampBrush}"
+                                 VerticalAlignment="Center" />
+                    </Border>
                     <TextBlock x:Name="TelemetryBadge"
                                Text="{x:Static localization:UiText.HudArm}"
                                Classes="silkscreen"
diff --git a/windows/src/Murmur.App/Views/HudWindow.axaml.cs b/windows/src/Murmur.App/Views/HudWindow.axaml.cs
index 425344c..691707c 100644
--- a/windows/src/Murmur.App/Views/HudWindow.axaml.cs
+++ b/windows/src/Murmur.App/Views/HudWindow.axaml.cs
@@ -43,6 +43,8 @@ public partial class HudWindow : Window
     private readonly ConicGradientBrush _rainbowBrush;
     private bool _rainbowAnimating;
     private bool _rainbowFrameRequested;
+    private bool _reducedMotion;
+    private int _entryGeneration;
 
     private const double RainbowRestAngle = -90;
     private const double RainbowDegreesPerSecond = 120;
@@ -106,14 +108,63 @@ protected override void OnOpened(EventArgs e)
     protected override void OnClosed(EventArgs e)
     {
         base.OnClosed(e);
-        CancelContentReveal();
-        StopProcessingAnimation();
-        _hideTimer?.Stop();
+        StopHiddenEffects();
         LayoutUpdated -= OnLayoutUpdated;
         _appliedNativeRegion = null;
         _platformHandle = null;
     }
 
+    /// <inheritdoc />
+    protected override void OnPropertyChanged(AvaloniaPropertyChangedEventArgs change)
+    {
+        base.OnPropertyChanged(change);
+        if (change.Property == IsVisibleProperty && HudMeter is not null)
+        {
+            HudMeter.IsVisible = IsVisible;
+            if (!IsVisible) StopHiddenEffects();
+        }
+    }
+
+    private void StopHiddenEffects()
+    {
+        _entryGeneration++;
+        CancelContentReveal();
+        CancelPendingHide();
+        HudSurface.Classes.Set("motionOff", true);
+        HudContentSurface.Classes.Set("motionOff", true);
+        TranscriptText.Classes.Set("motionOff", true);
+        RecordingRim.Classes.Set("motionOff", true);
+        RainbowRim.Classes.Set("motionOff", true);
+        RecordingRim.Classes.Set("active", false);
+        StopProcessingAnimation();
+        HudMeter.ResetBallistics();
+    }
+
+    private bool ApplyMotionPreference(DictationStatus status)
+    {
+        var reduced = IsReducedMotion();
+        var changed = reduced != _reducedMotion;
+        _reducedMotion = reduced;
+        HudMeter.ReducedMotion = reduced;
+        var instant = reduced || status == DictationStatus.Error;
+        HudSurface.Classes.Set("motionOff", instant);
+        HudContentSurface.Classes.Set("motionOff", instant);
+        TranscriptText.Classes.Set("motionOff", instant);
+        if (reduced)
+        {
+            _entryGeneration++;
+            CancelContentReveal();
+            HudSurface.Opacity = 1;
+            HudSurface.RenderTransform = TransformScale1;
+            SetContentVisible(status != DictationStatus.Idle);
+        }
+        var instantRims = reduced || status is DictationStatus.Starting or DictationStatus.Error;
+        RecordingRim.Classes.Set("motionOff", instantRims);
+        RainbowRim.Classes.Set("motionOff", instantRims);
+        RecordingRim.Classes.Set("active", status == DictationStatus.Listening);
+        return changed;
+    }
+
     private void OnLayoutUpdated(object? sender, EventArgs e)
     {
         ApplyNativeRegion();
@@ -196,7 +247,8 @@ private void PositionForForegroundWindow()
 
     private IBrush GetBrush(string key, IBrush fallback)
     {
-        if (this.TryFindResource(key, out var resource) && resource is IBrush brush)
+        if ((this.TryFindResource(key, ActualThemeVariant, out var resource) ||
+             this.TryFindResource(key, out resource)) && resource is IBrush brush)
         {
             return brush;
         }
@@ -320,6 +372,11 @@ private void CancelContentReveal()
     private void ScheduleContentReveal()
     {
         CancelContentReveal();
+        if (_reducedMotion)
+        {
+            SetContentVisible(true);
+            return;
+        }
 
         var timer = new DispatcherTimer
         {
@@ -352,7 +409,11 @@ private void StartProcessingAnimation()
     {
         ProcessingDots.IsVisible = true;
         _processingPhase = 0;
+        ProcessingDot1.Opacity = ProcessingDot2.Opacity = ProcessingDot3.Opacity = 0.35;
         _processingTimer?.Stop();
+        _processingTimer = null;
+        StartRainbowRim();
+        if (_reducedMotion) return;
         _processingTimer = new DispatcherTimer
         {
             Interval = TimeSpan.FromMilliseconds(
@@ -360,7 +421,6 @@ private void StartProcessingAnimation()
         };
         _processingTimer.Tick += OnProcessingTick;
         _processingTimer.Start();
-        StartRainbowRim();
     }
 
     private void OnProcessingTick(object? sender, EventArgs e)
@@ -380,7 +440,7 @@ private static void SetDotOpacity(Ellipse dot, double phase, double offset)
     private void StartRainbowRim()
     {
         RainbowRim.Classes.Set("active", true);
-        _rainbowAnimating = !IsReducedMotion();
+        _rainbowAnimating = !_reducedMotion;
         if (_rainbowAnimating)
         {
             RequestRainbowFrame();
@@ -480,6 +540,7 @@ private static string BuildErrorText(string? message, string? transcript)
 
     private void BeginOrbEntry()
     {
+        var generation = ++_entryGeneration;
         ApplyPlacementAlignment();
         CancelContentReveal();
 
@@ -492,12 +553,12 @@ private void BeginOrbEntry()
             diameter,
             diameter,
             orbRadius,
-            GetBrush("HudHairlineBrush", Brushes.Gray));
+            GetBrush("HudSpecularHairlineBrush", Brushes.Gray));
 
         SetContentVisible(false);
 
-        HudSurface.Opacity = 0;
-        HudSurface.RenderTransform = TransformScaleOrbStart;
+        HudSurface.Opacity = _reducedMotion ? 1 : 0;
+        HudSurface.RenderTransform = _reducedMotion ? TransformScale1 : TransformScaleOrbStart;
 
         if (!IsVisible)
         {
@@ -505,10 +566,16 @@ private void BeginOrbEntry()
             Show();
         }
 
+        if (_reducedMotion)
+        {
+            SetContentVisible(true);
+            return;
+        }
+
         Dispatcher.UIThread.Post(() =>
         {
-            if (!IsVisible ||
-                _lastStatus == DictationStatus.Idle)
+            if (generation != _entryGeneration || !IsVisible ||
+                _lastStatus is DictationStatus.Idle or DictationStatus.Error)
             {
                 return;
             }
@@ -529,6 +596,13 @@ private void CancelPendingHide()
 
     private void ScheduleHide()
     {
+        CancelPendingHide();
+        if (_reducedMotion)
+        {
+            SetContentVisible(false);
+            Hide();
+            return;
+        }
         var generation = _hideGeneration;
         var hideTimer = new DispatcherTimer
         {
@@ -602,6 +676,7 @@ public void UpdateLevel(DictationStatus status, float level)
     {
         if (Dispatcher.UIThread.CheckAccess())
         {
+            if (!IsVisible || status != _lastStatus) return;
             HudMeter.Level = Math.Clamp(level, 0.0f, 1.0f);
             HudMeter.IsActive = status == DictationStatus.Listening;
             return;
@@ -615,6 +690,7 @@ public void UpdateLevel(DictationStatus status, float level)
                 var lvl = _pendingLevel;
                 var st = _pendingLevelStatus;
                 Interlocked.Exchange(ref _levelUpdatePending, 0);
+                if (!IsVisible || st != _lastStatus) return;
 
                 HudMeter.Level = Math.Clamp(lvl, 0.0f, 1.0f);
                 HudMeter.IsActive = st == DictationStatus.Listening;
@@ -629,13 +705,17 @@ public void UpdateState(DictationState state, float level, string transcript)
 
         void ApplyState()
         {
+            var motionChanged = ApplyMotionPreference(state.Status);
             HudMeter.Level = Math.Clamp(level, 0.0f, 1.0f);
             HudMeter.IsActive = state.Status == DictationStatus.Listening;
+            if (state.Status is not (DictationStatus.Listening or DictationStatus.Finishing))
+                HudMeter.ResetBallistics();
 
             if (state.Status == DictationStatus.Idle)
             {
                 CancelContentReveal();
                 StopProcessingAnimation();
+                _entryGeneration++;
 
                 _lastStatus = DictationStatus.Idle;
                 _lastTranscript = null;
@@ -646,7 +726,7 @@ void ApplyState()
                     GetDouble("HudOrbDiameter", 52),
                     GetDouble("HudArmedHeight", 44),
                     GetCornerRadius("HudOrbRadius", new CornerRadius(26)),
-                    GetBrush("HudHairlineBrush", Brushes.Gray));
+                    GetBrush("HudSpecularHairlineBrush", Brushes.Gray));
                 SetContentTarget(
                     GetDouble("HudArmedWidth", 245),
                     GetDouble("HudArmedHeight", 44));
@@ -674,7 +754,7 @@ void ApplyState()
                            _lastStatus is null ||
                            _lastStatus == DictationStatus.Idle;
 
-            if (!statusChanged && !transcriptChanged && !errorChanged && !entering)
+            if (!statusChanged && !transcriptChanged && !errorChanged && !entering && !motionChanged)
             {
                 return;
             }
@@ -685,9 +765,8 @@ _lastStatus is null ||
 
             var idleLamp = GetBrush("HudIdleLampBrush", Brushes.DarkGray);
             var recordingEdge = GetBrush("HudRecordingEdgeBrush", Brushes.Red);
-            var processingBrush = GetBrush("HudProcessingBrush", Brushes.DodgerBlue);
             var errorBrush = GetBrush("HudErrorBrush", Brushes.DarkOrange);
-            var hairlineBrush = GetBrush("HudHairlineBrush", Brushes.Gray);
+            var hairlineBrush = GetBrush("HudSpecularHairlineBrush", Brushes.Gray);
 
             if (entering)
             {
@@ -732,13 +811,13 @@ _lastStatus is null ||
                         GetDouble("HudRecordingMaxWidth", 416));
 
                     var recordingHeight = GetDouble("HudArmedHeight", 44);
-                    var recordingRadius = GetCornerRadius("HudRadiusRecording", new CornerRadius(26));
+                    var recordingRadius = GetCornerRadius("HudRadiusRecording", new CornerRadius(22));
                     var widthStep = GetDouble("HudTranscriptWidthStep", 12);
 
                     if (_recordingWidth <= 0 || Math.Abs(desiredWidth - _recordingWidth) >= widthStep)
                     {
                         _recordingWidth = desiredWidth;
-                        SetSurfaceTarget(_recordingWidth, recordingHeight, recordingRadius, recordingEdge);
+                        SetSurfaceTarget(_recordingWidth, recordingHeight, recordingRadius, hairlineBrush);
                         SetContentTarget(_recordingWidth, recordingHeight);
                     }
                     break;
@@ -755,22 +834,22 @@ _lastStatus is null ||
                             ? UiText.HudTranscribing
                             : preview);
 
-                    if (statusChanged)
+                    if (statusChanged || entering || motionChanged)
                     {
                         StartProcessingAnimation();
                     }
 
                     SetSurfaceTarget(
                         GetDouble("HudProcessingWidth", 301),
-                        GetDouble("HudProcessingHeight", 38),
+                        GetDouble("HudProcessingHeight", 44),
                         GetCornerRadius(
                             "HudRadiusProcessing",
-                            new CornerRadius(19)),
-                        processingBrush);
+                            new CornerRadius(22)),
+                        hairlineBrush);
 
                     SetContentTarget(
                         GetDouble("HudProcessingWidth", 301),
-                        GetDouble("HudProcessingHeight", 38));
+                        GetDouble("HudProcessingHeight", 44));
 
                     AutomationProperties.SetLiveSetting(
                         TranscriptText,
@@ -779,8 +858,11 @@ _lastStatus is null ||
                     break;
 
                 case DictationStatus.Error:
+                    _entryGeneration++;
                     CancelContentReveal();
                     StopProcessingAnimation();
+                    HudSurface.Opacity = 1;
+                    HudSurface.RenderTransform = TransformScale1;
 
                     _recordingWidth = 0;
                     RecordLamp.Fill = errorBrush;
diff --git a/windows/tests/Murmur.App.Tests/SettingsWindowTests.cs b/windows/tests/Murmur.App.Tests/SettingsWindowTests.cs
index fa86026..0485183 100644
--- a/windows/tests/Murmur.App.Tests/SettingsWindowTests.cs
+++ b/windows/tests/Murmur.App.Tests/SettingsWindowTests.cs
@@ -641,12 +641,13 @@ public void Axaml_ContainsNoGradientsPurpleOrIllegalRed()
 
             if (relativeName.Equals("Styles\\MurmurTokens.axaml", StringComparison.OrdinalIgnoreCase))
             {
-                foreach (var key in new[] { "LensPrimaryBrush", "LensProgressBrush", "LensSpecularBrush" })
+                foreach (var key in new[] { "LensPrimaryBrush", "LensProgressBrush", "LensSpecularBrush", "HudSpecularHairlineBrush" })
                 {
                     content.ShouldContain($"x:Key=\"{key}\"");
                 }
 
-                content.Split("<LinearGradientBrush", StringSplitOptions.None).Length.ShouldBe(7);
+                // Three lens gradients and the studio HUD hairline, each in both themes.
+                content.Split("<LinearGradientBrush", StringSplitOptions.None).Length.ShouldBe(9);
             }
             else
             {
diff --git a/windows/tests/Murmur.App.Tests/StudioHudTests.cs b/windows/tests/Murmur.App.Tests/StudioHudTests.cs
new file mode 100644
index 0000000..9863352
--- /dev/null
+++ b/windows/tests/Murmur.App.Tests/StudioHudTests.cs
@@ -0,0 +1,403 @@
+using System.Reflection;
+using Avalonia;
+using Avalonia.Animation;
+using Avalonia.Controls;
+using Avalonia.Controls.Shapes;
+using Avalonia.Headless;
+using Avalonia.Headless.XUnit;
+using Avalonia.Media;
+using Avalonia.Styling;
+using Avalonia.Threading;
+using Murmur.App.Controls;
+using Murmur.App.Views;
+using Murmur.Core.State;
+using Shouldly;
+
+namespace Murmur.App.Tests;
+
+public class StudioHudTests
+{
+    private static readonly string[] DotNames = ["ProcessingDot1", "ProcessingDot2", "ProcessingDot3"];
+    private static T Part<T>(HudWindow hud, string name) where T : Control => hud.FindControl<T>(name)!;
+
+    private static object? Field(object instance, string name) => instance.GetType()
+        .GetField(name, BindingFlags.Instance | BindingFlags.NonPublic)!.GetValue(instance);
+
+    [AvaloniaFact]
+    public async Task LateLevelUpdates_CannotUndoLatestLifecycleState()
+    {
+        var hud = new HudWindow { IsReducedMotion = () => false };
+        try
+        {
+            hud.UpdateState(DictationState.Listening, .6f, "words");
+            hud.UpdateState(DictationState.ErrorState("lost"), 0, "words");
+            hud.UpdateLevel(DictationStatus.Listening, .9f);
+            var meter = Part<VUMeterControl>(hud, "HudMeter");
+            meter.IsActive.ShouldBeFalse();
+            meter.IsAnimationRunning.ShouldBeFalse();
+            await Task.Run(() => hud.UpdateLevel(DictationStatus.Listening, .9f));
+            Dispatcher.UIThread.RunJobs();
+            meter.IsActive.ShouldBeFalse();
+            meter.IsAnimationRunning.ShouldBeFalse();
+            hud.UpdateState(DictationState.Listening, .8f, "again");
+            hud.UpdateLevel(DictationStatus.Finishing, 0);
+            meter.IsActive.ShouldBeTrue();
+            meter.Level.ShouldBe(.8f);
+            hud.Hide();
+            hud.UpdateLevel(DictationStatus.Listening, .9f);
+            meter.IsAnimationRunning.ShouldBeFalse();
+            meter.CurrentPosition.ShouldBe(0);
+        }
+        finally { hud.Close(); }
+    }
+
+    [AvaloniaFact]
+    public void RapidEntryAndRestart_RetainLatestTextPlacementAndCancelOldHide()
+    {
+        var hud = new HudWindow { IsReducedMotion = () => false };
+        try
+        {
+            hud.SetPlacement("bottom-right");
+            hud.UpdateState(DictationState.Starting, 0, "");
+            hud.UpdateState(DictationState.Listening, .6f, "first");
+            hud.UpdateState(DictationState.Finishing, 0, "first");
+            hud.UpdateState(DictationState.Idle, 0, "");
+            hud.UpdateState(DictationState.Listening, .8f, "latest");
+            Dispatcher.UIThread.RunJobs();
+            hud.IsVisible.ShouldBeTrue();
+            Part<TextBlock>(hud, "TranscriptText").Text.ShouldBe("latest");
+            Part<Panel>(hud, "RecordingRim").Classes.ShouldContain("active");
+            Part<Panel>(hud, "RainbowRim").Classes.ShouldNotContain("active");
+            Part<Border>(hud, "HudSurface").HorizontalAlignment.ShouldBe(Avalonia.Layout.HorizontalAlignment.Right);
+            Part<Border>(hud, "HudContentSurface").VerticalAlignment.ShouldBe(Avalonia.Layout.VerticalAlignment.Bottom);
+            Field(hud, "_hideTimer").ShouldBeNull();
+            Field(hud, "_processingTimer").ShouldBeNull();
+            hud.IsRainbowAnimating.ShouldBeFalse();
+        }
+        finally { hud.Close(); }
+    }
+
+    // Avalonia's clock is internal; drive its real transition engine without wall-clock sleeps.
+    private sealed class ManualClock
+    {
+        private readonly object _clock = Activator.CreateInstance(
+            typeof(Animatable).Assembly.GetType("Avalonia.Animation.Clock")!, nonPublic: true)!;
+        public void Attach(Animatable target) => typeof(Animatable)
+            .GetProperty("Clock", BindingFlags.Instance | BindingFlags.NonPublic)!.SetValue(target, _clock);
+        public void Advance(double seconds) => _clock.GetType().BaseType!
+            .GetMethod("Pulse", BindingFlags.Instance | BindingFlags.NonPublic | BindingFlags.Public)!
+            .Invoke(_clock, [TimeSpan.FromSeconds(seconds)]);
+    }
+
+    [AvaloniaFact]
+    public void RimFade_ReversesFromCurrentOpacityAndErrorAbortsImmediately()
+    {
+        var hud = new HudWindow { IsReducedMotion = () => false };
+        try
+        {
+            hud.UpdateState(DictationState.Starting, 0, "");
+            Dispatcher.UIThread.RunJobs();
+            var recording = Part<Panel>(hud, "RecordingRim");
+            var rainbow = Part<Panel>(hud, "RainbowRim");
+            var clock = new ManualClock();
+            clock.Attach(recording);
+            clock.Attach(rainbow);
+            hud.UpdateState(DictationState.Listening, .5f, "words");
+            clock.Advance(0);
+            clock.Advance(.2);
+            recording.Opacity.ShouldBe(1, .0001);
+            hud.UpdateState(DictationState.Finishing, 0, "words");
+            clock.Advance(.2);
+            clock.Advance(.25);
+            recording.Opacity.ShouldBeInRange(.01, .99);
+            rainbow.Opacity.ShouldBeInRange(.01, .99);
+            (recording.Opacity + rainbow.Opacity).ShouldBe(1, .0001);
+            var recOpacity = recording.Opacity;
+            var rainbowOpacity = rainbow.Opacity;
+            hud.UpdateState(DictationState.Listening, .8f, "again");
+            recording.Opacity.ShouldBe(recOpacity, .0001);
+            rainbow.Opacity.ShouldBe(rainbowOpacity, .0001);
+            clock.Advance(.25);
+            clock.Advance(.45);
+            recording.Opacity.ShouldBe(1, .0001);
+            rainbow.Opacity.ShouldBe(0, .0001);
+            hud.UpdateState(DictationState.Finishing, 0, "again");
+            hud.UpdateState(DictationState.ErrorState("device lost"), 0, "again");
+            Dispatcher.UIThread.RunJobs();
+            recording.Opacity.ShouldBe(0);
+            rainbow.Opacity.ShouldBe(0);
+            hud.IsRainbowAnimating.ShouldBeFalse();
+            Field(hud, "_processingTimer").ShouldBeNull();
+            Field(hud, "_contentRevealTimer").ShouldBeNull();
+            Part<TextBlock>(hud, "TranscriptText").Text!.ShouldContain("device lost");
+            Part<Border>(hud, "HudContentSurface").Opacity.ShouldBeGreaterThan(0);
+        }
+        finally { hud.Close(); }
+    }
+
+    [AvaloniaFact]
+    public void Lifecycle_StopsLoopsOnStartingIdleErrorHiddenAndClose()
+    {
+        foreach (var ending in new[] { "starting", "idle", "error", "hidden", "close" })
+        {
+            var hud = new HudWindow { IsReducedMotion = () => false };
+            try
+            {
+                hud.UpdateState(DictationState.Listening, .8f, "words");
+                Dispatcher.UIThread.RunJobs();
+                var meter = Part<VUMeterControl>(hud, "HudMeter");
+                meter.StepBallistics(.09);
+                var peak = meter.CurrentPosition;
+                hud.UpdateState(DictationState.Finishing, 0, "words");
+                meter.IsActive.ShouldBeFalse();
+                meter.StepBallistics(.4);
+                meter.CurrentPosition.ShouldBeLessThan(peak * .06);
+                Field(hud, "_processingTimer").ShouldBeOfType<DispatcherTimer>().IsEnabled.ShouldBeTrue();
+                hud.IsRainbowAnimating.ShouldBeTrue();
+                switch (ending)
+                {
+                    case "starting": hud.UpdateState(DictationState.Starting, 0, ""); break;
+                    case "idle": hud.UpdateState(DictationState.Idle, 0, ""); break;
+                    case "error": hud.UpdateState(DictationState.ErrorState("failed"), 0, ""); break;
+                    case "hidden": hud.Hide(); break;
+                    case "close": hud.Close(); break;
+                }
+                var angle = ((ConicGradientBrush)Part<Panel>(hud, "RainbowRim").Resources["HudRainbowBrush"]!).Angle;
+                AvaloniaHeadlessPlatform.ForceRenderTimerTick(3);
+                Dispatcher.UIThread.RunJobs();
+                hud.IsRainbowAnimating.ShouldBeFalse();
+                Field(hud, "_rainbowFrameRequested").ShouldBe(false);
+                Field(hud, "_processingTimer").ShouldBeNull();
+                meter.IsAnimationRunning.ShouldBeFalse();
+                meter.CurrentPosition.ShouldBe(0);
+                Part<StackPanel>(hud, "ProcessingDots").IsVisible.ShouldBeFalse();
+                ((ConicGradientBrush)Part<Panel>(hud, "RainbowRim").Resources["HudRainbowBrush"]!).Angle.ShouldBe(angle);
+                if (ending is "error" or "hidden" or "close")
+                {
+                    Field(hud, "_contentRevealTimer").ShouldBeNull();
+                    Field(hud, "_hideTimer").ShouldBeNull();
+                }
+            }
+            finally { hud.Close(); }
+        }
+    }
+
+    [AvaloniaFact]
+    public void MotionPreferenceChange_DuringFinishingStopsDotsRotationAndTransitions()
+    {
+        var reduced = false;
+        var reads = 0;
+        var hud = new HudWindow { IsReducedMotion = () => { reads++; return reduced; } };
+        try
+        {
+            hud.UpdateState(DictationState.Finishing, 0, "words");
+            Dispatcher.UIThread.RunJobs();
+            var initialReads = reads;
+            AvaloniaHeadlessPlatform.ForceRenderTimerTick(3);
+            Dispatcher.UIThread.RunJobs();
+            reads.ShouldBe(initialReads);
+            reduced = true;
+            hud.UpdateState(DictationState.Finishing, 0, "words");
+            AvaloniaHeadlessPlatform.ForceRenderTimerTick(3);
+            Dispatcher.UIThread.RunJobs();
+            var rim = Part<Panel>(hud, "RainbowRim");
+            rim.Opacity.ShouldBe(1);
+            rim.Transitions.ShouldBeNull();
+            hud.IsRainbowAnimating.ShouldBeFalse();
+            Field(hud, "_rainbowFrameRequested").ShouldBe(false);
+            Field(hud, "_processingTimer").ShouldBeNull();
+            Field(hud, "_contentRevealTimer").ShouldBeNull();
+            Part<Border>(hud, "HudContentSurface").Opacity.ShouldBe(1);
+            ((ConicGradientBrush)rim.Resources["HudRainbowBrush"]!).Angle.ShouldBe(-90);
+            reduced = false;
+            hud.UpdateState(DictationState.Finishing, 0, "words");
+            rim.Transitions.ShouldNotBeNull();
+            hud.IsRainbowAnimating.ShouldBeTrue();
+            Field(hud, "_processingTimer").ShouldBeOfType<DispatcherTimer>().IsEnabled.ShouldBeTrue();
+        }
+        finally { hud.Close(); }
+    }
+
+    [AvaloniaFact]
+    public void SettingsMeter_KeepsLegacyBallisticsAndTimerWhileHudReducedMotionSnaps()
+    {
+        var settings = new VUMeterControl { ReducedMotion = true, IsActive = true, Level = .75f };
+        var window = new Window { Content = settings };
+        try
+        {
+            window.Show();
+            settings.IsAnimationRunning.ShouldBeTrue();
+            settings.CurrentPosition.ShouldBe(0);
+            typeof(VUMeterControl).GetMethod("AdvanceNeedle", BindingFlags.NonPublic | BindingFlags.Instance)!.Invoke(settings, null);
+            settings.CurrentPosition.ShouldBe(.288, .000001);
+            settings.HoldRemainingSeconds.ShouldBe(0);
+            var hud = new VUMeterControl { UseHudPalette = true, ReducedMotion = true, IsActive = true, Level = .75f };
+            hud.CurrentPosition.ShouldBe(.75);
+            hud.Level = .25f;
+            hud.CurrentPosition.ShouldBe(.25);
+            hud.HoldRemainingSeconds.ShouldBe(0);
+            hud.IsAnimationRunning.ShouldBeFalse();
+        }
+        finally { window.Close(); }
+    }
+
+    [AvaloniaFact]
+    public void RecordingAndFinishing_ShareHeightRadiusAndRimGeometry()
+    {
+        var hud = new HudWindow { IsReducedMotion = () => true };
+        try
+        {
+            hud.UpdateState(DictationState.Listening, .7f, "words");
+            var surface = Part<Border>(hud, "HudSurface");
+            var radius = surface.CornerRadius;
+            surface.Height.ShouldBe(44);
+            hud.UpdateState(DictationState.Finishing, 0, "words");
+            surface.Height.ShouldBe(44);
+            surface.CornerRadius.ShouldBe(radius);
+            Part<Border>(hud, "HudContentSurface").Height.ShouldBe(44);
+            var recording = Part<Panel>(hud, "RecordingRim");
+            var rainbow = Part<Panel>(hud, "RainbowRim");
+            recording.ShouldNotBeNull();
+            recording.Margin.ShouldBe(rainbow.Margin);
+            recording.Children.OfType<Border>().Select(b => b.BorderThickness)
+                .ShouldBe(rainbow.Children.OfType<Border>().Select(b => b.BorderThickness));
+        }
+        finally { hud.Close(); }
+    }
+
+    [AvaloniaFact]
+    public void ReducedMotion_UsesImmediatePropertiesAndNoMeterDotsOrRimLoops()
+    {
+        var hud = new HudWindow { IsReducedMotion = () => true };
+        try
+        {
+            foreach (var state in new[] { DictationState.Starting, DictationState.Listening, DictationState.Finishing })
+            {
+                hud.UpdateState(state, .75f, "words");
+                Dispatcher.UIThread.RunJobs();
+                var meter = Part<VUMeterControl>(hud, "HudMeter");
+                meter.IsAnimationRunning.ShouldBeFalse();
+                meter.CurrentPosition.ShouldBe(state.Status == DictationStatus.Listening ? .75 : 0);
+                meter.HoldRemainingSeconds.ShouldBe(0);
+                Part<Panel>(hud, "RecordingRim").Opacity.ShouldBe(state.Status == DictationStatus.Listening ? 1 : 0);
+                Part<Panel>(hud, "RainbowRim").Opacity.ShouldBe(state.Status == DictationStatus.Finishing ? 1 : 0);
+                Part<Border>(hud, "HudSurface").Opacity.ShouldBe(1);
+                Part<Border>(hud, "HudContentSurface").Opacity.ShouldBe(1);
+                Part<Border>(hud, "HudSurface").Transitions.ShouldBeNull();
+                Part<Border>(hud, "HudContentSurface").Transitions.ShouldBeNull();
+                Part<TextBlock>(hud, "TranscriptText").Transitions.ShouldBeNull();
+                Part<Panel>(hud, "RecordingRim").Transitions.ShouldBeNull();
+                Part<Panel>(hud, "RainbowRim").Transitions.ShouldBeNull();
+                Field(hud, "_processingTimer").ShouldBeNull();
+                Field(hud, "_contentRevealTimer").ShouldBeNull();
+                Field(hud, "_rainbowFrameRequested").ShouldBe(false);
+            }
+            var brush = (ConicGradientBrush)Part<Panel>(hud, "RainbowRim").Resources["HudRainbowBrush"]!;
+            var dots = DotNames
+                .Select(name => Part<Ellipse>(hud, name)).ToArray();
+            var opacities = dots.Select(d => d.Opacity).ToArray();
+            AvaloniaHeadlessPlatform.ForceRenderTimerTick(5);
+            Dispatcher.UIThread.RunJobs();
+            brush.Angle.ShouldBe(-90);
+            dots.Select(d => d.Opacity).ShouldBe(opacities);
+            hud.UpdateState(DictationState.Idle, 0, "");
+            hud.IsVisible.ShouldBeFalse();
+            Field(hud, "_hideTimer").ShouldBeNull();
+        }
+        finally { hud.Close(); }
+    }
+
+    [AvaloniaFact]
+    public void HudBallistics_AttackHoldReleaseAreMonotoneAndTimeStepIndependent()
+    {
+        var meter = new VUMeterControl { UseHudPalette = true, IsActive = true, Level = .8f };
+        meter.StepBallistics(.09);
+        meter.CurrentPosition.ShouldBeInRange(.75, .8);
+        var peak = meter.CurrentPosition;
+        meter.Level = 0;
+        meter.StepBallistics(.10);
+        meter.CurrentPosition.ShouldBe(peak);
+        meter.HoldRemainingSeconds.ShouldBe(.08, .000001);
+        var split = new VUMeterControl { UseHudPalette = true, IsActive = true, Level = .8f };
+        split.StepBallistics(.09);
+        split.Level = 0;
+        split.StepBallistics(.18);
+        split.StepBallistics(.02);
+        meter.StepBallistics(.10);
+        meter.CurrentPosition.ShouldBe(split.CurrentPosition, .000001);
+        var previous = meter.CurrentPosition;
+        for (var i = 0; i < 100; i++)
+        {
+            meter.StepBallistics(.016);
+            meter.CurrentPosition.ShouldBeInRange(0, previous);
+            previous = meter.CurrentPosition;
+        }
+        meter.CurrentPosition.ShouldBe(0);
+    }
+
+    [AvaloniaFact]
+    public void HudBallistics_NewPeakInterruptsHoldAndInactiveReleasesWithoutSecondHold()
+    {
+        var meter = new VUMeterControl { UseHudPalette = true, IsActive = true, Level = .6f };
+        meter.StepBallistics(.09);
+        meter.Level = 0;
+        meter.StepBallistics(.05);
+        var held = meter.CurrentPosition;
+        meter.Level = 1;
+        meter.StepBallistics(.03);
+        meter.CurrentPosition.ShouldBeGreaterThan(held);
+        var peak = meter.CurrentPosition;
+        meter.IsActive = false;
+        meter.StepBallistics(.4);
+        meter.CurrentPosition.ShouldBeLessThan(peak * .06);
+        meter.HoldRemainingSeconds.ShouldBe(0);
+        meter.StepBallistics(double.NaN);
+        meter.StepBallistics(-1);
+        double.IsFinite(meter.CurrentPosition).ShouldBeTrue();
+    }
+
+    [AvaloniaFact]
+    public void StudioTheme_ReusesRecordRedAndPreservesAmberError()
+    {
+        foreach (var theme in new[] { ThemeVariant.Dark, ThemeVariant.Light })
+        {
+            var hud = new HudWindow { RequestedThemeVariant = theme, IsReducedMotion = () => true };
+            try
+            {
+                hud.UpdateState(DictationState.Listening, .5f, "words");
+                var lamp = Part<Ellipse>(hud, "RecordLamp");
+                lamp.Parent.ShouldBeOfType<Border>().BorderThickness.Left.ShouldBeGreaterThan(0);
+                var rim = Part<Panel>(hud, "RecordingRim");
+                rim.Children.OfType<Border>().Last().BorderBrush.ShouldBe(lamp.Fill);
+                hud.TryFindResource("HudSpecularHairlineBrush", theme, out var edge).ShouldBeTrue();
+                Part<Border>(hud, "HudSurface").BorderBrush.ShouldBe(edge);
+                var gradient = edge.ShouldBeAssignableTo<ILinearGradientBrush>();
+                gradient!.GradientStops![0].Color.A.ShouldBeGreaterThan(gradient.GradientStops[^1].Color.A);
+                hud.TryFindResource("HudSolidFallbackBrush", theme, out var fallback).ShouldBeTrue();
+                var background = fallback.ShouldBeAssignableTo<ISolidColorBrush>()!.Color;
+                var foreground = Part<TextBlock>(hud, "TranscriptText").Foreground.ShouldBeAssignableTo<ISolidColorBrush>()!.Color;
+                var bg = Luminance(background);
+                var fg = Luminance(foreground);
+                ((Math.Max(bg, fg) + .05) / (Math.Min(bg, fg) + .05)).ShouldBeGreaterThan(4.5);
+                hud.UpdateState(DictationState.Finishing, 0, "words");
+                Part<Border>(hud, "HudSurface").BorderBrush.ShouldBe(edge);
+                hud.UpdateState(DictationState.ErrorState("device lost"), 0, "words");
+                hud.TryFindResource("HudErrorBrush", theme, out var amber).ShouldBeTrue();
+                Part<Border>(hud, "HudSurface").BorderBrush.ShouldBe(amber);
+                lamp.Fill.ShouldBe(amber);
+                Part<Panel>(hud, "RainbowRim").Opacity.ShouldBe(0);
+            }
+            finally { hud.Close(); }
+        }
+    }
+
+    private static double Luminance(Color color)
+    {
+        static double Linear(byte channel)
+        {
+            var value = channel / 255.0;
+            return value <= .04045 ? value / 12.92 : Math.Pow((value + .055) / 1.055, 2.4);
+        }
+        return .2126 * Linear(color.R) + .7152 * Linear(color.G) + .0722 * Linear(color.B);
+    }
+}

From 7cbf59c5a739d4ec22415d41a51e11e8371947e0 Mon Sep 17 00:00:00 2001
From: devjenjen <devjenjen@gmail.com>
Date: Mon, 26 Oct 2026 21:02:53 +0100
Subject: [PATCH 3/9] feat(hud): pulse recording rim and sharpen meter response

---
 .../src/Murmur.App/Controls/VUMeterControl.cs |  6 +-
 .../src/Murmur.App/Styles/MurmurTokens.axaml  |  4 +-
 windows/src/Murmur.App/Views/HudWindow.axaml  | 11 +--
 .../src/Murmur.App/Views/HudWindow.axaml.cs   | 55 ++++++++---
 .../tests/Murmur.App.Tests/StudioHudTests.cs  | 99 +++++++++++++++++--
 5 files changed, 143 insertions(+), 32 deletions(-)

diff --git a/windows/src/Murmur.App/Controls/VUMeterControl.cs b/windows/src/Murmur.App/Controls/VUMeterControl.cs
index 3f501bd..12e749d 100644
--- a/windows/src/Murmur.App/Controls/VUMeterControl.cs
+++ b/windows/src/Murmur.App/Controls/VUMeterControl.cs
@@ -355,7 +355,7 @@ internal void StepBallistics(double dtSeconds)
         var rising = target >= _position;
         if (rising)
         {
-            _holdRemaining = .180;
+            _holdRemaining = .040;
         }
         else
         {
@@ -365,8 +365,8 @@ internal void StepBallistics(double dtSeconds)
             dtSeconds -= heldTime;
         }
 
-        // Exact exponential response: 95% in 90/400ms, monotone even after a delayed frame.
-        _position = target + (_position - target) * Math.Exp(-3 * dtSeconds / (rising ? .090 : .400));
+        // The controller already smooths input; keep the HUD's extra response short and monotone.
+        _position = target + (_position - target) * Math.Exp(-3 * dtSeconds / (rising ? .035 : .160));
         if (Math.Abs(target - _position) < .001)
         {
             _position = target;
diff --git a/windows/src/Murmur.App/Styles/MurmurTokens.axaml b/windows/src/Murmur.App/Styles/MurmurTokens.axaml
index 5ec6fd6..7e02336 100644
--- a/windows/src/Murmur.App/Styles/MurmurTokens.axaml
+++ b/windows/src/Murmur.App/Styles/MurmurTokens.axaml
@@ -86,7 +86,7 @@
                     <SolidColorBrush x:Key="HudChassisBrush" Color="#551C1C1E" />
                     <SolidColorBrush x:Key="HudSolidFallbackBrush" Color="#FF1C1C1E" />
                     <SolidColorBrush x:Key="HudHairlineBrush" Color="#40FFFFFF" />
-                    <SolidColorBrush x:Key="HudRecordingEdgeBrush" Color="{StaticResource RecordLampColor}" />
+                    <SolidColorBrush x:Key="HudRecordingEdgeBrush" Color="#FFFF453A" />
                     <LinearGradientBrush x:Key="HudSpecularHairlineBrush" StartPoint="50%,0%" EndPoint="50%,100%">
                         <GradientStop Offset="0" Color="#38E4DED0" />
                         <GradientStop Offset="0.3" Color="#20FFFFFF" />
@@ -214,7 +214,7 @@
                     <SolidColorBrush x:Key="HudChassisBrush" Color="#55FAFAFC" />
                     <SolidColorBrush x:Key="HudSolidFallbackBrush" Color="#FFFAFAFC" />
                     <SolidColorBrush x:Key="HudHairlineBrush" Color="#40000000" />
-                    <SolidColorBrush x:Key="HudRecordingEdgeBrush" Color="{StaticResource RecordLampColor}" />
+                    <SolidColorBrush x:Key="HudRecordingEdgeBrush" Color="#FFD32F2F" />
                     <LinearGradientBrush x:Key="HudSpecularHairlineBrush" StartPoint="50%,0%" EndPoint="50%,100%">
                         <GradientStop Offset="0" Color="#40000000" />
                         <GradientStop Offset="0.4" Color="#18000000" />
diff --git a/windows/src/Murmur.App/Views/HudWindow.axaml b/windows/src/Murmur.App/Views/HudWindow.axaml
index c4e1d5d..dc01594 100644
--- a/windows/src/Murmur.App/Views/HudWindow.axaml
+++ b/windows/src/Murmur.App/Views/HudWindow.axaml
@@ -33,14 +33,13 @@
                        Classes="hudRecordingRim"
                        Margin="-1"
                        IsHitTestVisible="False">
-                    <Border CornerRadius="{Binding #HudSurface.CornerRadius}"
+                    <Border x:Name="RecordingWash" CornerRadius="{Binding #HudSurface.CornerRadius}"
                             BorderThickness="4"
-                            BorderBrush="{DynamicResource RecordLampBrush}"
-                            Opacity="0.12" />
-                    <Border CornerRadius="{Binding #HudSurface.CornerRadius}"
+                            BorderBrush="{DynamicResource HudRecordingEdgeBrush}"
+                            Opacity="0.30" />
+                    <Border x:Name="RecordingStroke" CornerRadius="{Binding #HudSurface.CornerRadius}"
                             BorderThickness="1.5"
-                            BorderBrush="{DynamicResource RecordLampBrush}"
-                            Opacity="0.65" />
+                            BorderBrush="{DynamicResource HudRecordingEdgeBrush}" />
                 </Panel>
                 <!-- Rainbow rim shown only while transcribing (Finishing). Margin cancels
                      HudBorderThickness so the stroke traces the outer pill silhouette, which
diff --git a/windows/src/Murmur.App/Views/HudWindow.axaml.cs b/windows/src/Murmur.App/Views/HudWindow.axaml.cs
index 691707c..d3d2d5e 100644
--- a/windows/src/Murmur.App/Views/HudWindow.axaml.cs
+++ b/windows/src/Murmur.App/Views/HudWindow.axaml.cs
@@ -42,7 +42,9 @@ public partial class HudWindow : Window
     private DictationStatus _pendingLevelStatus;
     private readonly ConicGradientBrush _rainbowBrush;
     private bool _rainbowAnimating;
-    private bool _rainbowFrameRequested;
+    private bool _rimFrameRequested;
+    private bool _recordingAnimating;
+    private TimeSpan? _recordingPulseStart;
     private bool _reducedMotion;
     private int _entryGeneration;
 
@@ -127,6 +129,8 @@ protected override void OnPropertyChanged(AvaloniaPropertyChangedEventArgs chang
 
     private void StopHiddenEffects()
     {
+        _recordingAnimating = false;
+        _recordingPulseStart = null;
         _entryGeneration++;
         CancelContentReveal();
         CancelPendingHide();
@@ -162,6 +166,18 @@ private bool ApplyMotionPreference(DictationStatus status)
         RecordingRim.Classes.Set("motionOff", instantRims);
         RainbowRim.Classes.Set("motionOff", instantRims);
         RecordingRim.Classes.Set("active", status == DictationStatus.Listening);
+        var pulse = status == DictationStatus.Listening && !reduced;
+        if (_recordingAnimating != pulse) _recordingPulseStart = null;
+        _recordingAnimating = pulse;
+        if (pulse)
+        {
+            RequestRimFrame();
+        }
+        else if (status != DictationStatus.Finishing || reduced)
+        {
+            RecordingStroke.Opacity = 1;
+            RecordingWash.Opacity = .30;
+        }
         return changed;
     }
 
@@ -443,7 +459,7 @@ private void StartRainbowRim()
         _rainbowAnimating = !_reducedMotion;
         if (_rainbowAnimating)
         {
-            RequestRainbowFrame();
+            RequestRimFrame();
         }
         else
         {
@@ -458,24 +474,39 @@ private void StopRainbowRim()
         RainbowRim.Classes.Set("active", false);
     }
 
-    private void RequestRainbowFrame()
+    private void RequestRimFrame()
     {
-        if (_rainbowFrameRequested) return;
-        _rainbowFrameRequested = true;
-        RequestAnimationFrame(OnRainbowFrame);
+        if (_rimFrameRequested) return;
+        _rimFrameRequested = true;
+        RequestAnimationFrame(OnRimFrame);
     }
 
-    private void OnRainbowFrame(TimeSpan time)
+    private void OnRimFrame(TimeSpan time)
     {
-        _rainbowFrameRequested = false;
-        if (!_rainbowAnimating || !IsVisible)
+        _rimFrameRequested = false;
+        if (!IsVisible || (!_rainbowAnimating && !_recordingAnimating))
         {
             _rainbowAnimating = false;
+            _recordingAnimating = false;
             return;
         }
 
-        _rainbowBrush.Angle = RainbowRestAngle + (time.TotalSeconds * RainbowDegreesPerSecond % 360);
-        RequestRainbowFrame();
+        AdvanceRimVisuals(time);
+        RequestRimFrame();
+    }
+
+    internal void AdvanceRimVisuals(TimeSpan time)
+    {
+        if (_recordingAnimating)
+        {
+            _recordingPulseStart ??= time;
+            var phase = (time - _recordingPulseStart.Value).TotalSeconds / 1.2;
+            var light = (1 + Math.Cos(phase * 2 * Math.PI)) / 2;
+            RecordingStroke.Opacity = .55 + .45 * light;
+            RecordingWash.Opacity = .12 + .18 * light;
+        }
+        if (_rainbowAnimating)
+            _rainbowBrush.Angle = RainbowRestAngle + (time.TotalSeconds * RainbowDegreesPerSecond % 360);
     }
 
     private static bool ReadSystemReducedMotion()
@@ -792,7 +823,7 @@ _lastStatus is null ||
 
                 case DictationStatus.Listening:
                     StopProcessingAnimation();
-                    RecordLamp.Fill = GetBrush("RecordLampBrush", recordingEdge);
+                    RecordLamp.Fill = recordingEdge;
                     TelemetryBadge.Text = UiText.Text("HudRecording");
                     var preview = BuildTranscriptTail(transcript, 15);
                     UpdateTranscriptText(string.IsNullOrEmpty(preview) ? UiText.HudListening : preview);
diff --git a/windows/tests/Murmur.App.Tests/StudioHudTests.cs b/windows/tests/Murmur.App.Tests/StudioHudTests.cs
index 9863352..5f72848 100644
--- a/windows/tests/Murmur.App.Tests/StudioHudTests.cs
+++ b/windows/tests/Murmur.App.Tests/StudioHudTests.cs
@@ -23,6 +23,72 @@ public class StudioHudTests
     private static object? Field(object instance, string name) => instance.GetType()
         .GetField(name, BindingFlags.Instance | BindingFlags.NonPublic)!.GetValue(instance);
 
+    [AvaloniaFact]
+    public void RecordingPulse_BrightDimBrightWithoutRestartingOnTranscriptUpdates()
+    {
+        var hud = new HudWindow { RequestedThemeVariant = ThemeVariant.Dark, IsReducedMotion = () => false };
+        try
+        {
+            hud.UpdateState(DictationState.Listening, .5f, "first");
+            var stroke = Part<Border>(hud, "RecordingStroke");
+            stroke.ShouldNotBeNull();
+            hud.AdvanceRimVisuals(TimeSpan.Zero);
+            stroke.Opacity.ShouldBe(1);
+            hud.AdvanceRimVisuals(TimeSpan.FromSeconds(.6));
+            stroke.Opacity.ShouldBe(.55, .0001);
+            hud.UpdateState(DictationState.Listening, .5f, "next words");
+            hud.AdvanceRimVisuals(TimeSpan.FromSeconds(.6));
+            stroke.Opacity.ShouldBe(.55, .0001);
+            hud.AdvanceRimVisuals(TimeSpan.FromSeconds(1.2));
+            stroke.Opacity.ShouldBe(1, .0001);
+            Field(hud, "_recordingAnimating").ShouldBe(true);
+            hud.IsRainbowAnimating.ShouldBeFalse();
+            var red = stroke.BorderBrush.ShouldBeAssignableTo<ISolidColorBrush>()!;
+            red.Color.R.ShouldBeGreaterThan((byte)230);
+        }
+        finally { hud.Close(); }
+    }
+
+    [AvaloniaFact]
+    public void RecordingPulse_StopsOnLifecycleChangesAndReducedMotion()
+    {
+        foreach (var ending in new[] { "starting", "finishing", "idle", "error", "hidden", "close", "reduced" })
+        {
+            var reduced = false;
+            var hud = new HudWindow { IsReducedMotion = () => reduced };
+            try
+            {
+                hud.UpdateState(DictationState.Listening, .5f, "words");
+                hud.AdvanceRimVisuals(TimeSpan.Zero);
+                hud.AdvanceRimVisuals(TimeSpan.FromSeconds(.6));
+                switch (ending)
+                {
+                    case "starting": hud.UpdateState(DictationState.Starting, 0, ""); break;
+                    case "finishing": hud.UpdateState(DictationState.Finishing, 0, "words"); break;
+                    case "idle": hud.UpdateState(DictationState.Idle, 0, ""); break;
+                    case "error": hud.UpdateState(DictationState.ErrorState("lost"), 0, ""); break;
+                    case "hidden": hud.Hide(); break;
+                    case "close": hud.Close(); break;
+                    case "reduced": reduced = true; hud.UpdateState(DictationState.Listening, .5f, "words"); break;
+                }
+                Field(hud, "_recordingAnimating").ShouldBe(false);
+                var stroke = Part<Border>(hud, "RecordingStroke");
+                var opacity = stroke.Opacity;
+                hud.AdvanceRimVisuals(TimeSpan.FromSeconds(1.2));
+                stroke.Opacity.ShouldBe(opacity);
+                AvaloniaHeadlessPlatform.ForceRenderTimerTick(3);
+                Dispatcher.UIThread.RunJobs();
+                if (ending != "finishing") Field(hud, "_rimFrameRequested").ShouldBe(false);
+                if (reduced)
+                {
+                    stroke.Opacity.ShouldBe(1);
+                    Part<VUMeterControl>(hud, "HudMeter").IsAnimationRunning.ShouldBeFalse();
+                }
+            }
+            finally { hud.Close(); }
+        }
+    }
+
     [AvaloniaFact]
     public async Task LateLevelUpdates_CannotUndoLatestLifecycleState()
     {
@@ -166,7 +232,7 @@ public void Lifecycle_StopsLoopsOnStartingIdleErrorHiddenAndClose()
                 AvaloniaHeadlessPlatform.ForceRenderTimerTick(3);
                 Dispatcher.UIThread.RunJobs();
                 hud.IsRainbowAnimating.ShouldBeFalse();
-                Field(hud, "_rainbowFrameRequested").ShouldBe(false);
+                Field(hud, "_rimFrameRequested").ShouldBe(false);
                 Field(hud, "_processingTimer").ShouldBeNull();
                 meter.IsAnimationRunning.ShouldBeFalse();
                 meter.CurrentPosition.ShouldBe(0);
@@ -204,7 +270,7 @@ public void MotionPreferenceChange_DuringFinishingStopsDotsRotationAndTransition
             rim.Opacity.ShouldBe(1);
             rim.Transitions.ShouldBeNull();
             hud.IsRainbowAnimating.ShouldBeFalse();
-            Field(hud, "_rainbowFrameRequested").ShouldBe(false);
+            Field(hud, "_rimFrameRequested").ShouldBe(false);
             Field(hud, "_processingTimer").ShouldBeNull();
             Field(hud, "_contentRevealTimer").ShouldBeNull();
             Part<Border>(hud, "HudContentSurface").Opacity.ShouldBe(1);
@@ -290,7 +356,7 @@ public void ReducedMotion_UsesImmediatePropertiesAndNoMeterDotsOrRimLoops()
                 Part<Panel>(hud, "RainbowRim").Transitions.ShouldBeNull();
                 Field(hud, "_processingTimer").ShouldBeNull();
                 Field(hud, "_contentRevealTimer").ShouldBeNull();
-                Field(hud, "_rainbowFrameRequested").ShouldBe(false);
+                Field(hud, "_rimFrameRequested").ShouldBe(false);
             }
             var brush = (ConicGradientBrush)Part<Panel>(hud, "RainbowRim").Resources["HudRainbowBrush"]!;
             var dots = DotNames
@@ -311,19 +377,19 @@ public void ReducedMotion_UsesImmediatePropertiesAndNoMeterDotsOrRimLoops()
     public void HudBallistics_AttackHoldReleaseAreMonotoneAndTimeStepIndependent()
     {
         var meter = new VUMeterControl { UseHudPalette = true, IsActive = true, Level = .8f };
-        meter.StepBallistics(.09);
+        meter.StepBallistics(.035);
         meter.CurrentPosition.ShouldBeInRange(.75, .8);
         var peak = meter.CurrentPosition;
         meter.Level = 0;
-        meter.StepBallistics(.10);
+        meter.StepBallistics(.020);
         meter.CurrentPosition.ShouldBe(peak);
-        meter.HoldRemainingSeconds.ShouldBe(.08, .000001);
+        meter.HoldRemainingSeconds.ShouldBe(.020, .000001);
         var split = new VUMeterControl { UseHudPalette = true, IsActive = true, Level = .8f };
-        split.StepBallistics(.09);
+        split.StepBallistics(.035);
         split.Level = 0;
-        split.StepBallistics(.18);
+        split.StepBallistics(.040);
         split.StepBallistics(.02);
-        meter.StepBallistics(.10);
+        meter.StepBallistics(.040);
         meter.CurrentPosition.ShouldBe(split.CurrentPosition, .000001);
         var previous = meter.CurrentPosition;
         for (var i = 0; i < 100; i++)
@@ -335,6 +401,21 @@ public void HudBallistics_AttackHoldReleaseAreMonotoneAndTimeStepIndependent()
         meter.CurrentPosition.ShouldBe(0);
     }
 
+    [AvaloniaFact]
+    public void HudBallistics_FollowsShortSyllablesInsteadOfHoldingOldPeak()
+    {
+        var meter = new VUMeterControl { UseHudPalette = true, IsActive = true };
+        for (var syllable = 0; syllable < 3; syllable++)
+        {
+            meter.Level = .8f;
+            meter.StepBallistics(.035);
+            meter.CurrentPosition.ShouldBeGreaterThan(.75);
+            meter.Level = 0;
+            meter.StepBallistics(.160);
+            meter.CurrentPosition.ShouldBeLessThan(.09);
+        }
+    }
+
     [AvaloniaFact]
     public void HudBallistics_NewPeakInterruptsHoldAndInactiveReleasesWithoutSecondHold()
     {

From b9e6c8271f545452d78810f47fcce66bf669e5c7 Mon Sep 17 00:00:00 2001
From: devjenjen <devjenjen@gmail.com>
Date: Tue, 27 Oct 2026 01:46:28 +0100
Subject: [PATCH 4/9] fix(speech): preserve originals at repair token and
 context limits

---
 .../src/Murmur.Core/DictationController.cs    |   3 +-
 .../Murmur.Speech/LlamaSharpSpeechRepairer.cs | 129 ++++++++++--------
 .../DictationControllerTests.cs               |  44 ++++++
 .../SpeechRepairBudgetTests.cs                | 113 +++++++++++++++
 4 files changed, 233 insertions(+), 56 deletions(-)
 create mode 100644 windows/tests/Murmur.Speech.Tests/SpeechRepairBudgetTests.cs

diff --git a/windows/src/Murmur.Core/DictationController.cs b/windows/src/Murmur.Core/DictationController.cs
index 687d869..e7266f7 100644
--- a/windows/src/Murmur.Core/DictationController.cs
+++ b/windows/src/Murmur.Core/DictationController.cs
@@ -348,12 +348,13 @@ private async Task FinishSessionAsync(ActiveSessionState session, CancellationTo
                 try
                 {
                     var repairResult = await repairer.RepairAsync(raw, cancellationToken).ConfigureAwait(false);
+                    cancellationToken.ThrowIfCancellationRequested();
                     if (!string.IsNullOrWhiteSpace(repairResult))
                     {
                         repaired = repairResult;
                     }
                 }
-                catch (OperationCanceledException) when (cancellationToken.IsCancellationRequested)
+                catch (OperationCanceledException)
                 {
                     throw;
                 }
diff --git a/windows/src/Murmur.Speech/LlamaSharpSpeechRepairer.cs b/windows/src/Murmur.Speech/LlamaSharpSpeechRepairer.cs
index 262f60e..c227a83 100644
--- a/windows/src/Murmur.Speech/LlamaSharpSpeechRepairer.cs
+++ b/windows/src/Murmur.Speech/LlamaSharpSpeechRepairer.cs
@@ -25,6 +25,11 @@ public sealed class LlamaSharpSpeechRepairer : ISpeechRepairer, IDisposable
     private readonly string? _modelPath;
     private readonly ISpeechRepairer _fallback;
     private readonly object _lock = new();
+    private readonly SemaphoreSlim _inferenceGate = new(1, 1);
+    private readonly Func<string, int>? _tokenize;
+    private readonly Func<string, int, CancellationToken, IAsyncEnumerable<string>>? _infer;
+    private const int ContextTokens = 2048;
+    private const int ContextMargin = 16;
 
     private LLamaWeights? _weights;
     private StatelessExecutor? _executor;
@@ -42,60 +47,73 @@ public LlamaSharpSpeechRepairer(string? modelPath = null, ISpeechRepairer? fallb
         _fallback = fallback ?? new RuleBasedSpeechRepairer();
     }
 
-    /// <inheritdoc />
-    public async Task<string> RepairAsync(string rawTranscript, CancellationToken cancellationToken = default)
+    internal LlamaSharpSpeechRepairer(Func<string, int> tokenize,
+        Func<string, int, CancellationToken, IAsyncEnumerable<string>> infer)
+        : this()
     {
-        if (string.IsNullOrEmpty(rawTranscript))
-        {
-            return rawTranscript;
-        }
-
-        if (string.IsNullOrWhiteSpace(rawTranscript))
-        {
-            return rawTranscript;
-        }
+        _tokenize = tokenize;
+        _infer = infer;
+    }
 
-        if (_isDisposed || !EnsureLoaded() || _executor == null)
-        {
-            return await _fallback.RepairAsync(rawTranscript, cancellationToken).ConfigureAwait(false);
-        }
+    private static string CheckedResult(string result, CancellationToken cancellationToken)
+    {
+        cancellationToken.ThrowIfCancellationRequested();
+        return result;
+    }
 
+    /// <inheritdoc />
+    public async Task<string> RepairAsync(string rawTranscript, CancellationToken cancellationToken = default)
+    {
+        cancellationToken.ThrowIfCancellationRequested();
+        if (string.IsNullOrWhiteSpace(rawTranscript)) return CheckedResult(rawTranscript, cancellationToken);
+        await _inferenceGate.WaitAsync(cancellationToken).ConfigureAwait(false);
         try
         {
-            var prompt = FormatChatPrompt(DefaultSystemPrompt, rawTranscript);
-
-            var inferenceParams = new InferenceParams
-            {
-                MaxTokens = 256,
-                AntiPrompts = new[] { "<|im_end|>", "<|im_start|>", "\n<|im_start|>" },
-                SamplingPipeline = new DefaultSamplingPipeline
-                {
-                    Temperature = 0.0f
-                }
-            };
-
-            var sb = new StringBuilder();
-            await foreach (var token in _executor.InferAsync(prompt, inferenceParams, cancellationToken).ConfigureAwait(false))
+            if (_isDisposed || (_infer == null && (!EnsureLoaded() || _executor == null)))
             {
-                sb.Append(token);
+                cancellationToken.ThrowIfCancellationRequested();
+                var fallback = await _fallback.RepairAsync(rawTranscript, cancellationToken).ConfigureAwait(false);
+                return CheckedResult(fallback, cancellationToken);
             }
 
-            var result = CleanOutput(sb.ToString());
-            if (string.IsNullOrWhiteSpace(result))
+            try
             {
-                return await _fallback.RepairAsync(rawTranscript, cancellationToken).ConfigureAwait(false);
+                var prompt = FormatChatPrompt(DefaultSystemPrompt, rawTranscript);
+                // Match StatelessExecutor 0.22 exactly: our ChatML is already formatted, BOS/special enabled.
+                int Count(string text) => _tokenize != null ? _tokenize(text)
+                    : _weights!.Tokenize(text, true, true, Encoding.UTF8).Length;
+                var promptTokens = Count(prompt);
+                var rawTokens = Count(rawTranscript);
+                var reserve = Math.Max(256L, 2L * rawTokens + 64);
+                var context = _executor?.Context.ContextSize ?? ContextTokens;
+                if (promptTokens < 0 || rawTokens < 0 || promptTokens + reserve + ContextMargin > context)
+                    return CheckedResult(rawTranscript, cancellationToken);
+                var maximum = (int)reserve;
+                cancellationToken.ThrowIfCancellationRequested();
+                var chunks = _infer != null ? _infer(prompt, maximum, cancellationToken)
+                    : _executor!.InferAsync(prompt, new InferenceParams
+                    {
+                        MaxTokens = maximum,
+                        AntiPrompts = ["<|im_end|>", "<|im_start|>", "\n<|im_start|>"],
+                        SamplingPipeline = new DefaultSamplingPipeline { Temperature = 0.0f }
+                    }, cancellationToken);
+                var output = new StringBuilder();
+                var yielded = 0;
+                await foreach (var chunk in chunks.ConfigureAwait(false))
+                {
+                    cancellationToken.ThrowIfCancellationRequested();
+                    // Only the pinned StatelessExecutor yields once per non-EOS token, including empty UTF8 chunks.
+                    if (++yielded >= maximum) return CheckedResult(rawTranscript, cancellationToken);
+                    output.Append(chunk);
+                }
+                cancellationToken.ThrowIfCancellationRequested();
+                var result = CleanOutput(output.ToString());
+                return CheckedResult(string.IsNullOrWhiteSpace(result) ? rawTranscript : result, cancellationToken);
             }
-
-            return result;
-        }
-        catch (OperationCanceledException)
-        {
-            throw;
-        }
-        catch (Exception)
-        {
-            return await _fallback.RepairAsync(rawTranscript, cancellationToken).ConfigureAwait(false);
+            catch (OperationCanceledException) { throw; }
+            catch (Exception) { return CheckedResult(rawTranscript, cancellationToken); }
         }
+        finally { _inferenceGate.Release(); }
     }
 
     private bool EnsureLoaded()
@@ -123,12 +141,12 @@ private bool EnsureLoaded()
             {
                 var parameters = new ModelParams(_modelPath)
                 {
-                    ContextSize = 1024,
+                    ContextSize = ContextTokens,
                     GpuLayerCount = 0
                 };
 
                 _weights = LLamaWeights.LoadFromFile(parameters);
-                _executor = new StatelessExecutor(_weights, parameters);
+                _executor = new StatelessExecutor(_weights, parameters) { ApplyTemplate = false };
                 return true;
             }
             catch (Exception)
@@ -182,17 +200,18 @@ internal static string CleanOutput(string output)
     /// <inheritdoc />
     public void Dispose()
     {
-        if (_isDisposed)
-        {
-            return;
-        }
-
-        lock (_lock)
+        _inferenceGate.Wait();
+        try
         {
-            _isDisposed = true;
-            _executor = null;
-            _weights?.Dispose();
-            _weights = null;
+            lock (_lock)
+            {
+                if (_isDisposed) return;
+                _isDisposed = true;
+                _executor = null;
+                _weights?.Dispose();
+                _weights = null;
+            }
         }
+        finally { _inferenceGate.Release(); }
     }
 }
diff --git a/windows/tests/Murmur.Core.Tests/DictationControllerTests.cs b/windows/tests/Murmur.Core.Tests/DictationControllerTests.cs
index 44a91b4..bf39727 100644
--- a/windows/tests/Murmur.Core.Tests/DictationControllerTests.cs
+++ b/windows/tests/Murmur.Core.Tests/DictationControllerTests.cs
@@ -10,6 +10,50 @@ namespace Murmur.Core.Tests;
 
 public class DictationControllerTests
 {
+    [Fact]
+    public async Task RepairCancellationCannotInsertEvenWhenRepairerReturnsLateText()
+    {
+        var audio = new FakeAudioCapture();
+        var hotkey = new FakeHotkeySource();
+        var injector = new FakeTextInjector();
+        var cancelled = new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously);
+        DictationController? controller = null;
+        Task? stopped = null;
+        var repairer = new FakeSpeechRepairer(_ =>
+        {
+            stopped = controller!.StopAsync();
+            cancelled.TrySetResult();
+            return "late repair";
+        });
+        await using var owner = controller = new DictationController(audio, hotkey,
+            new FakeTranscriber("original speech"), injector, "fake", speechRepairer: repairer);
+        owner.Start();
+        hotkey.Press();
+        audio.EmitChunk(new float[160]);
+        hotkey.Release();
+        await cancelled.Task.WaitAsync(TimeSpan.FromSeconds(5));
+        await stopped!.WaitAsync(TimeSpan.FromSeconds(5));
+        injector.Injected.ShouldBeEmpty();
+    }
+
+    [Fact]
+    public async Task RepairMayLegitimatelyRemoveLongFalseStartWithoutLengthHeuristic()
+    {
+        var audio = new FakeAudioCapture();
+        var hotkey = new FakeHotkeySource();
+        var injector = new FakeTextInjector();
+        using var controller = new DictationController(audio, hotkey,
+            new FakeTranscriber(new string('x', 1200)), injector, "fake",
+            speechRepairer: new FakeSpeechRepairer(_ => "Mittwoch"));
+        controller.Start();
+        hotkey.Press();
+        audio.EmitChunk(new float[160]);
+        hotkey.Release();
+        await WaitForStatusAsync(controller, DictationStatus.Idle);
+        injector.Injected.Single().ShouldBe("Mittwoch.");
+        injector.InjectionMetadata.Single().Target.ShouldBe(injector.CapturedTarget);
+    }
+
     private static async Task WaitForStatusAsync(DictationController controller, DictationStatus status)
     {
         if (controller.State.Status == status)
diff --git a/windows/tests/Murmur.Speech.Tests/SpeechRepairBudgetTests.cs b/windows/tests/Murmur.Speech.Tests/SpeechRepairBudgetTests.cs
new file mode 100644
index 0000000..b5b3096
--- /dev/null
+++ b/windows/tests/Murmur.Speech.Tests/SpeechRepairBudgetTests.cs
@@ -0,0 +1,113 @@
+
+using Murmur.Core.Abstractions;
+using Shouldly;
+using Xunit;
+
+namespace Murmur.Speech.Tests;
+
+public class SpeechRepairBudgetTests
+{
+    private static async IAsyncEnumerable<string> Chunks(IEnumerable<string> chunks, Action? after = null)
+    {
+        await Task.CompletedTask;
+        foreach (var chunk in chunks) yield return chunk;
+        after?.Invoke();
+    }
+
+    [Theory]
+    [InlineData(1568, true)]
+    [InlineData(1569, false)]
+    [InlineData(2048, false)]
+    [InlineData(int.MaxValue, false)]
+    public async Task ExactFormattedPromptAndEntireReserveMustFit(int promptTokens, bool fits)
+    {
+        const string raw = "  Original ohne Veraenderung  ";
+        var prompts = new List<string>();
+        var calls = 0;
+        using var repairer = new LlamaSharpSpeechRepairer(text =>
+        {
+            prompts.Add(text);
+            return text == raw ? 200 : promptTokens;
+        }, (prompt, maximum, ct) =>
+        {
+            calls++;
+            maximum.ShouldBe(464);
+            prompt.ShouldStartWith("<|im_start|>system\n");
+            prompt.ShouldEndWith("<|im_start|>assistant\n");
+            prompt.ShouldContain(raw);
+            return Chunks(["kurz"]);
+        });
+        (await repairer.RepairAsync(raw)).ShouldBe(fits ? "kurz" : raw);
+        calls.ShouldBe(fits ? 1 : 0);
+        prompts.Count.ShouldBe(2);
+    }
+
+    [Fact]
+    public async Task LongOutputBeyondOld256LimitIsAcceptedBeforeDynamicBudget()
+    {
+        using var repairer = new LlamaSharpSpeechRepairer(_ => 200,
+            (_, maximum, _) => Chunks(Enumerable.Repeat("wort ", 300)));
+        (await repairer.RepairAsync("Original")).ShouldBe(string.Join(' ', Enumerable.Repeat("wort", 300)));
+    }
+
+    [Theory]
+    [InlineData(false)]
+    [InlineData(true)]
+    public async Task FullBudgetIncludingEmptyUtf8YieldsKeepsExactOriginal(bool empty)
+    {
+        const string raw = " Original mit Rest ";
+        using var repairer = new LlamaSharpSpeechRepairer(_ => 200,
+            (_, maximum, _) => Chunks(Enumerable.Repeat(empty ? "" : "Teil", maximum)));
+        (await repairer.RepairAsync(raw)).ShouldBe(raw);
+    }
+
+    [Theory]
+    [InlineData("Mittwoch")]
+    [InlineData("am Mittwoch um")]
+    public async Task LegitimateStrongCorrectionAndFragmentNeedNoLengthOrPunctuationHeuristic(string corrected)
+    {
+        using var repairer = new LlamaSharpSpeechRepairer(_ => 200, (_, _, _) => Chunks([corrected]));
+        (await repairer.RepairAsync(new string('x', 500))).ShouldBe(corrected);
+    }
+
+    [Fact]
+    public async Task InferenceFailureOrEmptyOutputKeepsOriginal()
+    {
+        foreach (var fails in new[] { true, false })
+        {
+            using var repairer = new LlamaSharpSpeechRepairer(_ => 200,
+                (_, _, _) => fails ? throw new InvalidOperationException("decoder failed") : Chunks([" "]));
+            (await repairer.RepairAsync(" original ")).ShouldBe(" original ");
+        }
+    }
+
+    [Theory]
+    [InlineData("")]
+    [InlineData(" ")]
+    [InlineData("lang")]
+    public async Task CancellationWinsOverEarlyReturnsAndMissingModelFallback(string raw)
+    {
+        using var cancellation = new CancellationTokenSource();
+        cancellation.Cancel();
+        using var repairer = new LlamaSharpSpeechRepairer(null);
+        await Should.ThrowAsync<OperationCanceledException>(() => repairer.RepairAsync(raw, cancellation.Token));
+    }
+
+    [Fact]
+    public async Task SilentExecutorCancellationAfterEnumerationCannotReturnPartial()
+    {
+        using var cancellation = new CancellationTokenSource();
+        using var repairer = new LlamaSharpSpeechRepairer(_ => 200,
+            (_, _, _) => Chunks(["Teil"], cancellation.Cancel));
+        await Should.ThrowAsync<OperationCanceledException>(() => repairer.RepairAsync("Original", cancellation.Token));
+    }
+
+    [Fact]
+    public async Task CancellationDuringTokenizationWinsOverContextFallback()
+    {
+        using var cancellation = new CancellationTokenSource();
+        using var repairer = new LlamaSharpSpeechRepairer(_ => { cancellation.Cancel(); return int.MaxValue; },
+            (_, _, _) => throw new InvalidOperationException("Must not infer"));
+        await Should.ThrowAsync<OperationCanceledException>(() => repairer.RepairAsync("Original", cancellation.Token));
+    }
+}

From eb1fa61c5935dee4cd6b4ffb0ce7d78dd775ebd7 Mon Sep 17 00:00:00 2001
From: devjenjen <devjenjen@gmail.com>
Date: Tue, 27 Oct 2026 02:05:21 +0100
Subject: [PATCH 5/9] fix(lifecycle): quarantine native work until actual
 completion

---
 windows/src/Murmur.App/App.axaml.cs           |  74 ++++++--
 .../Diagnostics/ShutdownDeadline.cs           |  26 +++
 .../Localization/UiTextResources.de.resx      |   1 +
 .../Localization/UiTextResources.resx         |   1 +
 .../src/Murmur.Core/DictationController.cs    | 121 +++++++++++--
 .../Audio/WasapiAudioCapture.cs               |   2 +-
 .../NemotronStreamingTranscriber.cs           |  46 +++--
 .../ControllerRetirementTests.cs              |  96 ++++++++++
 .../Murmur.App.Tests/ShutdownDeadlineTests.cs |  34 ++++
 .../DictationControllerTests.cs               |   7 +-
 .../DictationLifecycleTests.cs                | 164 ++++++++++++++++++
 .../NativeSessionLifetimeTests.cs             | 162 +++++++++++++++++
 12 files changed, 681 insertions(+), 53 deletions(-)
 create mode 100644 windows/src/Murmur.App/Diagnostics/ShutdownDeadline.cs
 create mode 100644 windows/tests/Murmur.App.Tests/ControllerRetirementTests.cs
 create mode 100644 windows/tests/Murmur.App.Tests/ShutdownDeadlineTests.cs
 create mode 100644 windows/tests/Murmur.Core.Tests/DictationLifecycleTests.cs
 create mode 100644 windows/tests/Murmur.Speech.Tests/NativeSessionLifetimeTests.cs

diff --git a/windows/src/Murmur.App/App.axaml.cs b/windows/src/Murmur.App/App.axaml.cs
index 40e0861..8a3e3ff 100644
--- a/windows/src/Murmur.App/App.axaml.cs
+++ b/windows/src/Murmur.App/App.axaml.cs
@@ -52,6 +52,7 @@ public App()
 
     private DictationController? _controller;
     private readonly SemaphoreSlim _controllerGate = new(1, 1);
+    private bool _recognitionBlocked;
     private int _controllerGeneration;
     private volatile bool _shuttingDown;
     private Action? _unsubscribeControllerEvents;
@@ -332,11 +333,23 @@ private void OnProfileMenuItemClick(object? sender, EventArgs e)
 
     private async Task StartControllerAsync()
     {
+        if (_recognitionBlocked || _controller?.RequiresRestart == true)
+        {
+            _recognitionBlocked = true;
+            _settingsWindow?.SetStatus(UiText.Text("RecognitionRestartRequired"), isError: true);
+            _hud?.UpdateState(DictationState.ErrorState(UiText.Text("RecognitionRestartRequired")), 0, _recoveryTranscript ?? string.Empty);
+            return;
+        }
         var generation = Interlocked.Increment(ref _controllerGeneration);
         var settings = _settings.Normalize();
         var model = ModelManifest.Get(settings.SpeechModelId);
         bool IsCurrentLoad() => !_shuttingDown && generation == Volatile.Read(ref _controllerGeneration);
-        await _controllerGate.WaitAsync();
+        if (!await _controllerGate.WaitAsync(TimeSpan.FromSeconds(3)))
+        {
+            _recognitionBlocked = true;
+            _settingsWindow?.SetStatus(UiText.Text("RecognitionRestartRequired"), isError: true);
+            return;
+        }
         ITranscriber? transcriber = null;
         WasapiAudioCapture? audioCapture = null;
         LowLevelKeyboardHook? hotkeyHook = null;
@@ -344,7 +357,7 @@ private async Task StartControllerAsync()
         var loadingTranscriber = false;
         try
         {
-            if (!IsCurrentLoad()) return;
+            if (!IsCurrentLoad() || _recognitionBlocked) return;
             _profileToggleHook?.Dispose();
             _profileToggleHook = null;
             await DisposeControllerAsync();
@@ -491,8 +504,21 @@ private async Task DisposeControllerAsync()
         _controller = null;
         _controllerModelId = null;
         _settingsWindow?.SetModelNotLoaded();
-        try { if (owner != null) await owner.DisposeAsync(); }
-        finally { unsubscribe?.Invoke(); }
+        try
+        {
+            if (owner != null) await owner.DisposeAsync();
+        }
+        catch (TimeoutException ex)
+        {
+            _recognitionBlocked = true;
+            throw new InvalidOperationException(UiText.Text("RecognitionRestartRequired"), ex);
+        }
+        finally
+        {
+            _recognitionBlocked |= owner?.RequiresRestart == true;
+            unsubscribe?.Invoke();
+        }
+        if (_recognitionBlocked) throw new InvalidOperationException(UiText.Text("RecognitionRestartRequired"));
     }
 
     private Action SubscribeControllerEvents(DictationController owner, string modelId)
@@ -594,6 +620,7 @@ private static DictationState LocalizeDictationState(DictationState state)
             "TextTargetUnavailable" => UiText.TextTargetUnavailable,
             "TextTargetChanged" => UiText.TextTargetChanged,
             "TextModifierHeld" => UiText.TextModifierHeld,
+            "RecognitionRestartRequired" => UiText.Text("RecognitionRestartRequired"),
             _ => state.Message
         };
         return string.Equals(localized, state.Message, StringComparison.Ordinal)
@@ -966,6 +993,11 @@ private void OnSettingsDownloadCancelRequested(object? sender, EventArgs e)
     private async void OnSettingsMicrophoneTestRequested()
     {
         if (_shuttingDown) return;
+        if (_recognitionBlocked || _controller?.RequiresRestart == true)
+        {
+            _settingsWindow?.SetStatus(UiText.Text("RecognitionRestartRequired"), isError: true);
+            return;
+        }
         bool isRunning;
         lock (_testCaptureLock)
         {
@@ -1045,17 +1077,19 @@ private async Task StopMicrophoneTestAsync(int? expectedGeneration = null)
         {
             if (capture != null)
             {
-                try
+                var actualStop = Task.Run(async () =>
                 {
-                    await capture.StopAsync().ConfigureAwait(false);
-                }
+                    try { await capture.StopAsync(CancellationToken.None).ConfigureAwait(false); }
+                    finally { if (!capture.IsRunning) capture.Dispose(); }
+                });
+                ShutdownDeadline.Observe(actualStop);
+                try { await actualStop.WaitAsync(TimeSpan.FromSeconds(3)).ConfigureAwait(false); }
                 catch (Exception ex)
                 {
+                    _recognitionBlocked = true;
                     AppLogger.LogException("StopMicrophoneTestAsync", ex);
-                }
-                finally
-                {
-                    capture.Dispose();
+                    Dispatcher.UIThread.Post(() => _settingsWindow?.SetStatus(
+                        UiText.Text("RecognitionRestartRequired"), isError: true));
                 }
             }
         }
@@ -1277,6 +1311,16 @@ private async void OnExitClick(object? sender, EventArgs e)
         AppLogger.Log("App exiting via Tray Exit.");
         _updateCts.Cancel();
         _downloadCts?.Cancel();
+        await ShutdownDeadline.RunAsync(ShutdownCoreAsync(), () =>
+        {
+            _hud?.Close();
+            _settingsWindow?.Close();
+            if (ApplicationLifetime is IClassicDesktopStyleApplicationLifetime desktop) desktop.Shutdown();
+        }, () => Environment.Exit(0));
+    }
+
+    private async Task ShutdownCoreAsync()
+    {
         if (_initializationTask != null) await _initializationTask;
         await StopMicrophoneTestAsync();
         await _controllerGate.WaitAsync();
@@ -1286,18 +1330,10 @@ private async void OnExitClick(object? sender, EventArgs e)
             _profileToggleHook = null;
             await DisposeControllerAsync();
         }
-        catch (Exception ex) { AppLogger.LogException("Controller shutdown", ex); }
         finally { _controllerGate.Release(); }
         _updateChecker.Dispose();
         _updateCts.Dispose();
         _recoveryTranscript = null;
         _clickSoundPlayer.Dispose();
-        _hud?.Close();
-        _settingsWindow?.Close();
-
-        if (ApplicationLifetime is IClassicDesktopStyleApplicationLifetime desktop)
-        {
-            desktop.Shutdown();
-        }
     }
 }
diff --git a/windows/src/Murmur.App/Diagnostics/ShutdownDeadline.cs b/windows/src/Murmur.App/Diagnostics/ShutdownDeadline.cs
new file mode 100644
index 0000000..d6655c2
--- /dev/null
+++ b/windows/src/Murmur.App/Diagnostics/ShutdownDeadline.cs
@@ -0,0 +1,26 @@
+namespace Murmur.App.Diagnostics;
+
+internal static class ShutdownDeadline
+{
+    internal static void Observe(Task work) => _ = work.ContinueWith(
+        static completed => { _ = completed.Exception; }, CancellationToken.None,
+        TaskContinuationOptions.OnlyOnFaulted | TaskContinuationOptions.ExecuteSynchronously, TaskScheduler.Default);
+
+    internal static async Task RunAsync(Task cleanup, Action completed, Action forceExit,
+        Func<Task, TimeSpan, Task>? wait = null)
+    {
+        Observe(cleanup);
+        try
+        {
+            wait ??= static (work, budget) => work.WaitAsync(budget);
+            await wait(cleanup, TimeSpan.FromSeconds(3));
+        }
+        catch
+        {
+            // Only process termination can reclaim a genuinely stuck native call safely.
+            forceExit();
+            return;
+        }
+        completed();
+    }
+}
diff --git a/windows/src/Murmur.App/Localization/UiTextResources.de.resx b/windows/src/Murmur.App/Localization/UiTextResources.de.resx
index 63a67e3..fe1a41c 100644
--- a/windows/src/Murmur.App/Localization/UiTextResources.de.resx
+++ b/windows/src/Murmur.App/Localization/UiTextResources.de.resx
@@ -215,4 +215,5 @@
   <data name="DictionaryTermExample" xml:space="preserve"><value>z. B. GitHub</value></data>
   <data name="DictionaryCorrectionExample" xml:space="preserve"><value>z. B. cloud code</value></data>
   <data name="Confirm" xml:space="preserve"><value>Bestätigen</value></data>
+  <data name="RecognitionRestartRequired" xml:space="preserve"><value>Die Spracherkennung konnte nicht sicher beendet werden. Bitte Murmur vor dem nächsten Diktat oder Modellwechsel neu starten. Geretteter Teiltext ist unvollständig.</value></data>
 </root>
diff --git a/windows/src/Murmur.App/Localization/UiTextResources.resx b/windows/src/Murmur.App/Localization/UiTextResources.resx
index 1c230e3..e392fc0 100644
--- a/windows/src/Murmur.App/Localization/UiTextResources.resx
+++ b/windows/src/Murmur.App/Localization/UiTextResources.resx
@@ -215,4 +215,5 @@
   <data name="DictionaryTermExample" xml:space="preserve"><value>e.g. GitHub</value></data>
   <data name="DictionaryCorrectionExample" xml:space="preserve"><value>e.g. cloud code</value></data>
   <data name="Confirm" xml:space="preserve"><value>Confirm</value></data>
+  <data name="RecognitionRestartRequired" xml:space="preserve"><value>Speech recognition did not finish safely. Please restart Murmur before dictating or changing models. Any recovered partial text is incomplete.</value></data>
 </root>
diff --git a/windows/src/Murmur.Core/DictationController.cs b/windows/src/Murmur.Core/DictationController.cs
index e7266f7..3455d39 100644
--- a/windows/src/Murmur.Core/DictationController.cs
+++ b/windows/src/Murmur.Core/DictationController.cs
@@ -34,6 +34,8 @@ private sealed class ActiveSessionState(RuntimeState runtime, TextInjectionTarge
         public long? ReleasedAt { get; set; }
         public long? InjectedAt { get; set; }
         public long SampleCount { get; set; }
+        public Task InFlight { get; set; } = Task.CompletedTask;
+        public bool Ended { get; set; }
     }
 
     private readonly IAudioCapture _audioCapture;
@@ -53,6 +55,17 @@ private sealed class ActiveSessionState(RuntimeState runtime, TextInjectionTarge
     private Task _sessionTask = Task.CompletedTask;
     private Task? _stopTask;
     private Task? _disposeTask;
+    private Task? _stopCompletion;
+    private Task? _disposeCompletion;
+    private volatile bool _requiresRestart;
+    private static readonly TimeSpan ShutdownBudget = TimeSpan.FromSeconds(3);
+    internal Func<Task, TimeSpan, CancellationToken, Task> WaitForWorkAsync { get; set; } =
+        static (work, budget, cancellation) => work.WaitAsync(budget, cancellation);
+    internal Task DisposalCompletion => _disposeCompletion ?? Task.CompletedTask;
+    internal Task SessionCompletion => _sessionTask;
+
+    /// <summary>True after a deadline leaves native/capture work in quarantine; restart the app before reuse.</summary>
+    public bool RequiresRestart => _requiresRestart;
     private bool _stopping;
     private bool _disposed;
 
@@ -145,6 +158,7 @@ public void Start()
         lock (_lock)
         {
             ObjectDisposedException.ThrowIf(_disposed, this);
+            if (_requiresRestart) throw new InvalidOperationException("RecognitionRestartRequired");
             if (_stopTask is { IsCompleted: false })
                 throw new InvalidOperationException("Controller is still stopping.");
             _stopping = false;
@@ -223,30 +237,60 @@ public Task StopAsync()
             }
             var work = _sessionTask;
             var started = session?.CaptureStarted.Task ?? Task.CompletedTask;
-            _stopTask = Task.Run(() => StopCoreAsync(work, started));
+            _stopCompletion = Task.Run(() => StopCoreAsync(work, started));
+            _stopTask = WaitForShutdownAsync(_stopCompletion);
+            ObserveFailure(_stopTask);
             return _stopTask;
         }
     }
 
     private async Task StopCoreAsync(Task sessionWork, Task captureStarted)
     {
-        _hotkeySource.Stop();
+        try { _hotkeySource.Stop(); }
+        catch { RequireRestart(null); }
         await captureStarted.ConfigureAwait(false);
         await CleanupCaptureAsync().ConfigureAwait(false);
         await sessionWork.ConfigureAwait(false);
         lock (_lock)
         {
             ClearAudioBuffer();
-            SetState(DictationState.Idle);
+            SetState(_requiresRestart ? DictationState.ErrorState("RecognitionRestartRequired") : DictationState.Idle);
         }
     }
 
+    private static void ObserveFailure(Task work) => _ = work.ContinueWith(
+        static completed => { _ = completed.Exception; }, CancellationToken.None,
+        TaskContinuationOptions.OnlyOnFaulted | TaskContinuationOptions.ExecuteSynchronously, TaskScheduler.Default);
+
+    private void RequireRestart(ActiveSessionState? session)
+    {
+        lock (_lock)
+        {
+            _requiresRestart = true;
+            if (session is { Ended: false, InsertionCommitted: false }) session.Cancellation.Cancel();
+            SetState(DictationState.ErrorState("RecognitionRestartRequired"));
+        }
+    }
+
+    private async Task WaitForShutdownAsync(Task work)
+    {
+        try { await WaitForWorkAsync(work, ShutdownBudget, CancellationToken.None).ConfigureAwait(false); }
+        catch (TimeoutException) { RequireRestart(null); throw; }
+    }
+
+    private async Task WaitForOperationAsync(ActiveSessionState session, Task work, TimeSpan budget, CancellationToken cancellationToken)
+    {
+        session.InFlight = work;
+        try { await WaitForWorkAsync(work, budget, cancellationToken).ConfigureAwait(false); }
+        catch (TimeoutException) { RequireRestart(session); throw; }
+    }
+
     private void OnHotkeyPressed()
     {
         ActiveSessionState session;
         lock (_lock)
         {
-            if (_stopping || _disposed || !_sessionTask.IsCompleted ||
+            if (_stopping || _disposed || _requiresRestart || !_sessionTask.IsCompleted ||
                 State.Status is not (DictationStatus.Idle or DictationStatus.Error)) return;
 
             try
@@ -307,7 +351,8 @@ private async Task FinishSessionAsync(ActiveSessionState session, CancellationTo
             await Task.Delay(40, cancellationToken).ConfigureAwait(false);
             if (!IsCurrentSession(session)) return;
             // A cancelled wait must not let native resources outlive capture shutdown.
-            await _audioCapture.StopAsync(CancellationToken.None).ConfigureAwait(false);
+            await WaitForOperationAsync(session, Task.Run(() => _audioCapture.StopAsync(CancellationToken.None), CancellationToken.None),
+                ShutdownBudget, cancellationToken).ConfigureAwait(false);
 
             float[] audioCopy;
             long sampleCount;
@@ -326,9 +371,13 @@ private async Task FinishSessionAsync(ActiveSessionState session, CancellationTo
 
             var audioDurationMs = sampleCount * 1000.0 / 16000.0;
             var sw = Stopwatch.StartNew();
-            var raw = _streamingTranscriber is null
-                ? await _transcriber.TranscribeAsync(audioCopy, cancellationToken).ConfigureAwait(false)
-                : await _streamingTranscriber.CompleteSessionAsync(cancellationToken).ConfigureAwait(false);
+            var recognition = _streamingTranscriber is null
+                ? Task.Run(() => _transcriber.TranscribeAsync(audioCopy, cancellationToken), CancellationToken.None)
+                : Task.Run(() => _streamingTranscriber.CompleteSessionAsync(cancellationToken), CancellationToken.None);
+            var inferenceBudget = _streamingTranscriber is null
+                ? TimeSpan.FromSeconds(Math.Max(60, sampleCount * 2.0 / 16000)) : TimeSpan.FromSeconds(30);
+            await WaitForOperationAsync(session, recognition, inferenceBudget, cancellationToken).ConfigureAwait(false);
+            var raw = await recognition.ConfigureAwait(false);
             audioCopy = [];
             if (!IsCurrentSession(session)) return;
             sw.Stop();
@@ -341,13 +390,21 @@ private async Task FinishSessionAsync(ActiveSessionState session, CancellationTo
                 return;
             }
 
+            lock (_lock)
+            {
+                if (!IsCurrent(session)) return;
+                CurrentTranscript = raw;
+                TranscriptChanged?.Invoke(raw);
+            }
             var repaired = raw;
             var repairer = _speechRepairer;
             if (session.Runtime.EnableSelfCorrection && repairer != null)
             {
                 try
                 {
-                    var repairResult = await repairer.RepairAsync(raw, cancellationToken).ConfigureAwait(false);
+                    var repair = Task.Run(() => repairer.RepairAsync(raw, cancellationToken), CancellationToken.None);
+                    await WaitForOperationAsync(session, repair, inferenceBudget, cancellationToken).ConfigureAwait(false);
+                    var repairResult = await repair.ConfigureAwait(false);
                     cancellationToken.ThrowIfCancellationRequested();
                     if (!string.IsNullOrWhiteSpace(repairResult))
                     {
@@ -418,6 +475,7 @@ private async Task FinishSessionAsync(ActiveSessionState session, CancellationTo
         }
         finally
         {
+            await WaitForActualWorkAsync(session).ConfigureAwait(false);
             await CleanupCaptureAsync().ConfigureAwait(false);
             EndSession(session, error);
         }
@@ -451,7 +509,7 @@ private void RecordMetrics(ActiveSessionState session, double audioMs, double in
     }
 
     private bool IsCurrent(ActiveSessionState session) =>
-        !_stopping && !_disposed && ReferenceEquals(_activeSessionState, session) &&
+        !_stopping && !_disposed && !_requiresRestart && ReferenceEquals(_activeSessionState, session) &&
         !session.Cancellation.IsCancellationRequested;
 
     private bool IsCurrentSession(ActiveSessionState session)
@@ -461,11 +519,28 @@ private bool IsCurrentSession(ActiveSessionState session)
 
     private void BeginAbort(ActiveSessionState session, Exception exception)
     {
+        if (session.Ended) return;
         session.Failure ??= exception;
         session.Cancellation.Cancel();
-        if (session.WorkStarted) return;
-        session.WorkStarted = true;
-        _sessionTask = Task.Run(() => AbortSessionAsync(session));
+        SetState(DictationState.ErrorState(GetErrorMessage(exception, "Microphone error")));
+        if (!session.WorkStarted)
+        {
+            session.WorkStarted = true;
+            _sessionTask = Task.Run(() => AbortSessionAsync(session));
+        }
+        _ = MonitorAbortAsync(_sessionTask);
+    }
+
+    private async Task MonitorAbortAsync(Task work)
+    {
+        try { await WaitForShutdownAsync(work).ConfigureAwait(false); }
+        catch { /* The public error is already reported; actual cleanup retains resource ownership. */ }
+    }
+
+    private static async Task WaitForActualWorkAsync(ActiveSessionState session)
+    {
+        try { await session.InFlight.ConfigureAwait(false); }
+        catch { /* Observe late native failures; never release before the actual task has finished. */ }
     }
 
     private async Task AbortSessionAsync(ActiveSessionState session)
@@ -478,7 +553,15 @@ private async Task AbortSessionAsync(ActiveSessionState session)
     private async Task CleanupCaptureAsync()
     {
         try { await _audioCapture.StopAsync().ConfigureAwait(false); }
-        catch { /* Preserve the original capture or transcription failure. */ }
+        catch
+        {
+            if (_audioCapture.IsRunning)
+            {
+                RequireRestart(null);
+                // Capture did not confirm shutdown: retain ownership until process exit.
+                await Task.Delay(Timeout.InfiniteTimeSpan).ConfigureAwait(false);
+            }
+        }
         try
         {
             if (_streamingTranscriber != null)
@@ -497,9 +580,11 @@ private void EndSession(ActiveSessionState session, string? error)
                 ClearAudioBuffer();
                 Level = 0;
                 LevelChanged?.Invoke(0);
-                error = session.Failure is { } failure ? GetErrorMessage(failure, "Microphone error") : error;
+                error = _requiresRestart ? "RecognitionRestartRequired"
+                    : session.Failure is { } failure ? GetErrorMessage(failure, "Microphone error") : error;
                 SetState(error == null ? DictationState.Idle : DictationState.ErrorState(error));
             }
+            session.Ended = true;
             session.Cancellation.Dispose();
         }
     }
@@ -566,8 +651,10 @@ public ValueTask DisposeAsync()
         {
             if (_disposeTask != null) return new ValueTask(_disposeTask);
             _disposed = true;
-            var stopped = StopAsync();
-            _disposeTask = Task.Run(() => DisposeCoreAsync(stopped));
+            _ = StopAsync();
+            _disposeCompletion = Task.Run(() => DisposeCoreAsync(_stopCompletion!));
+            ObserveFailure(_disposeCompletion);
+            _disposeTask = WaitForShutdownAsync(_disposeCompletion);
             return new ValueTask(_disposeTask);
         }
     }
diff --git a/windows/src/Murmur.Platform.Windows/Audio/WasapiAudioCapture.cs b/windows/src/Murmur.Platform.Windows/Audio/WasapiAudioCapture.cs
index 273a05d..11d341c 100644
--- a/windows/src/Murmur.Platform.Windows/Audio/WasapiAudioCapture.cs
+++ b/windows/src/Murmur.Platform.Windows/Audio/WasapiAudioCapture.cs
@@ -175,7 +175,7 @@ public async Task StopAsync(CancellationToken cancellationToken = default)
 
         if (stoppedTask != null)
         {
-            await stoppedTask.Task.WaitAsync(TimeSpan.FromSeconds(2), cancellationToken).ConfigureAwait(false);
+            await stoppedTask.Task.WaitAsync(cancellationToken).ConfigureAwait(false);
         }
     }
 
diff --git a/windows/src/Murmur.Speech/NemotronStreamingTranscriber.cs b/windows/src/Murmur.Speech/NemotronStreamingTranscriber.cs
index 8fb03cf..a405138 100644
--- a/windows/src/Murmur.Speech/NemotronStreamingTranscriber.cs
+++ b/windows/src/Murmur.Speech/NemotronStreamingTranscriber.cs
@@ -9,11 +9,14 @@ namespace Murmur.Speech;
 /// </summary>
 public sealed class NemotronStreamingTranscriber : IStreamingTranscriber
 {
-    private readonly OnlineRecognizer _recognizer;
+    internal sealed record NativeSession(Action<float[]> Accept, Func<bool> IsReady, Action Decode,
+        Func<string> GetText, Action InputFinished, Action Dispose);
+    private readonly Func<NativeSession> _createStream;
+    private readonly Action _disposeRecognizer;
     private readonly Lock _lock = new();
-    private sealed class StreamingSession(OnlineStream stream, Channel<float[]> channel)
+    private sealed class StreamingSession(NativeSession stream, Channel<float[]> channel)
     {
-        public OnlineStream Stream { get; } = stream;
+        public NativeSession Stream { get; } = stream;
         public Channel<float[]> Channel { get; } = channel;
         public Task Worker { get; set; } = Task.CompletedTask;
         public int Cancelled;
@@ -53,7 +56,23 @@ public NemotronStreamingTranscriber(string? modelDir = null)
         config.ModelConfig.Provider = "cpu";
         config.DecodingMethod = "greedy_search";
 
-        _recognizer = new OnlineRecognizer(config);
+        var recognizer = new OnlineRecognizer(config);
+        _createStream = () =>
+        {
+            var stream = recognizer.CreateStream();
+            try { stream.SetOption("language", "auto"); }
+            catch { stream.Dispose(); throw; }
+            return new NativeSession(samples => stream.AcceptWaveform(16000, samples),
+                () => recognizer.IsReady(stream), () => recognizer.Decode(stream),
+                () => recognizer.GetResult(stream).Text ?? string.Empty, stream.InputFinished, stream.Dispose);
+        };
+        _disposeRecognizer = recognizer.Dispose;
+    }
+
+    internal NemotronStreamingTranscriber(Func<NativeSession> createStream, Action disposeRecognizer)
+    {
+        _createStream = createStream;
+        _disposeRecognizer = disposeRecognizer;
     }
 
     /// <inheritdoc />
@@ -69,10 +88,9 @@ public void BeginSession()
 
             _closeTask = null;
 
-            var sessionStream = _recognizer.CreateStream();
+            var sessionStream = _createStream();
             try
             {
-                sessionStream.SetOption("language", "auto");
                 var sessionChannel = Channel.CreateUnbounded<float[]>(new UnboundedChannelOptions
                 {
                     SingleReader = true,
@@ -112,12 +130,12 @@ private async Task ProcessAudioLoopAsync(StreamingSession session)
             await foreach (var samples in session.Channel.Reader.ReadAllAsync().ConfigureAwait(false))
             {
                 if (Volatile.Read(ref session.Cancelled) != 0) return;
-                stream.AcceptWaveform(16000, samples);
-                while (Volatile.Read(ref session.Cancelled) == 0 && _recognizer.IsReady(stream))
+                stream.Accept(samples);
+                while (Volatile.Read(ref session.Cancelled) == 0 && stream.IsReady())
                 {
-                    _recognizer.Decode(stream);
+                    stream.Decode();
                     if (Volatile.Read(ref session.Cancelled) != 0) return;
-                    var text = _recognizer.GetResult(stream).Text ?? string.Empty;
+                    var text = stream.GetText();
                     if (text.Length > 0 && !string.Equals(text, lastPartial, StringComparison.Ordinal) &&
                         Volatile.Read(ref session.Cancelled) == 0)
                     {
@@ -191,12 +209,12 @@ private async Task<string> FinishClosingSessionAsync(StreamingSession session, b
             if (decodeFinal && Volatile.Read(ref session.Cancelled) == 0)
             {
                 stream.InputFinished();
-                while (Volatile.Read(ref session.Cancelled) == 0 && _recognizer.IsReady(stream))
+                while (Volatile.Read(ref session.Cancelled) == 0 && stream.IsReady())
                 {
-                    _recognizer.Decode(stream);
+                    stream.Decode();
                 }
                 if (Volatile.Read(ref session.Cancelled) == 0)
-                    return _recognizer.GetResult(stream).Text ?? string.Empty;
+                    return stream.GetText();
             }
             return string.Empty;
         }
@@ -239,7 +257,7 @@ public void Dispose()
             _disposeTask ??= Task.Run(async () =>
             {
                 try { await CancelSessionAsync().ConfigureAwait(false); }
-                finally { _recognizer.Dispose(); }
+                finally { _disposeRecognizer(); }
             });
             disposing = _disposeTask;
         }
diff --git a/windows/tests/Murmur.App.Tests/ControllerRetirementTests.cs b/windows/tests/Murmur.App.Tests/ControllerRetirementTests.cs
new file mode 100644
index 0000000..bb316f5
--- /dev/null
+++ b/windows/tests/Murmur.App.Tests/ControllerRetirementTests.cs
@@ -0,0 +1,96 @@
+using System.Reflection;
+using Avalonia;
+using Avalonia.Headless.XUnit;
+using Murmur.Core;
+using Murmur.Core.Abstractions;
+using Shouldly;
+
+namespace Murmur.App.Tests;
+
+public class ControllerRetirementTests
+{
+    private sealed class Audio : IAudioCapture
+    {
+        public event Action<ReadOnlyMemory<float>>? AudioChunkAvailable;
+        public event Action<float>? LevelChanged { add { } remove { } }
+        public event Action<Exception>? CaptureFailed { add { } remove { } }
+        public bool IsRunning { get; private set; }
+        public AudioCaptureFormat? Format => null;
+        public AudioCaptureStats? LastSessionStats => null;
+        public int Disposals { get; private set; }
+        public void Start() { IsRunning = true; AudioChunkAvailable?.Invoke(new float[160]); }
+        public Task StopAsync(CancellationToken cancellationToken = default) { IsRunning = false; return Task.CompletedTask; }
+        public void Dispose() => Disposals++;
+    }
+    private sealed class Keys : IHotkeySource
+    {
+        public event Action? Pressed;
+        public event Action? Released;
+        public void Press() => Pressed?.Invoke();
+        public void Release() => Released?.Invoke();
+        public void Start() { }
+        public void Stop() { }
+        public void Dispose() { }
+    }
+    private sealed class Native : ITranscriber
+    {
+        public TaskCompletionSource Entered { get; } = new(TaskCreationOptions.RunContinuationsAsynchronously);
+        public TaskCompletionSource<string> Returned { get; } = new(TaskCreationOptions.RunContinuationsAsynchronously);
+        public int Disposals { get; private set; }
+        public Task<string> TranscribeAsync(ReadOnlyMemory<float> samples, CancellationToken cancellationToken = default)
+        { Entered.SetResult(); return Returned.Task; }
+        public void Dispose() { Returned.Task.IsCompleted.ShouldBeTrue(); Disposals++; }
+    }
+    private sealed class Injector : ITextInjector
+    {
+        public TextInjectionTarget CaptureTarget() => new(1, 2);
+        public void Insert(string text, TextInjectionTarget target, Murmur.Core.Settings.TextInsertionMode mode,
+            bool restorePreviousWindow = false) => throw new InvalidOperationException("Late result must never be inserted");
+    }
+
+    [AvaloniaFact]
+    public async Task ModelSwitchCannotCreateReplacementAfterBoundedControllerDisposal()
+    {
+        const BindingFlags flags = BindingFlags.Instance | BindingFlags.NonPublic;
+        var app = Application.Current.ShouldBeOfType<App>();
+        var ownerField = typeof(App).GetField("_controller", flags)!;
+        ownerField.GetValue(app).ShouldBeNull();
+        var audio = new Audio();
+        var keys = new Keys();
+        var native = new Native();
+        var controller = new DictationController(audio, keys, native, new Injector(), "fake");
+        var expire = false;
+        Func<Task, TimeSpan, CancellationToken, Task> wait = (work, budget, cancellation) =>
+            expire && budget == TimeSpan.FromSeconds(3) ? Task.FromException(new TimeoutException()) : work.WaitAsync(cancellation);
+        typeof(DictationController).GetProperty("WaitForWorkAsync", flags)!.SetValue(controller, wait);
+        ownerField.SetValue(app, controller);
+        try
+        {
+            controller.Start(); keys.Press(); keys.Release();
+            await native.Entered.Task.WaitAsync(TimeSpan.FromSeconds(5));
+            expire = true;
+            var retirement = (Task)typeof(App).GetMethod("DisposeControllerAsync", flags)!.Invoke(app, null)!;
+            await Should.ThrowAsync<InvalidOperationException>(() => retirement);
+            typeof(App).GetField("_recognitionBlocked", flags)!.GetValue(app).ShouldBe(true);
+            native.Disposals.ShouldBe(0);
+            audio.Disposals.ShouldBe(0);
+            await (Task)typeof(App).GetMethod("StartControllerAsync", flags)!.Invoke(app, null)!;
+            ownerField.GetValue(app).ShouldBeNull();
+            native.Returned.SetResult("late");
+            await ((Task)typeof(DictationController).GetProperty("DisposalCompletion", flags)!
+                .GetValue(controller)!).WaitAsync(TimeSpan.FromSeconds(5));
+            native.Disposals.ShouldBe(1);
+            audio.Disposals.ShouldBe(1);
+        }
+        finally
+        {
+            native.Returned.TrySetResult("late");
+            expire = false;
+            try { await controller.DisposeAsync(); } catch (TimeoutException) { }
+            await ((Task)typeof(DictationController).GetProperty("DisposalCompletion", flags)!
+                .GetValue(controller)!).WaitAsync(TimeSpan.FromSeconds(5));
+            ownerField.SetValue(app, null);
+            typeof(App).GetField("_recognitionBlocked", flags)!.SetValue(app, false);
+        }
+    }
+}
diff --git a/windows/tests/Murmur.App.Tests/ShutdownDeadlineTests.cs b/windows/tests/Murmur.App.Tests/ShutdownDeadlineTests.cs
new file mode 100644
index 0000000..b7c0e48
--- /dev/null
+++ b/windows/tests/Murmur.App.Tests/ShutdownDeadlineTests.cs
@@ -0,0 +1,34 @@
+using Murmur.App.Diagnostics;
+using Shouldly;
+using Xunit;
+
+namespace Murmur.App.Tests;
+
+public class ShutdownDeadlineTests
+{
+    [Fact]
+    public async Task ExitBudgetEndsProcessViaCallbackWithoutDisposingUnfinishedWork()
+    {
+        var work = new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously);
+        var exited = 0;
+        var normal = 0;
+        await ShutdownDeadline.RunAsync(work.Task, () => normal++, () => exited++, (pending, budget) =>
+        {
+            pending.ShouldBe(work.Task);
+            budget.ShouldBe(TimeSpan.FromSeconds(3));
+            return Task.FromException(new TimeoutException());
+        });
+        exited.ShouldBe(1);
+        normal.ShouldBe(0);
+        work.Task.IsCompleted.ShouldBeFalse();
+        work.SetException(new IOException("late cleanup failure"));
+    }
+
+    [Fact]
+    public async Task HealthyExitUsesNormalCallback()
+    {
+        var normal = 0;
+        await ShutdownDeadline.RunAsync(Task.CompletedTask, () => normal++, () => throw new InvalidOperationException());
+        normal.ShouldBe(1);
+    }
+}
diff --git a/windows/tests/Murmur.Core.Tests/DictationControllerTests.cs b/windows/tests/Murmur.Core.Tests/DictationControllerTests.cs
index bf39727..e7abdc3 100644
--- a/windows/tests/Murmur.Core.Tests/DictationControllerTests.cs
+++ b/windows/tests/Murmur.Core.Tests/DictationControllerTests.cs
@@ -8,7 +8,7 @@
 
 namespace Murmur.Core.Tests;
 
-public class DictationControllerTests
+public partial class DictationControllerTests
 {
     [Fact]
     public async Task RepairCancellationCannotInsertEvenWhenRepairerReturnsLateText()
@@ -101,6 +101,7 @@ private sealed class FakeAudioCapture : IAudioCapture
         public TaskCompletionSource StopGate { get; } =
             new(TaskCreationOptions.RunContinuationsAsynchronously);
         public bool DelayStop { get; set; }
+        public int DisposeCalls { get; private set; }
 
         public void Start()
         {
@@ -133,7 +134,7 @@ public void Fail(Exception exception)
             IsRunning = false;
             CaptureFailed?.Invoke(exception);
         }
-        public void Dispose() { }
+        public void Dispose() => DisposeCalls++;
     }
 
     private sealed class FakeHotkeySource : IHotkeySource
@@ -669,6 +670,7 @@ public async Task Capture_Start_Error_Cancels_Streaming_Session()
         await WaitForStatusAsync(controller, DictationStatus.Error);
 
         controller.State.Status.ShouldBe(DictationStatus.Error);
+        await controller.SessionCompletion;
         transcriber.SessionActive.ShouldBeFalse();
         transcriber.CancelCalls.ShouldBe(1);
     }
@@ -693,6 +695,7 @@ public async Task Unexpected_Capture_Failure_Enters_Error_And_Next_Press_Restart
         controller.State.Message.ShouldNotBeNull();
         controller.State.Message.ShouldContain("device invalidated");
 
+        await controller.SessionCompletion;
         hotkey.Press();
         controller.State.Status.ShouldBe(DictationStatus.Listening);
     }
diff --git a/windows/tests/Murmur.Core.Tests/DictationLifecycleTests.cs b/windows/tests/Murmur.Core.Tests/DictationLifecycleTests.cs
new file mode 100644
index 0000000..4741906
--- /dev/null
+++ b/windows/tests/Murmur.Core.Tests/DictationLifecycleTests.cs
@@ -0,0 +1,164 @@
+using System.Collections.Concurrent;
+using Murmur.Core.Abstractions;
+using Murmur.Core.State;
+using Shouldly;
+using Xunit;
+
+namespace Murmur.Core.Tests;
+
+public partial class DictationControllerTests
+{
+    private sealed class ManualDeadlines : IDisposable
+    {
+        internal sealed record Request(Task Work, TimeSpan Budget, TaskCompletionSource Expired);
+        private readonly ConcurrentQueue<Request> _requests = new();
+        private readonly SemaphoreSlim _available = new(0);
+        public async Task WaitAsync(Task work, TimeSpan budget, CancellationToken cancellationToken)
+        {
+            if (work.IsCompleted) { await work; return; }
+            var expired = new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously);
+            _requests.Enqueue(new Request(work, budget, expired));
+            _available.Release();
+            var completed = await Task.WhenAny(work, expired.Task).WaitAsync(cancellationToken);
+            if (completed == expired.Task) throw new TimeoutException();
+            await work;
+        }
+        public void Dispose() => _available.Dispose();
+        public async Task<Request> NextAsync()
+        {
+            (await _available.WaitAsync(TimeSpan.FromSeconds(5))).ShouldBeTrue();
+            _requests.TryDequeue(out var request).ShouldBeTrue();
+            return request!;
+        }
+    }
+
+    private sealed class BlockedTranscriber : ITranscriber
+    {
+        public TaskCompletionSource<string> Returned { get; } = new(TaskCreationOptions.RunContinuationsAsynchronously);
+        public TaskCompletionSource Entered { get; } = new(TaskCreationOptions.RunContinuationsAsynchronously);
+        public int Calls { get; private set; }
+        public int DisposeCalls { get; private set; }
+        public Task<string> TranscribeAsync(ReadOnlyMemory<float> samples, CancellationToken cancellationToken = default)
+        {
+            Calls++;
+            Entered.TrySetResult();
+            return Returned.Task;
+        }
+        public void Dispose()
+        {
+            Returned.Task.IsCompleted.ShouldBeTrue("native owner must finish before disposal");
+            DisposeCalls++;
+        }
+    }
+
+    [Theory]
+    [InlineData(false)]
+    [InlineData(true)]
+    public async Task DecodeDeadlineOrStopBudgetQuarantinesUntilRealCompletion(bool stopFirst)
+    {
+        var audio = new FakeAudioCapture();
+        var hotkey = new FakeHotkeySource();
+        var transcriber = new BlockedTranscriber();
+        var repairer = new FakeSpeechRepairer();
+        var injector = new FakeTextInjector();
+        using var deadlines = new ManualDeadlines();
+        var controller = new DictationController(audio, hotkey, transcriber, injector, "fake", speechRepairer: repairer)
+        { WaitForWorkAsync = deadlines.WaitAsync };
+        try
+        {
+            controller.Start();
+            hotkey.Press();
+            audio.EmitChunk(new float[160]);
+            hotkey.Release();
+            var inference = await deadlines.NextAsync();
+            if (inference.Budget == TimeSpan.FromSeconds(3))
+            {
+                await inference.Work.WaitAsync(TimeSpan.FromSeconds(5));
+                inference = await deadlines.NextAsync();
+            }
+            inference.Budget.ShouldBe(TimeSpan.FromSeconds(60));
+            await transcriber.Entered.Task.WaitAsync(TimeSpan.FromSeconds(5));
+            if (stopFirst)
+            {
+                var stop = controller.StopAsync();
+                var stopDeadline = await deadlines.NextAsync();
+                stopDeadline.Budget.ShouldBe(TimeSpan.FromSeconds(3));
+                stopDeadline.Expired.SetResult();
+                await Should.ThrowAsync<TimeoutException>(() => stop);
+            }
+            else
+            {
+                inference.Expired.SetResult();
+                await WaitForStatusAsync(controller, DictationStatus.Error);
+            }
+            controller.RequiresRestart.ShouldBeTrue();
+            controller.State.Message.ShouldBe("RecognitionRestartRequired");
+            hotkey.Press();
+            transcriber.Calls.ShouldBe(1);
+            var disposal = controller.DisposeAsync().AsTask();
+            // Dispose has its own public deadline; the actual stop/cleanup task remains owned.
+            var pending = await deadlines.NextAsync();
+            pending.Expired.SetResult();
+            if (!stopFirst)
+            {
+                pending = await deadlines.NextAsync();
+                pending.Expired.SetResult();
+            }
+            await Should.ThrowAsync<TimeoutException>(() => disposal);
+            transcriber.DisposeCalls.ShouldBe(0);
+            audio.DisposeCalls.ShouldBe(0);
+            repairer.IsDisposed.ShouldBeFalse();
+            transcriber.Returned.SetResult("late text");
+            await controller.DisposalCompletion.WaitAsync(TimeSpan.FromSeconds(5));
+            transcriber.DisposeCalls.ShouldBe(1);
+            audio.DisposeCalls.ShouldBe(1);
+            repairer.IsDisposed.ShouldBeTrue();
+            injector.Injected.ShouldBeEmpty();
+            controller.State.Status.ShouldBe(DictationStatus.Error);
+        }
+        finally
+        {
+            transcriber.Returned.TrySetResult("late text");
+            controller.WaitForWorkAsync = static (work, budget, cancellation) => work.WaitAsync(budget, cancellation);
+            try { await controller.DisposeAsync(); } catch (TimeoutException) { }
+            await controller.DisposalCompletion.WaitAsync(TimeSpan.FromSeconds(5));
+        }
+    }
+
+    [Fact]
+    public async Task CaptureStopIsAlsoOwnedUntilActualCompletion()
+    {
+        var audio = new FakeAudioCapture { DelayStop = true };
+        var hotkey = new FakeHotkeySource();
+        var transcriber = new SpyTranscriber();
+        using var deadlines = new ManualDeadlines();
+        var controller = new DictationController(audio, hotkey, transcriber, new FakeTextInjector(), "fake")
+        { WaitForWorkAsync = deadlines.WaitAsync };
+        try
+        {
+            controller.Start(); hotkey.Press(); audio.EmitChunk(new float[160]); hotkey.Release();
+            var captureStop = await deadlines.NextAsync();
+            captureStop.Budget.ShouldBe(TimeSpan.FromSeconds(3));
+            captureStop.Expired.SetResult();
+            await WaitForStatusAsync(controller, DictationStatus.Error);
+            var disposal = controller.DisposeAsync().AsTask();
+            (await deadlines.NextAsync()).Expired.SetResult();
+            (await deadlines.NextAsync()).Expired.SetResult();
+            await Should.ThrowAsync<TimeoutException>(() => disposal);
+            audio.DisposeCalls.ShouldBe(0);
+            transcriber.DisposeCalls.ShouldBe(0);
+            audio.StopGate.SetResult();
+            await controller.DisposalCompletion.WaitAsync(TimeSpan.FromSeconds(5));
+            audio.DisposeCalls.ShouldBe(1);
+            transcriber.DisposeCalls.ShouldBe(1);
+            transcriber.TranscribeCalls.ShouldBe(0);
+        }
+        finally
+        {
+            audio.StopGate.TrySetResult();
+            controller.WaitForWorkAsync = static (work, budget, cancellation) => work.WaitAsync(budget, cancellation);
+            try { await controller.DisposeAsync(); } catch (TimeoutException) { }
+            await controller.DisposalCompletion.WaitAsync(TimeSpan.FromSeconds(5));
+        }
+    }
+}
diff --git a/windows/tests/Murmur.Speech.Tests/NativeSessionLifetimeTests.cs b/windows/tests/Murmur.Speech.Tests/NativeSessionLifetimeTests.cs
new file mode 100644
index 0000000..30fd672
--- /dev/null
+++ b/windows/tests/Murmur.Speech.Tests/NativeSessionLifetimeTests.cs
@@ -0,0 +1,162 @@
+using Shouldly;
+using Xunit;
+using System.Reflection;
+using Murmur.Core;
+using Murmur.Core.Abstractions;
+using Murmur.Core.Settings;
+using Murmur.Core.State;
+
+namespace Murmur.Speech.Tests;
+
+public class NativeSessionLifetimeTests
+{
+    private sealed class Audio : IAudioCapture
+    {
+        public event Action<ReadOnlyMemory<float>>? AudioChunkAvailable;
+        public event Action<float>? LevelChanged { add { } remove { } }
+        public event Action<Exception>? CaptureFailed { add { } remove { } }
+        public bool IsRunning { get; private set; }
+        public AudioCaptureFormat? Format => null;
+        public AudioCaptureStats? LastSessionStats => null;
+        public void Start() => IsRunning = true;
+        public void Emit() => AudioChunkAvailable?.Invoke(new float[160]);
+        public Task StopAsync(CancellationToken cancellationToken = default) { IsRunning = false; return Task.CompletedTask; }
+        public void Dispose() { }
+    }
+    private sealed class Keys : IHotkeySource
+    {
+        public event Action? Pressed;
+        public event Action? Released;
+        public void Press() => Pressed?.Invoke();
+        public void Release() => Released?.Invoke();
+        public void Start() { }
+        public void Stop() { }
+        public void Dispose() { }
+    }
+    private sealed class Injector : ITextInjector
+    {
+        public int Insertions { get; private set; }
+        public TextInjectionTarget CaptureTarget() => new(1, 2);
+        public void Insert(string text, TextInjectionTarget target, TextInsertionMode mode, bool restorePreviousWindow = false)
+            => Insertions++;
+    }
+
+    [Fact]
+    public async Task ControllerTimeoutRetainsNemotronFinalDecodeAndRecoveryUntilActualCleanup()
+    {
+        using var unblock = new ManualResetEventSlim();
+        var finalEntered = new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously);
+        var partialSeen = new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously);
+        var timedOut = new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously);
+        var deadline = new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously);
+        var final = false;
+        var ready = true;
+        var streamsDisposed = 0;
+        var recognizersDisposed = 0;
+        var transcriber = new NemotronStreamingTranscriber(() => new NemotronStreamingTranscriber.NativeSession(
+            _ => { }, () => ready, () =>
+            {
+                if (final) { finalEntered.TrySetResult(); unblock.Wait(); }
+                ready = false;
+            }, () => "partial recovery", () => { final = true; ready = true; },
+            () => Interlocked.Increment(ref streamsDisposed)), () => Interlocked.Increment(ref recognizersDisposed));
+        var audio = new Audio();
+        var keys = new Keys();
+        var injector = new Injector();
+        var controller = new DictationController(audio, keys, transcriber, injector, "fake");
+        const BindingFlags flags = BindingFlags.NonPublic | BindingFlags.Instance;
+        async Task Wait(Task work, TimeSpan budget, CancellationToken cancellation)
+        {
+            if (budget == TimeSpan.FromSeconds(30))
+            {
+                var winner = await Task.WhenAny(work, deadline.Task).WaitAsync(cancellation);
+                if (winner == deadline.Task) throw new TimeoutException();
+            }
+            else if (budget == TimeSpan.FromSeconds(3) && deadline.Task.IsCompleted) throw new TimeoutException();
+            await work.WaitAsync(cancellation);
+        }
+        typeof(DictationController).GetProperty("WaitForWorkAsync", flags)!.SetValue(controller,
+            (Func<Task, TimeSpan, CancellationToken, Task>)Wait);
+        controller.TranscriptChanged += text => { if (text == "partial recovery") partialSeen.TrySetResult(); };
+        controller.StateChanged += state => { if (state.Status == DictationStatus.Error) timedOut.TrySetResult(); };
+        try
+        {
+            controller.Start(); keys.Press(); audio.Emit();
+            await partialSeen.Task.WaitAsync(TimeSpan.FromSeconds(5));
+            keys.Release();
+            await finalEntered.Task.WaitAsync(TimeSpan.FromSeconds(5));
+            deadline.SetResult();
+            await timedOut.Task.WaitAsync(TimeSpan.FromSeconds(5));
+            controller.RequiresRestart.ShouldBeTrue();
+            controller.CurrentTranscript.ShouldBe("partial recovery");
+            await Should.ThrowAsync<TimeoutException>(() => controller.DisposeAsync().AsTask());
+            streamsDisposed.ShouldBe(0);
+            recognizersDisposed.ShouldBe(0);
+            unblock.Set();
+            await ((Task)typeof(DictationController).GetProperty("DisposalCompletion", flags)!
+                .GetValue(controller)!).WaitAsync(TimeSpan.FromSeconds(5));
+            streamsDisposed.ShouldBe(1);
+            recognizersDisposed.ShouldBe(1);
+            injector.Insertions.ShouldBe(0);
+        }
+        finally
+        {
+            unblock.Set();
+            try { await controller.DisposeAsync(); } catch (TimeoutException) { }
+            await ((Task)typeof(DictationController).GetProperty("DisposalCompletion", flags)!
+                .GetValue(controller)!).WaitAsync(TimeSpan.FromSeconds(5));
+        }
+    }
+
+    [Theory]
+    [InlineData(false)]
+    [InlineData(true)]
+    public async Task ReaderOrFinalDecodeRetainsWholeNativeChainUntilActuallyReturned(bool finalDecode)
+    {
+        using var unblock = new ManualResetEventSlim();
+        var entered = new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously);
+        var disposalStarted = new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously);
+        var streamDisposals = 0;
+        var recognizerDisposals = 0;
+        var final = false;
+        var ready = true;
+        var transcriber = new NemotronStreamingTranscriber(() => new NemotronStreamingTranscriber.NativeSession(
+            _ => { }, () => ready && (!finalDecode || final), () =>
+            {
+                entered.TrySetResult();
+                unblock.Wait();
+                ready = false;
+            }, () => "late result", () => final = true, () => Interlocked.Increment(ref streamDisposals)),
+            () => Interlocked.Increment(ref recognizerDisposals));
+        Task? disposal = null;
+        try
+        {
+            transcriber.BeginSession();
+            if (!finalDecode) transcriber.AcceptAudio(new float[160]);
+            using var cancellation = new CancellationTokenSource();
+            var completion = transcriber.CompleteSessionAsync(cancellation.Token);
+            await entered.Task.WaitAsync(TimeSpan.FromSeconds(5));
+            cancellation.Cancel();
+            await Should.ThrowAsync<OperationCanceledException>(() => completion);
+            Should.Throw<InvalidOperationException>(transcriber.BeginSession);
+            var cancelled = transcriber.CancelSessionAsync();
+            disposal = Task.Run(() => { disposalStarted.SetResult(); transcriber.Dispose(); });
+            await disposalStarted.Task.WaitAsync(TimeSpan.FromSeconds(5));
+            cancelled.IsCompleted.ShouldBeFalse();
+            streamDisposals.ShouldBe(0);
+            recognizerDisposals.ShouldBe(0);
+            unblock.Set();
+            await Task.WhenAll(cancelled, disposal).WaitAsync(TimeSpan.FromSeconds(5));
+            streamDisposals.ShouldBe(1);
+            recognizerDisposals.ShouldBe(1);
+            transcriber.Dispose();
+            recognizerDisposals.ShouldBe(1);
+        }
+        finally
+        {
+            unblock.Set();
+            if (disposal != null) await disposal.WaitAsync(TimeSpan.FromSeconds(5));
+            transcriber.Dispose();
+        }
+    }
+}

From c1cae6adaa990e2e8429717d86e30b05e9b5dd9a Mon Sep 17 00:00:00 2001
From: devjenjen <devjenjen@gmail.com>
Date: Tue, 27 Oct 2026 02:14:28 +0100
Subject: [PATCH 6/9] fix(audio): bound recording and streaming backlog with
 explicit recovery

---
 windows/src/Murmur.App/App.axaml.cs           |  10 +-
 .../Localization/UiTextResources.de.resx      |   3 +
 .../Localization/UiTextResources.resx         |   3 +
 .../src/Murmur.App/Views/HudWindow.axaml.cs   |   8 +-
 .../Abstractions/IStreamingTranscriber.cs     |   4 +-
 .../src/Murmur.Core/DictationController.cs    |  40 ++++-
 .../Audio/WasapiAudioCapture.cs               |  17 +-
 .../NemotronStreamingTranscriber.cs           |  87 ++++++++--
 .../ControllerRetirementTests.cs              |   6 +
 .../Murmur.App.Tests/RobustnessNoticeTests.cs |  52 ++++++
 .../DictationAudioBoundsTests.cs              | 151 ++++++++++++++++++
 .../DictationControllerTests.cs               |   8 +-
 .../DictationLifecycleTests.cs                |  11 +-
 .../WasapiAudioCaptureTests.cs                |  24 +++
 .../NativeSessionLifetimeTests.cs             |  57 ++++++-
 .../StreamingAudioBoundsTests.cs              |  94 +++++++++++
 16 files changed, 532 insertions(+), 43 deletions(-)
 create mode 100644 windows/tests/Murmur.App.Tests/RobustnessNoticeTests.cs
 create mode 100644 windows/tests/Murmur.Core.Tests/DictationAudioBoundsTests.cs
 create mode 100644 windows/tests/Murmur.Speech.Tests/StreamingAudioBoundsTests.cs

diff --git a/windows/src/Murmur.App/App.axaml.cs b/windows/src/Murmur.App/App.axaml.cs
index 8a3e3ff..33ac969 100644
--- a/windows/src/Murmur.App/App.axaml.cs
+++ b/windows/src/Murmur.App/App.axaml.cs
@@ -516,6 +516,11 @@ private async Task DisposeControllerAsync()
         finally
         {
             _recognitionBlocked |= owner?.RequiresRestart == true;
+            if (owner?.RequiresRestart == true && !string.IsNullOrWhiteSpace(owner.CurrentTranscript))
+            {
+                _recoveryTranscript = owner.CurrentTranscript;
+                _settingsWindow?.SetRecoveryTranscript(_recoveryTranscript);
+            }
             unsubscribe?.Invoke();
         }
         if (_recognitionBlocked) throw new InvalidOperationException(UiText.Text("RecognitionRestartRequired"));
@@ -539,7 +544,7 @@ void Post(Action action)
             Post(() =>
             {
                 AppLogger.Log($"StateChanged: {state.Status}");
-                if (state.Status == DictationStatus.Error && !string.IsNullOrWhiteSpace(text))
+                if (state.Status == DictationStatus.Error && state.Message != "RecordingDurationLimit" && !string.IsNullOrWhiteSpace(text))
                 {
                     _recoveryTranscript = text;
                     _settingsWindow?.SetRecoveryTranscript(text);
@@ -621,6 +626,9 @@ private static DictationState LocalizeDictationState(DictationState state)
             "TextTargetChanged" => UiText.TextTargetChanged,
             "TextModifierHeld" => UiText.TextModifierHeld,
             "RecognitionRestartRequired" => UiText.Text("RecognitionRestartRequired"),
+            "StreamingBacklogExceeded" => UiText.Text("StreamingBacklogExceeded"),
+            "StreamingRecognitionFailed" => UiText.Text("StreamingRecognitionFailed"),
+            "RecordingDurationLimit" => UiText.Text("RecordingDurationLimit"),
             _ => state.Message
         };
         return string.Equals(localized, state.Message, StringComparison.Ordinal)
diff --git a/windows/src/Murmur.App/Localization/UiTextResources.de.resx b/windows/src/Murmur.App/Localization/UiTextResources.de.resx
index fe1a41c..13b3981 100644
--- a/windows/src/Murmur.App/Localization/UiTextResources.de.resx
+++ b/windows/src/Murmur.App/Localization/UiTextResources.de.resx
@@ -216,4 +216,7 @@
   <data name="DictionaryCorrectionExample" xml:space="preserve"><value>z. B. cloud code</value></data>
   <data name="Confirm" xml:space="preserve"><value>Bestätigen</value></data>
   <data name="RecognitionRestartRequired" xml:space="preserve"><value>Die Spracherkennung konnte nicht sicher beendet werden. Bitte Murmur vor dem nächsten Diktat oder Modellwechsel neu starten. Geretteter Teiltext ist unvollständig.</value></data>
+  <data name="StreamingBacklogExceeded" xml:space="preserve"><value>Erkennung kam nicht hinterher. Aufnahme gestoppt; wiederhergestellter Text ist unvollständig. Bitte kürzer diktieren.</value></data>
+  <data name="StreamingRecognitionFailed" xml:space="preserve"><value>Streaming-Erkennung fehlgeschlagen. Aufnahme gestoppt; wiederhergestellter Text ist unvollständig. Bitte erneut versuchen.</value></data>
+  <data name="RecordingDurationLimit" xml:space="preserve"><value>Fünf-Minuten-Grenze erreicht. Aufnahme automatisch gestoppt. Ergebnis prüfen; danach gesprochene Wörter wurden nicht aufgenommen.</value></data>
 </root>
diff --git a/windows/src/Murmur.App/Localization/UiTextResources.resx b/windows/src/Murmur.App/Localization/UiTextResources.resx
index e392fc0..692237e 100644
--- a/windows/src/Murmur.App/Localization/UiTextResources.resx
+++ b/windows/src/Murmur.App/Localization/UiTextResources.resx
@@ -216,4 +216,7 @@
   <data name="DictionaryCorrectionExample" xml:space="preserve"><value>e.g. cloud code</value></data>
   <data name="Confirm" xml:space="preserve"><value>Confirm</value></data>
   <data name="RecognitionRestartRequired" xml:space="preserve"><value>Speech recognition did not finish safely. Please restart Murmur before dictating or changing models. Any recovered partial text is incomplete.</value></data>
+  <data name="StreamingBacklogExceeded" xml:space="preserve"><value>Recognition could not keep up. Recording stopped; recovered text is incomplete. Please try a shorter dictation.</value></data>
+  <data name="StreamingRecognitionFailed" xml:space="preserve"><value>Streaming recognition failed. Recording stopped; recovered text is incomplete. Please try again.</value></data>
+  <data name="RecordingDurationLimit" xml:space="preserve"><value>Five-minute limit reached. Recording stopped automatically. Check the result; words spoken after stopping were not recorded.</value></data>
 </root>
diff --git a/windows/src/Murmur.App/Views/HudWindow.axaml.cs b/windows/src/Murmur.App/Views/HudWindow.axaml.cs
index d3d2d5e..4e40d89 100644
--- a/windows/src/Murmur.App/Views/HudWindow.axaml.cs
+++ b/windows/src/Murmur.App/Views/HudWindow.axaml.cs
@@ -688,7 +688,11 @@ public void RefreshLocalizedLabels()
                     break;
                 case DictationStatus.Finishing:
                     TelemetryBadge.Text = UiText.HudProc;
-                    if (string.IsNullOrWhiteSpace(_lastTranscript))
+                    if (!string.IsNullOrWhiteSpace(_lastErrorMessage))
+                    {
+                        UpdateTranscriptText(_lastErrorMessage);
+                    }
+                    else if (string.IsNullOrWhiteSpace(_lastTranscript))
                     {
                         UpdateTranscriptText(UiText.HudTranscribing);
                     }
@@ -861,7 +865,7 @@ _lastStatus is null ||
 
                     preview = BuildTranscriptTail(transcript, 15);
                     UpdateTranscriptText(
-                        string.IsNullOrWhiteSpace(preview)
+                        !string.IsNullOrWhiteSpace(state.Message) ? state.Message : string.IsNullOrWhiteSpace(preview)
                             ? UiText.HudTranscribing
                             : preview);
 
diff --git a/windows/src/Murmur.Core/Abstractions/IStreamingTranscriber.cs b/windows/src/Murmur.Core/Abstractions/IStreamingTranscriber.cs
index 3b8b943..647abd1 100644
--- a/windows/src/Murmur.Core/Abstractions/IStreamingTranscriber.cs
+++ b/windows/src/Murmur.Core/Abstractions/IStreamingTranscriber.cs
@@ -8,8 +8,8 @@ public interface IStreamingTranscriber : ITranscriber
     /// <summary>Fired when a new intermediate partial transcript is available.</summary>
     event Action<string>? PartialTranscriptChanged;
 
-    /// <summary>Begins a new live streaming recognition session.</summary>
-    void BeginSession();
+    /// <summary>Begins a session; reports worker/backlog failure without waiting for completion.</summary>
+    void BeginSession(Action<Exception>? onFailure = null);
 
     /// <summary>Feeds audio samples into the active streaming session.</summary>
     void AcceptAudio(ReadOnlyMemory<float> audioSamples);
diff --git a/windows/src/Murmur.Core/DictationController.cs b/windows/src/Murmur.Core/DictationController.cs
index 3455d39..5a05db1 100644
--- a/windows/src/Murmur.Core/DictationController.cs
+++ b/windows/src/Murmur.Core/DictationController.cs
@@ -36,6 +36,7 @@ private sealed class ActiveSessionState(RuntimeState runtime, TextInjectionTarge
         public long SampleCount { get; set; }
         public Task InFlight { get; set; } = Task.CompletedTask;
         public bool Ended { get; set; }
+        public bool DurationLimited { get; set; }
     }
 
     private readonly IAudioCapture _audioCapture;
@@ -51,6 +52,7 @@ private sealed class ActiveSessionState(RuntimeState runtime, TextInjectionTarge
 
     private readonly List<float> _audioBuffer = [];
     private const int RetainedAudioCapacity = 16000 * 30;
+    private const int MaximumRecordingSamples = 16000 * 60 * 5;
     private readonly Lock _lock = new();
     private Task _sessionTask = Task.CompletedTask;
     private Task? _stopTask;
@@ -316,7 +318,13 @@ private void OnHotkeyPressed()
         try
         {
             if (!IsCurrentSession(session)) return;
-            _streamingTranscriber?.BeginSession();
+            _streamingTranscriber?.BeginSession(ex =>
+            {
+                lock (_lock)
+                {
+                    if (IsCurrent(session)) BeginAbort(session, ex);
+                }
+            });
             _audioCapture.Start();
             lock (_lock)
             {
@@ -582,6 +590,7 @@ private void EndSession(ActiveSessionState session, string? error)
                 LevelChanged?.Invoke(0);
                 error = _requiresRestart ? "RecognitionRestartRequired"
                     : session.Failure is { } failure ? GetErrorMessage(failure, "Microphone error") : error;
+                error ??= session.DurationLimited ? "RecordingDurationLimit" : null;
                 SetState(error == null ? DictationState.Idle : DictationState.ErrorState(error));
             }
             session.Ended = true;
@@ -593,10 +602,27 @@ private void OnAudioChunkAvailable(ReadOnlyMemory<float> chunk)
     {
         lock (_lock)
         {
-            if (_activeSessionState is not { } session || !IsCurrent(session) || !State.IsActive) return;
-            session.SampleCount += chunk.Length;
-            if (_streamingTranscriber is null) _audioBuffer.AddRange(chunk.Span);
-            _streamingTranscriber?.AcceptAudio(chunk);
+            if (_activeSessionState is not { } session || !IsCurrent(session) || !State.IsActive || session.DurationLimited) return;
+            try
+            {
+                var count = (int)Math.Min(chunk.Length, MaximumRecordingSamples - session.SampleCount);
+                var accepted = chunk[..count];
+                if (_streamingTranscriber is null) _audioBuffer.AddRange(accepted.Span);
+                else _streamingTranscriber.AcceptAudio(accepted);
+                session.SampleCount += count;
+                if (session.SampleCount == MaximumRecordingSamples)
+                {
+                    session.DurationLimited = true;
+                    if (!session.WorkStarted)
+                    {
+                        session.ReleasedAt = Stopwatch.GetTimestamp();
+                        session.WorkStarted = true;
+                        SetState(new DictationState(DictationStatus.Finishing, "RecordingDurationLimit"));
+                        _sessionTask = Task.Run(() => FinishSessionAsync(session, session.Cancellation.Token));
+                    }
+                }
+            }
+            catch (Exception ex) { BeginAbort(session, ex); }
         }
     }
 
@@ -637,7 +663,9 @@ mode is TextInsertionMode.AtCaret or TextInsertionMode.DocumentEnd
             : TextInsertionMode.DocumentEnd;
 
     private static string GetErrorMessage(Exception exception, string fallbackPrefix) =>
-        exception is TextInjectionException injection
+        exception.Message is "StreamingBacklogExceeded" or "StreamingRecognitionFailed"
+            ? exception.Message
+            : exception is TextInjectionException injection
             ? injection.UserMessageKey
             : $"{fallbackPrefix}: {exception.Message}";
 
diff --git a/windows/src/Murmur.Platform.Windows/Audio/WasapiAudioCapture.cs b/windows/src/Murmur.Platform.Windows/Audio/WasapiAudioCapture.cs
index 11d341c..8da5ab9 100644
--- a/windows/src/Murmur.Platform.Windows/Audio/WasapiAudioCapture.cs
+++ b/windows/src/Murmur.Platform.Windows/Audio/WasapiAudioCapture.cs
@@ -164,13 +164,8 @@ public async Task StopAsync(CancellationToken cancellationToken = default)
         TaskCompletionSource? stoppedTask;
         lock (_lock)
         {
-            if (!IsRunning || _capture == null)
-            {
-                return;
-            }
-
             stoppedTask = _stopped;
-            _capture.StopRecording();
+            if (IsRunning && _capture != null) _capture.StopRecording();
         }
 
         if (stoppedTask != null)
@@ -182,8 +177,10 @@ public async Task StopAsync(CancellationToken cancellationToken = default)
     private void OnRecordingStopped(object? sender, StoppedEventArgs e)
     {
         var failure = e.Exception;
+        TaskCompletionSource? stopped;
         lock (_lock)
         {
+            stopped = _stopped;
             IsRunning = false;
             LastSessionStats = new AudioCaptureStats(
                 _outputSamples == 0 ? 0 : Math.Sqrt(_sumOfSquares / _outputSamples),
@@ -193,14 +190,14 @@ private void OnRecordingStopped(object? sender, StoppedEventArgs e)
             _normalizer = null;
             LevelChanged?.Invoke(0);
 
-            _stopped?.TrySetResult();
         }
 
-        if (failure != null)
+        try
         {
-            CaptureFailed?.Invoke(failure);
+            if (failure != null) CaptureFailed?.Invoke(failure);
+            SessionStopped?.Invoke();
         }
-        SessionStopped?.Invoke();
+        finally { stopped?.TrySetResult(); }
     }
 
     private void OnDataAvailable(object? sender, WaveInEventArgs e)
diff --git a/windows/src/Murmur.Speech/NemotronStreamingTranscriber.cs b/windows/src/Murmur.Speech/NemotronStreamingTranscriber.cs
index a405138..e35cb7d 100644
--- a/windows/src/Murmur.Speech/NemotronStreamingTranscriber.cs
+++ b/windows/src/Murmur.Speech/NemotronStreamingTranscriber.cs
@@ -14,18 +14,28 @@ internal sealed record NativeSession(Action<float[]> Accept, Func<bool> IsReady,
     private readonly Func<NativeSession> _createStream;
     private readonly Action _disposeRecognizer;
     private readonly Lock _lock = new();
-    private sealed class StreamingSession(NativeSession stream, Channel<float[]> channel)
+    private const int MaximumPendingSamples = 144000;
+    private const int MaximumPendingItems = 1024;
+    private sealed class StreamingSession(NativeSession stream, Channel<float[]> channel, Action<Exception>? onFailure)
     {
         public NativeSession Stream { get; } = stream;
         public Channel<float[]> Channel { get; } = channel;
         public Task Worker { get; set; } = Task.CompletedTask;
         public int Cancelled;
+        public Action<Exception>? OnFailure { get; } = onFailure;
+        public Exception? Failure;
+        public int PendingSamples;
+        public int PendingItems;
     }
 
     private StreamingSession? _session;
     private Task<string>? _closeTask;
     private Task? _disposeTask;
     private bool _disposed;
+    internal (int Samples, int Items) PendingAudio
+    {
+        get { lock (_lock) return _session is { } s ? (s.PendingSamples, s.PendingItems) : (0, 0); }
+    }
 
     /// <inheritdoc />
     public event Action<string>? PartialTranscriptChanged;
@@ -76,7 +86,7 @@ internal NemotronStreamingTranscriber(Func<NativeSession> createStream, Action d
     }
 
     /// <inheritdoc />
-    public void BeginSession()
+    public void BeginSession(Action<Exception>? onFailure = null)
     {
         lock (_lock)
         {
@@ -91,12 +101,13 @@ public void BeginSession()
             var sessionStream = _createStream();
             try
             {
-                var sessionChannel = Channel.CreateUnbounded<float[]>(new UnboundedChannelOptions
+                var sessionChannel = Channel.CreateBounded<float[]>(new BoundedChannelOptions(MaximumPendingItems)
                 {
                     SingleReader = true,
-                    SingleWriter = false
+                    SingleWriter = false,
+                    FullMode = BoundedChannelFullMode.Wait
                 });
-                var session = new StreamingSession(sessionStream, sessionChannel);
+                var session = new StreamingSession(sessionStream, sessionChannel, onFailure);
                 _session = session;
                 session.Worker = Task.Run(() => ProcessAudioLoopAsync(session));
             }
@@ -117,10 +128,39 @@ public void AcceptAudio(ReadOnlyMemory<float> audioSamples)
         {
             if (_disposed || _closeTask != null || _session is not { } session ||
                 Volatile.Read(ref session.Cancelled) != 0) return;
-            session.Channel.Writer.TryWrite(audioSamples.ToArray());
+            // Include the item being decoded; check before allocating or adding to the budget.
+            if (audioSamples.Length > MaximumPendingSamples - session.PendingSamples ||
+                session.PendingItems >= MaximumPendingItems)
+            {
+                FailSessionLocked(session, new InvalidOperationException("StreamingBacklogExceeded"));
+                return;
+            }
+            var copy = audioSamples.ToArray();
+            session.PendingSamples += copy.Length;
+            session.PendingItems++;
+            if (!session.Channel.Writer.TryWrite(copy))
+            {
+                session.PendingSamples -= copy.Length;
+                session.PendingItems--;
+                FailSessionLocked(session, new InvalidOperationException("StreamingBacklogExceeded"));
+            }
         }
     }
 
+    private static void FailSessionLocked(StreamingSession session, Exception failure)
+    {
+        if (session.Failure != null) return;
+        session.Failure = failure;
+        Volatile.Write(ref session.Cancelled, 1);
+        session.Channel.Writer.TryComplete();
+        // Controller capture and native locks have opposite entry paths: never notify under this lock.
+        ThreadPool.QueueUserWorkItem(_ =>
+        {
+            try { session.OnFailure?.Invoke(failure); }
+            catch { /* A notification must not escape into the capture/worker thread. */ }
+        });
+    }
+
     private async Task ProcessAudioLoopAsync(StreamingSession session)
     {
         var stream = session.Stream;
@@ -129,18 +169,29 @@ private async Task ProcessAudioLoopAsync(StreamingSession session)
         {
             await foreach (var samples in session.Channel.Reader.ReadAllAsync().ConfigureAwait(false))
             {
-                if (Volatile.Read(ref session.Cancelled) != 0) return;
-                stream.Accept(samples);
-                while (Volatile.Read(ref session.Cancelled) == 0 && stream.IsReady())
+                try
                 {
-                    stream.Decode();
                     if (Volatile.Read(ref session.Cancelled) != 0) return;
-                    var text = stream.GetText();
-                    if (text.Length > 0 && !string.Equals(text, lastPartial, StringComparison.Ordinal) &&
-                        Volatile.Read(ref session.Cancelled) == 0)
+                    stream.Accept(samples);
+                    while (Volatile.Read(ref session.Cancelled) == 0 && stream.IsReady())
                     {
-                        lastPartial = text;
-                        PartialTranscriptChanged?.Invoke(text);
+                        stream.Decode();
+                        if (Volatile.Read(ref session.Cancelled) != 0) return;
+                        var text = stream.GetText();
+                        if (text.Length > 0 && !string.Equals(text, lastPartial, StringComparison.Ordinal) &&
+                            Volatile.Read(ref session.Cancelled) == 0)
+                        {
+                            lastPartial = text;
+                            PartialTranscriptChanged?.Invoke(text);
+                        }
+                    }
+                }
+                finally
+                {
+                    lock (_lock)
+                    {
+                        session.PendingSamples -= samples.Length;
+                        session.PendingItems--;
                     }
                 }
             }
@@ -149,6 +200,10 @@ private async Task ProcessAudioLoopAsync(StreamingSession session)
         {
             // Normal channel completion
         }
+        catch (Exception ex)
+        {
+            lock (_lock) FailSessionLocked(session, new InvalidOperationException("StreamingRecognitionFailed", ex));
+        }
     }
 
     /// <inheritdoc />
@@ -205,6 +260,7 @@ private async Task<string> FinishClosingSessionAsync(StreamingSession session, b
         try
         {
             await session.Worker.ConfigureAwait(false);
+            if (session.Failure is { } failure) throw failure;
 
             if (decodeFinal && Volatile.Read(ref session.Cancelled) == 0)
             {
@@ -257,6 +313,7 @@ public void Dispose()
             _disposeTask ??= Task.Run(async () =>
             {
                 try { await CancelSessionAsync().ConfigureAwait(false); }
+                catch { /* Cleanup observes the session failure already delivered to the caller. */ }
                 finally { _disposeRecognizer(); }
             });
             disposing = _disposeTask;
diff --git a/windows/tests/Murmur.App.Tests/ControllerRetirementTests.cs b/windows/tests/Murmur.App.Tests/ControllerRetirementTests.cs
index bb316f5..ed183b6 100644
--- a/windows/tests/Murmur.App.Tests/ControllerRetirementTests.cs
+++ b/windows/tests/Murmur.App.Tests/ControllerRetirementTests.cs
@@ -54,6 +54,8 @@ public async Task ModelSwitchCannotCreateReplacementAfterBoundedControllerDispos
         const BindingFlags flags = BindingFlags.Instance | BindingFlags.NonPublic;
         var app = Application.Current.ShouldBeOfType<App>();
         var ownerField = typeof(App).GetField("_controller", flags)!;
+        var recoveryField = typeof(App).GetField("_recoveryTranscript", flags)!;
+        var previousRecovery = recoveryField.GetValue(app);
         ownerField.GetValue(app).ShouldBeNull();
         var audio = new Audio();
         var keys = new Keys();
@@ -68,10 +70,13 @@ public async Task ModelSwitchCannotCreateReplacementAfterBoundedControllerDispos
         {
             controller.Start(); keys.Press(); keys.Release();
             await native.Entered.Task.WaitAsync(TimeSpan.FromSeconds(5));
+            typeof(DictationController).GetProperty(nameof(DictationController.CurrentTranscript))!
+                .SetValue(controller, "incomplete recovery");
             expire = true;
             var retirement = (Task)typeof(App).GetMethod("DisposeControllerAsync", flags)!.Invoke(app, null)!;
             await Should.ThrowAsync<InvalidOperationException>(() => retirement);
             typeof(App).GetField("_recognitionBlocked", flags)!.GetValue(app).ShouldBe(true);
+            recoveryField.GetValue(app).ShouldBe("incomplete recovery");
             native.Disposals.ShouldBe(0);
             audio.Disposals.ShouldBe(0);
             await (Task)typeof(App).GetMethod("StartControllerAsync", flags)!.Invoke(app, null)!;
@@ -90,6 +95,7 @@ public async Task ModelSwitchCannotCreateReplacementAfterBoundedControllerDispos
             await ((Task)typeof(DictationController).GetProperty("DisposalCompletion", flags)!
                 .GetValue(controller)!).WaitAsync(TimeSpan.FromSeconds(5));
             ownerField.SetValue(app, null);
+            recoveryField.SetValue(app, previousRecovery);
             typeof(App).GetField("_recognitionBlocked", flags)!.SetValue(app, false);
         }
     }
diff --git a/windows/tests/Murmur.App.Tests/RobustnessNoticeTests.cs b/windows/tests/Murmur.App.Tests/RobustnessNoticeTests.cs
new file mode 100644
index 0000000..f64a6d4
--- /dev/null
+++ b/windows/tests/Murmur.App.Tests/RobustnessNoticeTests.cs
@@ -0,0 +1,52 @@
+using System.Reflection;
+using Avalonia.Controls;
+using Avalonia.Headless.XUnit;
+using Avalonia.Threading;
+using Murmur.App.Localization;
+using Murmur.App.Views;
+using Murmur.Core.State;
+using Shouldly;
+using Xunit;
+
+namespace Murmur.App.Tests;
+
+public class RobustnessNoticeTests
+{
+    [Theory]
+    [InlineData("RecordingDurationLimit")]
+    [InlineData("StreamingBacklogExceeded")]
+    [InlineData("StreamingRecognitionFailed")]
+    [InlineData("RecognitionRestartRequired")]
+    public void SafetyNoticesResolveInBothLanguages(string key)
+    {
+        var method = typeof(App).GetMethod("LocalizeDictationState", BindingFlags.Static | BindingFlags.NonPublic)!;
+        try
+        {
+            UiText.SetLanguage(UiLanguage.German);
+            var german = (DictationState)method.Invoke(null, [DictationState.ErrorState(key)])!;
+            german.Message.ShouldNotBe(key);
+            UiText.SetLanguage(UiLanguage.English);
+            var english = (DictationState)method.Invoke(null, [DictationState.ErrorState(key)])!;
+            english.Message.ShouldNotBe(key);
+            english.Message.ShouldNotBe(german.Message);
+        }
+        finally { UiText.SetLanguage(UiLanguage.English); }
+    }
+
+    [AvaloniaFact]
+    public void DurationNoticeIsVisibleWhileFinishingThenInError()
+    {
+        var hud = new HudWindow();
+        var message = UiText.Text("RecordingDurationLimit");
+        try
+        {
+            hud.UpdateState(new DictationState(DictationStatus.Finishing, message), 0, "partial");
+            Dispatcher.UIThread.RunJobs();
+            hud.FindControl<TextBlock>("TranscriptText")!.Text.ShouldBe(message);
+            hud.UpdateState(DictationState.ErrorState(message), 0, "final");
+            Dispatcher.UIThread.RunJobs();
+            hud.FindControl<TextBlock>("TranscriptText")!.Text.ShouldNotBeNull().ShouldContain(message);
+        }
+        finally { hud.Close(); }
+    }
+}
diff --git a/windows/tests/Murmur.Core.Tests/DictationAudioBoundsTests.cs b/windows/tests/Murmur.Core.Tests/DictationAudioBoundsTests.cs
new file mode 100644
index 0000000..7c8dcfc
--- /dev/null
+++ b/windows/tests/Murmur.Core.Tests/DictationAudioBoundsTests.cs
@@ -0,0 +1,151 @@
+using Murmur.Core.Abstractions;
+using Murmur.Core.State;
+using Shouldly;
+using Xunit;
+
+namespace Murmur.Core.Tests;
+
+public partial class DictationControllerTests
+{
+    private sealed class EdgeHotkey : IHotkeySource
+    {
+        private bool _pressed;
+        public event Action? Pressed;
+        public event Action? Released;
+        public void Press() { if (!_pressed) { _pressed = true; Pressed?.Invoke(); } }
+        public void Release() { if (_pressed) { _pressed = false; Released?.Invoke(); } }
+        public void Start() { }
+        public void Stop() { }
+        public void Dispose() { }
+    }
+
+    [Theory]
+    [InlineData(4800000)]
+    [InlineData(4800001)]
+    [InlineData(5000000)]
+    public async Task DurationLimitAutoFinishesAtExactBoundaryWithoutWaitingInCallback(int length)
+    {
+        var audio = new FakeAudioCapture { DelayStop = true };
+        var keys = new EdgeHotkey();
+        var transcriber = new SpyTranscriber();
+        var injector = new FakeTextInjector();
+        await using var controller = new DictationController(audio, keys, transcriber, injector, "fake");
+        try
+        {
+            controller.Start(); keys.Press();
+            audio.EmitChunk(new float[length]);
+            controller.State.Status.ShouldBe(DictationStatus.Finishing);
+            controller.State.Message.ShouldBe("RecordingDurationLimit");
+            controller.SessionCompletion.IsCompleted.ShouldBeFalse();
+            transcriber.TranscribeCalls.ShouldBe(0);
+            audio.EmitChunk(new float[20]);
+            audio.StopGate.TrySetResult();
+            await controller.SessionCompletion.WaitAsync(TimeSpan.FromSeconds(5));
+            transcriber.LastSampleCount.ShouldBe(4800000);
+            injector.Injected.Count.ShouldBe(1);
+            controller.State.Message.ShouldBe("RecordingDurationLimit");
+            // Match the production hook's existing key-down deduplication after automatic stop.
+            keys.Press();
+            controller.State.Status.ShouldBe(DictationStatus.Error);
+            keys.Release(); keys.Press();
+            controller.State.Status.ShouldBe(DictationStatus.Listening);
+            audio.EmitChunk(new float[1]); keys.Release();
+            await controller.SessionCompletion.WaitAsync(TimeSpan.FromSeconds(5));
+            transcriber.LastSampleCount.ShouldBe(1);
+        }
+        finally { audio.StopGate.TrySetResult(); }
+    }
+
+    [Fact]
+    public async Task StreamingFailureStopsCaptureOffCallbackAndPreservesIncompletePartial()
+    {
+        var audio = new FakeAudioCapture { DelayStop = true };
+        var keys = new FakeHotkeySource();
+        var transcriber = new FakeStreamingTranscriber("must not insert");
+        var injector = new FakeTextInjector();
+        await using var controller = new DictationController(audio, keys, transcriber, injector, "fake");
+        try
+        {
+            controller.Start(); keys.Press(); transcriber.EmitPartial("unvollstaendig");
+            transcriber.Fail(new InvalidOperationException("StreamingBacklogExceeded"));
+            controller.State.Status.ShouldBe(DictationStatus.Error);
+            controller.State.Message.ShouldBe("StreamingBacklogExceeded");
+            controller.CurrentTranscript.ShouldBe("unvollstaendig");
+            controller.SessionCompletion.IsCompleted.ShouldBeFalse();
+            injector.Injected.ShouldBeEmpty();
+            audio.StopGate.TrySetResult();
+            await controller.SessionCompletion.WaitAsync(TimeSpan.FromSeconds(5));
+            controller.RequiresRestart.ShouldBeFalse();
+            keys.Press(); controller.State.Status.ShouldBe(DictationStatus.Listening);
+        }
+        finally { audio.StopGate.TrySetResult(); }
+    }
+
+    [Fact]
+    public async Task AcceptAudioExceptionCannotEscapeCaptureCallback()
+    {
+        var audio = new FakeAudioCapture();
+        var keys = new FakeHotkeySource();
+        var transcriber = new FakeStreamingTranscriber("must not insert") { AcceptFailure = new IOException("queue failed") };
+        var injector = new FakeTextInjector();
+        await using var controller = new DictationController(audio, keys, transcriber, injector, "fake");
+        controller.Start(); keys.Press();
+        Should.NotThrow(() => audio.EmitChunk(new float[1]));
+        await controller.SessionCompletion.WaitAsync(TimeSpan.FromSeconds(5));
+        controller.State.Status.ShouldBe(DictationStatus.Error);
+        injector.Injected.ShouldBeEmpty();
+    }
+
+    [Fact]
+    public async Task BelowDurationLimitKeepsListeningUntilRelease()
+    {
+        var audio = new FakeAudioCapture();
+        var keys = new EdgeHotkey();
+        var transcriber = new SpyTranscriber();
+        await using var controller = new DictationController(audio, keys, transcriber, new FakeTextInjector(), "fake");
+        controller.Start(); keys.Press();
+        audio.EmitChunk(new float[4799999]);
+        controller.State.Status.ShouldBe(DictationStatus.Listening);
+        keys.Release();
+        await controller.SessionCompletion.WaitAsync(TimeSpan.FromSeconds(5));
+        transcriber.LastSampleCount.ShouldBe(4799999);
+        controller.State.ShouldBe(DictationState.Idle);
+    }
+
+    [Fact]
+    public async Task StreamingDurationAutoFinishDoesNotAcceptPostLimitSamples()
+    {
+        var audio = new FakeAudioCapture();
+        var keys = new EdgeHotkey();
+        var transcriber = new FakeStreamingTranscriber("complete to the limit");
+        var injector = new FakeTextInjector();
+        await using var controller = new DictationController(audio, keys, transcriber, injector, "fake");
+        controller.Start(); keys.Press();
+        var chunk = new float[16000];
+        for (var i = 0; i < 300; i++) audio.EmitChunk(chunk);
+        audio.EmitChunk(chunk);
+        await controller.SessionCompletion.WaitAsync(TimeSpan.FromSeconds(5));
+        transcriber.AcceptedSamples.Count.ShouldBe(4800000);
+        injector.Injected.Count.ShouldBe(1);
+        controller.State.Message.ShouldBe("RecordingDurationLimit");
+    }
+
+    [Fact]
+    public async Task OldStreamingFailureCallbackCannotAbortNewSession()
+    {
+        var audio = new FakeAudioCapture();
+        var keys = new FakeHotkeySource();
+        var transcriber = new FakeStreamingTranscriber("next");
+        await using var controller = new DictationController(audio, keys, transcriber, new FakeTextInjector(), "fake");
+        controller.Start(); keys.Press();
+        var oldCallback = transcriber.FailureCallback!;
+        transcriber.Fail(new InvalidOperationException("StreamingRecognitionFailed"));
+        await controller.SessionCompletion.WaitAsync(TimeSpan.FromSeconds(5));
+        keys.Press();
+        oldCallback(new IOException("late old failure"));
+        controller.State.Status.ShouldBe(DictationStatus.Listening);
+        audio.EmitChunk(new float[1]); keys.Release();
+        await controller.SessionCompletion.WaitAsync(TimeSpan.FromSeconds(5));
+        controller.State.ShouldBe(DictationState.Idle);
+    }
+}
diff --git a/windows/tests/Murmur.Core.Tests/DictationControllerTests.cs b/windows/tests/Murmur.Core.Tests/DictationControllerTests.cs
index e7abdc3..9ab34ae 100644
--- a/windows/tests/Murmur.Core.Tests/DictationControllerTests.cs
+++ b/windows/tests/Murmur.Core.Tests/DictationControllerTests.cs
@@ -168,19 +168,25 @@ private sealed class FakeStreamingTranscriber : IStreamingTranscriber
         public List<float> AcceptedSamples { get; } = [];
         public bool SessionActive { get; private set; }
         public int CancelCalls { get; private set; }
+        public Exception? AcceptFailure { get; set; }
+        private Action<Exception>? _onFailure;
+        public Action<Exception>? FailureCallback => _onFailure;
+        public void Fail(Exception failure) => _onFailure?.Invoke(failure);
 
         public FakeStreamingTranscriber(string finalText)
         {
             _finalText = finalText;
         }
 
-        public void BeginSession()
+        public void BeginSession(Action<Exception>? onFailure = null)
         {
+            _onFailure = onFailure;
             SessionActive = true;
         }
 
         public void AcceptAudio(ReadOnlyMemory<float> audioSamples)
         {
+            if (AcceptFailure != null) throw AcceptFailure;
             AcceptedSamples.AddRange(audioSamples.Span);
         }
 
diff --git a/windows/tests/Murmur.Core.Tests/DictationLifecycleTests.cs b/windows/tests/Murmur.Core.Tests/DictationLifecycleTests.cs
index 4741906..43a2044 100644
--- a/windows/tests/Murmur.Core.Tests/DictationLifecycleTests.cs
+++ b/windows/tests/Murmur.Core.Tests/DictationLifecycleTests.cs
@@ -52,9 +52,10 @@ public void Dispose()
     }
 
     [Theory]
-    [InlineData(false)]
-    [InlineData(true)]
-    public async Task DecodeDeadlineOrStopBudgetQuarantinesUntilRealCompletion(bool stopFirst)
+    [InlineData(false, 160, 60)]
+    [InlineData(true, 160, 60)]
+    [InlineData(false, 960000, 120)]
+    public async Task DecodeDeadlineOrStopBudgetQuarantinesUntilRealCompletion(bool stopFirst, int samples, int seconds)
     {
         var audio = new FakeAudioCapture();
         var hotkey = new FakeHotkeySource();
@@ -68,7 +69,7 @@ public async Task DecodeDeadlineOrStopBudgetQuarantinesUntilRealCompletion(bool
         {
             controller.Start();
             hotkey.Press();
-            audio.EmitChunk(new float[160]);
+            audio.EmitChunk(new float[samples]);
             hotkey.Release();
             var inference = await deadlines.NextAsync();
             if (inference.Budget == TimeSpan.FromSeconds(3))
@@ -76,7 +77,7 @@ public async Task DecodeDeadlineOrStopBudgetQuarantinesUntilRealCompletion(bool
                 await inference.Work.WaitAsync(TimeSpan.FromSeconds(5));
                 inference = await deadlines.NextAsync();
             }
-            inference.Budget.ShouldBe(TimeSpan.FromSeconds(60));
+            inference.Budget.ShouldBe(TimeSpan.FromSeconds(seconds));
             await transcriber.Entered.Task.WaitAsync(TimeSpan.FromSeconds(5));
             if (stopFirst)
             {
diff --git a/windows/tests/Murmur.Platform.Windows.Tests/WasapiAudioCaptureTests.cs b/windows/tests/Murmur.Platform.Windows.Tests/WasapiAudioCaptureTests.cs
index eb82e88..58423d7 100644
--- a/windows/tests/Murmur.Platform.Windows.Tests/WasapiAudioCaptureTests.cs
+++ b/windows/tests/Murmur.Platform.Windows.Tests/WasapiAudioCaptureTests.cs
@@ -8,6 +8,30 @@ namespace Murmur.Platform.Windows.Tests;
 
 public class WasapiAudioCaptureTests
 {
+    [Fact]
+    public async Task StopWaitsForWholeStoppedCallbackEvenAfterRunningFlagCleared()
+    {
+        using var capture = new WasapiAudioCapture();
+        using var release = new ManualResetEventSlim();
+        var entered = new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously);
+        var stopped = new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously);
+        var flags = BindingFlags.NonPublic | BindingFlags.Instance;
+        typeof(WasapiAudioCapture).GetField("_stopped", flags)!.SetValue(capture, stopped);
+        capture.CaptureFailed += _ => { entered.TrySetResult(); release.Wait(); };
+        var callback = Task.Run(() => typeof(WasapiAudioCapture).GetMethod("OnRecordingStopped", flags)!
+            .Invoke(capture, [null, new StoppedEventArgs(new IOException("fake stopped"))]));
+        try
+        {
+            await entered.Task.WaitAsync(TimeSpan.FromSeconds(5));
+            capture.IsRunning.ShouldBeFalse();
+            var stop = capture.StopAsync();
+            stop.IsCompleted.ShouldBeFalse();
+            release.Set();
+            await Task.WhenAll(stop, callback).WaitAsync(TimeSpan.FromSeconds(5));
+        }
+        finally { release.Set(); await callback.WaitAsync(TimeSpan.FromSeconds(5)); }
+    }
+
     [Theory]
     [InlineData(short.MinValue, -1f)]
     [InlineData(0, 0f)]
diff --git a/windows/tests/Murmur.Speech.Tests/NativeSessionLifetimeTests.cs b/windows/tests/Murmur.Speech.Tests/NativeSessionLifetimeTests.cs
index 30fd672..f213bc0 100644
--- a/windows/tests/Murmur.Speech.Tests/NativeSessionLifetimeTests.cs
+++ b/windows/tests/Murmur.Speech.Tests/NativeSessionLifetimeTests.cs
@@ -20,6 +20,7 @@ public event Action<Exception>? CaptureFailed { add { } remove { } }
         public AudioCaptureStats? LastSessionStats => null;
         public void Start() => IsRunning = true;
         public void Emit() => AudioChunkAvailable?.Invoke(new float[160]);
+        public void Emit(float[] samples) => AudioChunkAvailable?.Invoke(samples);
         public Task StopAsync(CancellationToken cancellationToken = default) { IsRunning = false; return Task.CompletedTask; }
         public void Dispose() { }
     }
@@ -41,6 +42,60 @@ public void Insert(string text, TextInjectionTarget target, TextInsertionMode mo
             => Insertions++;
     }
 
+    [Fact]
+    public async Task BacklogStopsCaptureAndQuarantinesBlockedReaderWithoutInsertingPartial()
+    {
+        using var release = new ManualResetEventSlim();
+        var blocked = new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously);
+        var partial = new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously);
+        var restart = new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously);
+        var ready = false;
+        var chunks = 0;
+        var disposals = 0;
+        var native = new NemotronStreamingTranscriber(() => new(
+            _ => { chunks++; ready = true; }, () => ready,
+            () => { if (chunks == 2) { blocked.SetResult(); release.Wait(); } ready = false; },
+            () => "incomplete partial", () => { }, () => disposals++), () => { });
+        var audio = new Audio();
+        var keys = new Keys();
+        var injector = new Injector();
+        var controller = new DictationController(audio, keys, native, injector, "fake");
+        const BindingFlags flags = BindingFlags.NonPublic | BindingFlags.Instance;
+        Func<Task, TimeSpan, CancellationToken, Task> wait = (work, budget, cancellation) =>
+            blocked.Task.IsCompleted && budget == TimeSpan.FromSeconds(3)
+                ? Task.FromException(new TimeoutException()) : work.WaitAsync(cancellation);
+        typeof(DictationController).GetProperty("WaitForWorkAsync", flags)!.SetValue(controller, wait);
+        controller.TranscriptChanged += value => { if (value.Length > 0) partial.TrySetResult(); };
+        controller.StateChanged += state => { if (state.Message == "RecognitionRestartRequired") restart.TrySetResult(); };
+        try
+        {
+            controller.Start(); keys.Press(); audio.Emit();
+            await partial.Task.WaitAsync(TimeSpan.FromSeconds(5));
+            audio.Emit();
+            await blocked.Task.WaitAsync(TimeSpan.FromSeconds(5));
+            audio.Emit(new float[144001]);
+            await restart.Task.WaitAsync(TimeSpan.FromSeconds(5));
+            controller.RequiresRestart.ShouldBeTrue();
+            controller.CurrentTranscript.ShouldBe("incomplete partial");
+            injector.Insertions.ShouldBe(0);
+            await Should.ThrowAsync<TimeoutException>(() => controller.DisposeAsync().AsTask());
+            disposals.ShouldBe(0);
+            release.Set();
+            await ((Task)typeof(DictationController).GetProperty("DisposalCompletion", flags)!
+                .GetValue(controller)!).WaitAsync(TimeSpan.FromSeconds(5));
+            audio.IsRunning.ShouldBeFalse();
+            disposals.ShouldBe(1);
+            chunks.ShouldBe(2);
+        }
+        finally
+        {
+            release.Set();
+            try { await controller.DisposeAsync(); } catch (TimeoutException) { }
+            await ((Task)typeof(DictationController).GetProperty("DisposalCompletion", flags)!
+                .GetValue(controller)!).WaitAsync(TimeSpan.FromSeconds(5));
+        }
+    }
+
     [Fact]
     public async Task ControllerTimeoutRetainsNemotronFinalDecodeAndRecoveryUntilActualCleanup()
     {
@@ -138,7 +193,7 @@ public async Task ReaderOrFinalDecodeRetainsWholeNativeChainUntilActuallyReturne
             await entered.Task.WaitAsync(TimeSpan.FromSeconds(5));
             cancellation.Cancel();
             await Should.ThrowAsync<OperationCanceledException>(() => completion);
-            Should.Throw<InvalidOperationException>(transcriber.BeginSession);
+            Should.Throw<InvalidOperationException>(() => transcriber.BeginSession());
             var cancelled = transcriber.CancelSessionAsync();
             disposal = Task.Run(() => { disposalStarted.SetResult(); transcriber.Dispose(); });
             await disposalStarted.Task.WaitAsync(TimeSpan.FromSeconds(5));
diff --git a/windows/tests/Murmur.Speech.Tests/StreamingAudioBoundsTests.cs b/windows/tests/Murmur.Speech.Tests/StreamingAudioBoundsTests.cs
new file mode 100644
index 0000000..f6131e9
--- /dev/null
+++ b/windows/tests/Murmur.Speech.Tests/StreamingAudioBoundsTests.cs
@@ -0,0 +1,94 @@
+using Shouldly;
+using System.Buffers;
+using Xunit;
+
+namespace Murmur.Speech.Tests;
+
+public class StreamingAudioBoundsTests
+{
+    private sealed class UnreadableMemory(int length) : MemoryManager<float>
+    {
+        public Memory<float> Oversized => CreateMemory(length);
+        public override Span<float> GetSpan() => throw new InvalidOperationException("must check length before copy");
+        public override MemoryHandle Pin(int elementIndex = 0) => throw new NotSupportedException();
+        public override void Unpin() { }
+        protected override void Dispose(bool disposing) { }
+    }
+    [Theory]
+    [InlineData(false)]
+    [InlineData(true)]
+    public async Task OutstandingBudgetIncludesBlockedNativeItemAndRejectsNextChunk(bool tinyChunks)
+    {
+        using var release = new ManualResetEventSlim();
+        var entered = new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously);
+        var failed = new TaskCompletionSource<Exception>(TaskCreationOptions.RunContinuationsAsynchronously);
+        var disposed = 0;
+        var first = true;
+        using var transcriber = new NemotronStreamingTranscriber(() => new(
+            _ => { if (first) { first = false; entered.SetResult(); release.Wait(); } },
+            () => false, () => { }, () => "", () => { }, () => disposed++), () => { });
+        try
+        {
+            transcriber.BeginSession(ex => failed.TrySetResult(ex));
+            transcriber.AcceptAudio(new float[1]);
+            await entered.Task.WaitAsync(TimeSpan.FromSeconds(5));
+            if (tinyChunks)
+                for (var i = 1; i < 1024; i++) transcriber.AcceptAudio(new float[1]);
+            else transcriber.AcceptAudio(new float[143999]);
+            transcriber.PendingAudio.ShouldBe(tinyChunks ? (1024, 1024) : (144000, 2));
+            failed.Task.IsCompleted.ShouldBeFalse();
+            transcriber.AcceptAudio(new float[1]);
+            (await failed.Task.WaitAsync(TimeSpan.FromSeconds(5))).Message.ShouldBe("StreamingBacklogExceeded");
+            transcriber.PendingAudio.ShouldBe(tinyChunks ? (1024, 1024) : (144000, 2));
+            var cleanup = transcriber.CancelSessionAsync();
+            cleanup.IsCompleted.ShouldBeFalse();
+            disposed.ShouldBe(0);
+            release.Set();
+            await Should.ThrowAsync<InvalidOperationException>(() => cleanup);
+            disposed.ShouldBe(1);
+            transcriber.PendingAudio.ShouldBe((0, 0));
+            transcriber.BeginSession();
+            transcriber.AcceptAudio(new float[7]);
+            (await transcriber.CompleteSessionAsync()).ShouldBe("");
+            transcriber.PendingAudio.ShouldBe((0, 0));
+        }
+        finally { release.Set(); }
+    }
+
+    [Theory]
+    [InlineData(144001)]
+    [InlineData(int.MaxValue)]
+    public async Task OversizedSingleChunkFailsBeforeEnqueueAndDoesNotReturnPartialSuccess(int length)
+    {
+        var failed = new TaskCompletionSource<Exception>(TaskCreationOptions.RunContinuationsAsynchronously);
+        var accepts = 0;
+        using var transcriber = new NemotronStreamingTranscriber(() => new(
+            _ => accepts++, () => false, () => { }, () => "incomplete", () => { }, () => { }), () => { });
+        transcriber.BeginSession(ex => failed.TrySetResult(ex));
+        using var samples = new UnreadableMemory(length);
+        transcriber.AcceptAudio(samples.Oversized);
+        (await failed.Task.WaitAsync(TimeSpan.FromSeconds(5))).Message.ShouldBe("StreamingBacklogExceeded");
+        transcriber.PendingAudio.ShouldBe((0, 0));
+        await Should.ThrowAsync<InvalidOperationException>(() => transcriber.CompleteSessionAsync());
+        accepts.ShouldBe(0);
+    }
+
+    [Fact]
+    public async Task WorkerFailureSignalsImmediatelyWithoutCompleteAndNextSessionIsClean()
+    {
+        var failed = new TaskCompletionSource<Exception>(TaskCreationOptions.RunContinuationsAsynchronously);
+        var throwOnce = true;
+        var accepts = 0;
+        using var transcriber = new NemotronStreamingTranscriber(() => new(
+            _ => { accepts++; if (throwOnce) { throwOnce = false; throw new IOException("native failure"); } },
+            () => false, () => { }, () => "next", () => { }, () => { }), () => { });
+        transcriber.BeginSession(ex => failed.TrySetResult(ex));
+        transcriber.AcceptAudio(new float[3]);
+        (await failed.Task.WaitAsync(TimeSpan.FromSeconds(5))).Message.ShouldBe("StreamingRecognitionFailed");
+        await Should.ThrowAsync<InvalidOperationException>(() => transcriber.CancelSessionAsync());
+        transcriber.BeginSession();
+        transcriber.AcceptAudio(new float[1]);
+        (await transcriber.CompleteSessionAsync()).ShouldBe("next");
+        accepts.ShouldBe(2);
+    }
+}

From 2bc64524d46c4052426d7a3573b91bb819e5bc05 Mon Sep 17 00:00:00 2001
From: devjenjen <devjenjen@gmail.com>
Date: Tue, 27 Oct 2026 18:10:22 +0100
Subject: [PATCH 7/9] test(hud): remove timing dependency from entry reveal
 check

---
 windows/tests/Murmur.App.Tests/HudWindowTests.cs | 12 ++++++++++--
 1 file changed, 10 insertions(+), 2 deletions(-)

diff --git a/windows/tests/Murmur.App.Tests/HudWindowTests.cs b/windows/tests/Murmur.App.Tests/HudWindowTests.cs
index 881c4d0..6a8e505 100644
--- a/windows/tests/Murmur.App.Tests/HudWindowTests.cs
+++ b/windows/tests/Murmur.App.Tests/HudWindowTests.cs
@@ -435,7 +435,8 @@ public async Task HudWindow_IdleFollowedByImmediateListening_RemainsVisible()
     [AvaloniaFact]
     public async Task HudWindow_EntryKeepsContentHiddenUntilRevealDelay()
     {
-        var hud = new HudWindow();
+        var hud = new HudWindow { IsReducedMotion = () => false };
+        hud.Resources["HudContentRevealDelayMs"] = 60000d;
 
         hud.UpdateState(
             new DictationState(DictationStatus.Starting),
@@ -454,6 +455,13 @@ public async Task HudWindow_EntryKeepsContentHiddenUntilRevealDelay()
         surface.Height.ShouldBe(52);
         content.Opacity.ShouldBe(0);
 
+        var timer = typeof(HudWindow).GetField("_contentRevealTimer",
+            System.Reflection.BindingFlags.Instance | System.Reflection.BindingFlags.NonPublic)!
+            .GetValue(hud).ShouldBeOfType<DispatcherTimer>();
+        timer.IsEnabled.ShouldBeTrue();
+        timer.Interval.ShouldBe(TimeSpan.FromMinutes(1));
+        timer.Interval = TimeSpan.FromMilliseconds(1);
+
         await Task.Delay(120);
         Dispatcher.UIThread.RunJobs();
 
@@ -491,7 +499,7 @@ public async Task HudWindow_IdleCancelsPendingContentReveal()
     [AvaloniaFact]
     public async Task HudWindow_AudioLevelUpdatesDoNotRestartContentReveal()
     {
-        var hud = new HudWindow();
+        var hud = new HudWindow { IsReducedMotion = () => false };
 
         hud.UpdateState(
             new DictationState(DictationStatus.Starting),

From 62cad99dc43d1ba59f35adf8de2fd7a47a4f9b9f Mon Sep 17 00:00:00 2001
From: devjenjen <devjenjen@gmail.com>
Date: Tue, 27 Oct 2026 18:15:49 +0100
Subject: [PATCH 8/9] fix(speech): stream long batch audio within backlog
 budget

---
 .../NemotronStreamingTranscriber.cs           | 52 +++++++++++++--
 .../StreamingAudioBoundsTests.cs              | 65 +++++++++++++++++++
 2 files changed, 113 insertions(+), 4 deletions(-)

diff --git a/windows/src/Murmur.Speech/NemotronStreamingTranscriber.cs b/windows/src/Murmur.Speech/NemotronStreamingTranscriber.cs
index e35cb7d..75e01dd 100644
--- a/windows/src/Murmur.Speech/NemotronStreamingTranscriber.cs
+++ b/windows/src/Murmur.Speech/NemotronStreamingTranscriber.cs
@@ -26,6 +26,7 @@ private sealed class StreamingSession(NativeSession stream, Channel<float[]> cha
         public Exception? Failure;
         public int PendingSamples;
         public int PendingItems;
+        public TaskCompletionSource? Drained;
     }
 
     private StreamingSession? _session;
@@ -153,6 +154,7 @@ private static void FailSessionLocked(StreamingSession session, Exception failur
         session.Failure = failure;
         Volatile.Write(ref session.Cancelled, 1);
         session.Channel.Writer.TryComplete();
+        session.Drained?.TrySetResult();
         // Controller capture and native locks have opposite entry paths: never notify under this lock.
         ThreadPool.QueueUserWorkItem(_ =>
         {
@@ -192,6 +194,11 @@ private async Task ProcessAudioLoopAsync(StreamingSession session)
                     {
                         session.PendingSamples -= samples.Length;
                         session.PendingItems--;
+                        if (session.PendingItems == 0)
+                        {
+                            session.Drained?.TrySetResult();
+                            session.Drained = null;
+                        }
                     }
                 }
             }
@@ -237,7 +244,10 @@ private Task<string> StartClosingSession(bool decodeFinal)
         lock (_lock)
         {
             if (!decodeFinal && _session is { } cancelling)
+            {
                 Volatile.Write(ref cancelling.Cancelled, 1);
+                cancelling.Drained?.TrySetResult();
+            }
             if (_closeTask != null)
             {
                 return _closeTask;
@@ -291,15 +301,49 @@ private async Task<string> FinishClosingSessionAsync(StreamingSession session, b
     public async Task<string> TranscribeAsync(ReadOnlyMemory<float> audioSamples, CancellationToken cancellationToken = default)
     {
         cancellationToken.ThrowIfCancellationRequested();
-        BeginSession();
+        StreamingSession session;
+        lock (_lock)
+        {
+            BeginSession();
+            session = _session!;
+        }
         try
         {
-            AcceptAudio(audioSamples);
-            return await CompleteSessionAsync(cancellationToken).ConfigureAwait(false);
+            for (var offset = 0; offset < audioSamples.Length;)
+            {
+                cancellationToken.ThrowIfCancellationRequested();
+                var count = Math.Min(MaximumPendingSamples, audioSamples.Length - offset);
+                Task? drained;
+                lock (_lock)
+                {
+                    if (session.Failure is { } failure) throw failure;
+                    if (_disposed || !ReferenceEquals(_session, session) || _closeTask != null || session.Cancelled != 0)
+                        throw new OperationCanceledException("Streaming session ended before batch completion.");
+                    AcceptAudio(audioSamples.Slice(offset, count));
+                    if (session.Failure is { } acceptFailure) throw acceptFailure;
+                    drained = session.PendingItems == 0 ? null :
+                        (session.Drained ??= new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously)).Task;
+                }
+                offset += count;
+                if (drained != null) await drained.WaitAsync(cancellationToken).ConfigureAwait(false);
+            }
+            cancellationToken.ThrowIfCancellationRequested();
+            Task<string> completion;
+            lock (_lock)
+            {
+                if (session.Failure is { } failure) throw failure;
+                if (_disposed || !ReferenceEquals(_session, session) || _closeTask != null || session.Cancelled != 0)
+                    throw new OperationCanceledException("Streaming session ended before batch completion.");
+                completion = StartClosingSession(decodeFinal: true);
+            }
+            return await completion.WaitAsync(cancellationToken).ConfigureAwait(false);
         }
         finally
         {
-            await CancelSessionAsync().ConfigureAwait(false);
+            Task cleanup;
+            lock (_lock) cleanup = ReferenceEquals(_session, session) ? StartClosingSession(decodeFinal: false) : Task.CompletedTask;
+            try { await cleanup.ConfigureAwait(false); }
+            catch when (cancellationToken.IsCancellationRequested) { cancellationToken.ThrowIfCancellationRequested(); }
         }
     }
 
diff --git a/windows/tests/Murmur.Speech.Tests/StreamingAudioBoundsTests.cs b/windows/tests/Murmur.Speech.Tests/StreamingAudioBoundsTests.cs
index f6131e9..41c20f8 100644
--- a/windows/tests/Murmur.Speech.Tests/StreamingAudioBoundsTests.cs
+++ b/windows/tests/Murmur.Speech.Tests/StreamingAudioBoundsTests.cs
@@ -6,6 +6,71 @@ namespace Murmur.Speech.Tests;
 
 public class StreamingAudioBoundsTests
 {
+    [Fact]
+    public async Task BatchOverNineSecondsWaitsForConsumerAndKeepsAllSamplesInOrder()
+    {
+        using var release = new ManualResetEventSlim();
+        var entered = new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously);
+        var received = new List<float>();
+        var disposals = 0;
+        using var transcriber = new NemotronStreamingTranscriber(() => new(
+            samples => { if (received.Count == 0) { entered.TrySetResult(); release.Wait(); } received.AddRange(samples); },
+            () => false, () => { }, () => "complete", () => { }, () => disposals++), () => { });
+        var input = Enumerable.Range(0, 320001).Select(i => (float)i).ToArray();
+        Task<string>? result = null;
+        try
+        {
+            result = transcriber.TranscribeAsync(input);
+            await entered.Task.WaitAsync(TimeSpan.FromSeconds(5));
+            transcriber.PendingAudio.Samples.ShouldBeLessThanOrEqualTo(144000);
+            transcriber.PendingAudio.Items.ShouldBe(1);
+            result.IsCompleted.ShouldBeFalse();
+            release.Set();
+            (await result.WaitAsync(TimeSpan.FromSeconds(5))).ShouldBe("complete");
+            received.ShouldBe(input);
+            disposals.ShouldBe(1);
+        }
+        finally { release.Set(); if (result != null) try { await result; } catch { } }
+    }
+
+    [Fact]
+    public async Task CancelledBatchRetainsNativeOwnerUntilConsumerReturns()
+    {
+        using var release = new ManualResetEventSlim();
+        using var cancel = new CancellationTokenSource();
+        var entered = new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously);
+        var disposals = 0;
+        using var transcriber = new NemotronStreamingTranscriber(() => new(
+            _ => { entered.TrySetResult(); release.Wait(); }, () => false, () => { }, () => "late", () => { }, () => disposals++), () => { });
+        Task<string>? result = null;
+        try
+        {
+            result = transcriber.TranscribeAsync(new float[320001], cancel.Token);
+            await entered.Task.WaitAsync(TimeSpan.FromSeconds(5));
+            cancel.Cancel();
+            result.IsCompleted.ShouldBeFalse();
+            disposals.ShouldBe(0);
+            release.Set();
+            await Should.ThrowAsync<OperationCanceledException>(() => result.WaitAsync(TimeSpan.FromSeconds(5)));
+            disposals.ShouldBe(1);
+        }
+        finally { release.Set(); if (result != null) try { await result; } catch { } }
+    }
+
+    [Fact]
+    public async Task BatchWorkerFailurePropagatesAndAllowsNextSession()
+    {
+        var fail = true;
+        var received = 0;
+        using var transcriber = new NemotronStreamingTranscriber(() => new(
+            samples => { if (fail) { fail = false; throw new IOException("native failure"); } received += samples.Length; },
+            () => false, () => { }, () => "next", () => { }, () => { }), () => { });
+        var error = await Should.ThrowAsync<InvalidOperationException>(() => transcriber.TranscribeAsync(new float[320001]));
+        error.Message.ShouldBe("StreamingRecognitionFailed");
+        (await transcriber.TranscribeAsync(new float[160])).ShouldBe("next");
+        received.ShouldBe(160);
+    }
+
     private sealed class UnreadableMemory(int length) : MemoryManager<float>
     {
         public Memory<float> Oversized => CreateMemory(length);

From 5463dcaf839f08649d12a4f90795cc8953c2daad Mon Sep 17 00:00:00 2001
From: devjenjen <devjenjen@gmail.com>
Date: Tue, 27 Oct 2026 18:18:33 +0100
Subject: [PATCH 9/9] test(speech): serialize blocked native lifecycle fixtures

---
 windows/tests/Murmur.Speech.Tests/NativeSessionLifetimeTests.cs | 1 +
 windows/tests/Murmur.Speech.Tests/StreamingAudioBoundsTests.cs  | 1 +
 2 files changed, 2 insertions(+)

diff --git a/windows/tests/Murmur.Speech.Tests/NativeSessionLifetimeTests.cs b/windows/tests/Murmur.Speech.Tests/NativeSessionLifetimeTests.cs
index f213bc0..3a1dfa4 100644
--- a/windows/tests/Murmur.Speech.Tests/NativeSessionLifetimeTests.cs
+++ b/windows/tests/Murmur.Speech.Tests/NativeSessionLifetimeTests.cs
@@ -8,6 +8,7 @@
 
 namespace Murmur.Speech.Tests;
 
+[Collection("Native session lifetime")]
 public class NativeSessionLifetimeTests
 {
     private sealed class Audio : IAudioCapture
diff --git a/windows/tests/Murmur.Speech.Tests/StreamingAudioBoundsTests.cs b/windows/tests/Murmur.Speech.Tests/StreamingAudioBoundsTests.cs
index 41c20f8..b67ca76 100644
--- a/windows/tests/Murmur.Speech.Tests/StreamingAudioBoundsTests.cs
+++ b/windows/tests/Murmur.Speech.Tests/StreamingAudioBoundsTests.cs
@@ -4,6 +4,7 @@
 
 namespace Murmur.Speech.Tests;
 
+[Collection("Native session lifetime")]
 public class StreamingAudioBoundsTests
 {
     [Fact]