feat(stream): RECONNECTING driven by the status poll — no invented countdown (TASK 32·2)

Creator challenge (2026-11-05): "I really don't think that's going to be a constant — it's going to
depend on so many variables, some that are dark to us." Correct, so the measured-grace constant and
the countdown are dropped from the spec. YouTube's cutoff is server-side and depends on ingest health,
prior stream quality, region and load; a pinned number would be a guess wearing a timer, and it would
be wrong exactly when the creator is staring at it.

What ships instead:

- **Amber RECONNECTING** in the top bar with measured facts only: elapsed seconds and the attempt
  number ("0:12 · attempt 2 of 4"). The seconds come from a stopwatch started at the drop.
- **The status poll speeds up while recovering** (30 s → 4 s) and drives the sign; it restores 30 s
  when recovery ends.
- **`chatEndedEvent`** — already in the chat feed we poll and previously skipped — now raises a signal
  that prompts an immediate status check. It never decides anything: `liveBroadcasts.list`
  `lifeCycleStatus` stays authoritative, with `liveStreams.list` health as the push-received signal.
- At `complete`: red OFF AIR (the existing stop path) rather than a pretend-live sign.

Tests: `ChatEndedSignalTests` (the marker is not a chat row, the service raises the signal, and a
complete broadcast ends recovery with the honest message). FAST gate: 543 passed, 0 warnings.

ViewModels/MainViewModel.Recovery.cs

@@ -19,11 +19,79 @@ public partial class MainViewModel
 {
     private CancellationTokenSource? _recoveryCts;
 
-    /// <summary>True while a push is being relaunched — slice 2 binds the amber sign to this.</summary>
-    public bool IsReconnecting { get; private set; }
+    /// <summary>True while a push is being relaunched — the top bar shows amber RECONNECTING.</summary>
+    public bool IsReconnecting
+    {
+        get => _isReconnecting;
+        private set
+        {
+            if (!SetProperty(ref _isReconnecting, value)) return;
+            RaiseTopBarModes();
+            OnPropertyChanged(nameof(ReconnectDetailText));
+            ApplyReconnectPollCadence();
+        }
+    }
+
+    private bool _isReconnecting;
 
     /// <summary>The attempt currently in flight (0 when idle).</summary>
-    public int ReconnectAttempt { get; private set; }
+    public int ReconnectAttempt
+    {
+        get => _reconnectAttempt;
+        private set
+        {
+            if (!SetProperty(ref _reconnectAttempt, value)) return;
+            OnPropertyChanged(nameof(ReconnectDetailText));
+        }
+    }
+
+    private int _reconnectAttempt;
+
+    /// <summary>Whole seconds since the drop — measured, never predicted.</summary>
+    public int ReconnectElapsedSeconds
+    {
+        get => _reconnectElapsedSeconds;
+        private set
+        {
+            if (!SetProperty(ref _reconnectElapsedSeconds, value)) return;
+            OnPropertyChanged(nameof(ReconnectDetailText));
+        }
+    }
+
+    private int _reconnectElapsedSeconds;
+    private System.Windows.Threading.DispatcherTimer? _reconnectTick;
+
+    /// <summary>While recovering, ask YouTube much more often — the status IS the sign, so it has to
+    /// keep up with a reconnect that can succeed or die inside a few seconds.</summary>
+    private void ApplyReconnectPollCadence()
+    {
+        if (IsReconnecting)
+        {
+            _healthPollTimer.Interval = TimeSpan.FromSeconds(4);
+            _reconnectTick ??= new System.Windows.Threading.DispatcherTimer
+            {
+                Interval = TimeSpan.FromSeconds(1),
+            };
+            _reconnectTick.Tick -= OnReconnectTick;
+            _reconnectTick.Tick += OnReconnectTick;
+            _reconnectTick.Start();
+        }
+        else
+        {
+            _healthPollTimer.Interval = TimeSpan.FromSeconds(30);
+            if (_reconnectTick != null)
+            {
+                _reconnectTick.Stop();
+                _reconnectTick.Tick -= OnReconnectTick;
+            }
+        }
+    }
+
+    private void OnReconnectTick(object? sender, EventArgs e)
+        => ReconnectElapsedSeconds = (int)Math.Round(_reconnectStarted?.Elapsed.TotalSeconds ?? 0);
+
+    // Measured from the drop, so the displayed seconds are facts rather than a projection.
+    private System.Diagnostics.Stopwatch? _reconnectStarted;
 
     private void OnEncoderFailed(object? sender, string message)
     {
@@ -38,8 +106,11 @@ public partial class MainViewModel
 
     private async Task RecoverStreamAsync(string reason, CancellationToken cancellationToken)
     {
+        ReconnectElapsedSeconds = 0;
+        _reconnectStarted = System.Diagnostics.Stopwatch.StartNew();
         IsReconnecting = true;
         ReconnectAttempt = 0;
+        var dropped = _reconnectStarted;
 
         var logFrom = AppLog.SnapshotCurrentLaunch().Count > 0
             ? AppLog.SnapshotCurrentLaunch()[^1].Sequence + 1
@@ -126,6 +197,7 @@ public partial class MainViewModel
         }
         finally
         {
+            _reconnectStarted = null;
             IsReconnecting = false;
             ReconnectAttempt = 0;
             _recoveryCts?.Dispose();
@@ -145,4 +217,13 @@ public partial class MainViewModel
 
     /// <summary>The creator asked to stop: never race a stop against a relaunch.</summary>
     private void CancelStreamRecovery() => _recoveryCts?.Cancel();
+
+    /// <summary>YouTube ended the chat: ask the broadcast status now rather than at the next tick.
+    /// The API decides — this signal only saves up to 30 s of lying to the creator.</summary>
+    private void OnChatEnded()
+    {
+        if (!IsLive) return;
+        AppLog.Write("Chat ended event received — checking the broadcast status now");
+        _ = PollHealthAsync();
+    }
 }