feat(alerts): add scene-local recent ticker

Model the AlertBox and standalone ticker with shared settings; scene tickers render the in-memory active and queued events without saving history. Keep AlertBox content active-event-only.

Ref: https://obsproject.com/kb/obs-studio-overview

Services/AlertOverlayLayer.cs

@@ -58,6 +58,8 @@ public sealed class AlertOverlayLayer : IDisposable
 
     private ChatMessage? _current;
     private Source? _currentBox;
+    private sealed record TickerFeed(string Text, double Duration);
+    private volatile TickerFeed? _tickerFeed;
     private IAlertClipDecoder? _clip;
     private VideoFrame? _latestClipFrame;
     private bool _clipEof;
@@ -66,8 +68,6 @@ public sealed class AlertOverlayLayer : IDisposable
     private int _clipHeight;
     private bool _clipSawFrame;
     private bool _clipAudioHeard;
-    private string? _tickerText;
-    private AlertDisplayMethod _tickerMethod = AlertDisplayMethod.TickerScroll;
     private double _elapsed;
     private IEnumerable<Scene>? _scenes;
 
@@ -139,6 +139,7 @@ public sealed class AlertOverlayLayer : IDisposable
             BeginClip();
         }
         _contentVersion++;
+        RefreshTickerFeed();
     }
 
     /// <summary>Advance the playback clock (the ticker's beat — and the test seam;
@@ -172,6 +173,7 @@ public sealed class AlertOverlayLayer : IDisposable
                 _current = null;
                 _elapsed = 0;
                 AdvanceToNext();
+                RefreshTickerFeed();
             }
             _contentVersion++;
             return;
@@ -184,6 +186,7 @@ public sealed class AlertOverlayLayer : IDisposable
             _elapsed = 0;
             BeginClip();
             _contentVersion++;
+            RefreshTickerFeed();
             return;
         }
 
@@ -193,6 +196,7 @@ public sealed class AlertOverlayLayer : IDisposable
             _current = null;
             _elapsed = 0;
             AdvanceToNext();
+            RefreshTickerFeed();
         }
         _contentVersion++;
     }
@@ -249,27 +253,55 @@ public sealed class AlertOverlayLayer : IDisposable
     /// <see cref="VideoFrame.OriginX"/>/<see cref="VideoFrame.OriginY"/> instead of
     /// a hardcoded 0. <b>No alert box in the scene means no ticker at all</b> — there
     /// is no longer a global position for it to live in.</para></summary>
-    public VideoFrame? AlertTickerFrame
-    {
-        get
-        {
-            if (_current == null || string.IsNullOrWhiteSpace(_tickerText)) return null;
-            var box = _currentBox;
-            if (box == null) return null;
+    public VideoFrame? AlertTickerFrame => AlertBoxTickerFrame(_currentBox);
 
-            var w = (int)Math.Max(1, Math.Round(box.Width));
-            var h = (int)Math.Max(1, Math.Min(
-                Math.Round(box.Height), AlertTickerRenderer.Height));
-            var frame = AlertTickerRenderer.Render(
-                _tickerText!, _elapsed, _tickerMethod, AlertSeconds(),
-                TickerReadsPerAlert, w, h);
-            return frame == null
-                ? null
-                : new VideoFrame(frame.Width, frame.Height, frame.BgraPixels)
-                {
-                    Placement = ((int)Math.Round(box.X), (int)Math.Round(box.Y)),
-                };
+    public VideoFrame? AlertBoxTickerFrame(Source? alertBox)
+    {
+        if (_current == null || alertBox is not { Type: SourceType.AlertBox }) return null;
+
+        var w = (int)Math.Max(1, Math.Round(alertBox.Width));
+        var h = (int)Math.Max(1, Math.Min(
+            Math.Round(alertBox.Height), AlertTickerRenderer.Height));
+        var frame = AlertTickerRenderer.Render(
+            alertBox.Ticker, ComposeTicker(_current), _elapsed, AlertSeconds(),
+            TickerReadsPerAlert, w, h);
+        return frame == null
+            ? null
+            : new VideoFrame(frame.Width, frame.Height, frame.BgraPixels)
+            {
+                Placement = ((int)Math.Round(alertBox.X), (int)Math.Round(alertBox.Y)),
+            };
+    }
+
+    public VideoFrame? RenderSceneTicker(Source tickerSource)
+    {
+        if (tickerSource.Type != SourceType.Ticker || !tickerSource.Ticker.IsEnabled)
+            return null;
+
+        var feed = _tickerFeed;
+        if (feed == null) return null;
+        return AlertTickerRenderer.Render(
+            tickerSource.Ticker,
+            feed.Text,
+            _elapsed,
+            feed.Duration,
+            TickerReadsPerAlert,
+            (int)Math.Max(1, Math.Round(tickerSource.Width)),
+            (int)Math.Max(1, Math.Round(tickerSource.Height)));
+    }
+
+    private void RefreshTickerFeed()
+    {
+        if (_current == null)
+        {
+            _tickerFeed = null;
+            return;
         }
+
+        var messages = new[] { _current }.Concat(_queue).ToArray();
+        _tickerFeed = new TickerFeed(
+            string.Join("   •   ", messages.Select(ComposeTicker)),
+            messages.Sum(DurationOf));
     }
 
     /// <summary>How many times the marquee must cross the frame per alert, so the
@@ -354,17 +386,11 @@ public sealed class AlertOverlayLayer : IDisposable
     private void BeginClip()
     {
         StopClip();
-        _tickerText = null;
         if (_current == null) return;
 
         var box = _scenes?.SelectMany(s => s.Elements).OfType<Source>()
             .FirstOrDefault(s => s.Type == SourceType.AlertBox);
         _currentBox = box;
-        if (box != null && box.AlertShowTicker)
-        {
-            _tickerText = ComposeTicker(_current);
-            _tickerMethod = box.AlertDisplayMethod;
-        }
 
         if (box == null) return;
         StartSoundByte(box);
@@ -552,6 +578,9 @@ public sealed class AlertOverlayLayer : IDisposable
             };
             UpdatePreview(alertBox);
         }
+        foreach (var ticker in scenes.SelectMany(s => s.Elements).OfType<Source>()
+                     .Where(s => s.Type == SourceType.Ticker))
+            UpdateTickerPreview(ticker);
     }
 
     private void RefreshAlertPreviews()
@@ -566,6 +595,27 @@ public sealed class AlertOverlayLayer : IDisposable
         foreach (var alertBox in _scenes.SelectMany(s => s.Elements).OfType<Source>()
                      .Where(s => s.Type == SourceType.AlertBox))
             UpdatePreview(alertBox);
+        foreach (var ticker in _scenes.SelectMany(s => s.Elements).OfType<Source>()
+                     .Where(s => s.Type == SourceType.Ticker))
+            UpdateTickerPreview(ticker);
+    }
+
+    private void UpdateTickerPreview(Source ticker)
+    {
+        var frame = RenderSceneTicker(ticker);
+        if (frame == null)
+        {
+            ticker.VideoImageSource = null;
+            return;
+        }
+
+        var bitmap = ticker.VideoImageSource;
+        if (bitmap == null || bitmap.PixelWidth != frame.Width || bitmap.PixelHeight != frame.Height)
+        {
+            bitmap = new WriteableBitmap(frame.Width, frame.Height, 96, 96, PixelFormats.Bgra32, null);
+            ticker.VideoImageSource = bitmap;
+        }
+        bitmap.WritePixels(new Int32Rect(0, 0, frame.Width, frame.Height), frame.BgraPixels, frame.Stride, 0);
     }
 
     public void Dispose()
@@ -574,6 +624,7 @@ public sealed class AlertOverlayLayer : IDisposable
         _ticker?.Stop();
         _queue.Clear();
         _current = null;
+        _tickerFeed = null;
         StopClip();
     }
-}
+}

Services/Compositor/AlertTickerRenderer.cs

@@ -34,6 +34,15 @@ public static class AlertTickerRenderer
     /// (0.5s on, 0.5s off — a 1Hz pulse for the whole alert).</summary>
     public const double FlashHalfSeconds = 0.5;
 
+    public static VideoFrame? Render(Ticker ticker, string? text, double elapsedSeconds,
+        double alertSeconds, int readsPerAlert, int width, int height)
+    {
+        if (ticker == null) throw new ArgumentNullException(nameof(ticker));
+        return ticker.IsEnabled
+            ? Render(text, elapsedSeconds, ticker.DisplayMethod, alertSeconds, readsPerAlert, width, height)
+            : null;
+    }
+
     private static readonly object Gate = new();
     private static readonly Dictionary<string, VideoFrame> StripCache = new();
 
@@ -179,4 +188,4 @@ public static class AlertTickerRenderer
         }
         return new VideoFrame(pillW, Height, pixels);
     }
-}
+}

Services/Encoder/FramePump.cs

@@ -29,7 +29,7 @@ public sealed class FramePump : IDisposable
     private readonly Action<string>? _log;
     private readonly Func<TimeSpan, CancellationToken, Task> _pacingDelay;
     private readonly Func<(VideoFrame? Frame, SocialBarPosition Position)>? _socialBar;
-    private readonly Func<VideoFrame?>? _alertTicker;
+    private readonly Func<Scene, VideoFrame?>? _alertTicker;
     private readonly Func<VideoFrame?>? _brandFlash;
     private readonly TransitionService? _transition;
     private VideoFrame? _lastOutput;
@@ -138,7 +138,7 @@ public sealed class FramePump : IDisposable
         Action<string>? log = null,
         Func<TimeSpan, CancellationToken, Task>? pacingDelay = null,
         Func<(VideoFrame? Frame, SocialBarPosition Position)>? socialBar = null,
-        Func<VideoFrame?>? alertTicker = null,
+        Func<Scene, VideoFrame?>? alertTicker = null,
         Func<VideoFrame?>? brandFlash = null,
         TransitionService? transition = null,
         SceneGraph? sceneGraph = null)
@@ -486,7 +486,7 @@ public sealed class FramePump : IDisposable
                     }
 
                     var sw = System.Diagnostics.Stopwatch.StartNew();
-                    VideoFrame? tickerFrame = _alertTicker?.Invoke();
+                    VideoFrame? tickerFrame = _alertTicker?.Invoke(scene);
                     tickerTicks += sw.ElapsedTicks;
                     sw.Restart();
                     VideoFrame? flashFrame = _brandFlash?.Invoke();

Services/index.md

@@ -13,7 +13,7 @@ External-facing logic: YouTube API, persistence. See
 | `ChatBoxRenderer.cs` | Chat overlay rasterizer (WPF FormattedText → BGRA `VideoFrame`), live rows + Super Chat/member styling |
 | `ChatOverlayLayer.cs` | **The chat component (Commit G):** owns the message buffer, `ChatBoxRenderer`, fade/mock timers, per-source preview renders, live `RenderFrame`; raster-on-change cache pattern (OBS text-source contract) |
 | `AlertRenderer.cs` | **The alert rasterizer (TASK 43, 2026-09-24):** renders one event's celebration animation into a BGRA `VideoFrame` — SIX DISTINCT animations (SuperChat slide-up/shine/count-up, SuperSticker scale-pop, NewMember drop-in/flash-band, MemberGift slide-left/chip-fan, GiftReceived confetti scale-in, MemberMilestone rise/growth-bar), enter/hold/exit phases, brand line on every card. **Still the fallback** when no alert clip is playable (TASK 47) |
-| `AlertOverlayLayer.cs` | **The native alert-box component (TASK 43; video branch TASK 47):** event queue (cap 10) + 33ms dispatch ticker + `RenderFrame` cache-first live path + `UpdatePreview`; **`Advance(double)` is the deterministic test clock** (tests never start the timer); `ChatEventKind.None` rows (sub mentions) never enqueue; idle = transparent (null frame). Since TASK 47 a clip branch owns `IAlertClipDecoder` per play — ctor seams `(clipDecoderFactory, clipPathResolver, audioSink)`, fade in/out over `FadeDurationSeconds = 0.30` (straight-alpha copies + volume×fade audio), EOF freeze-frame → drain, and `AlertTickerFrame` composes the scrolling message strip |
+| `AlertOverlayLayer.cs` | **The native alert-box component (TASK 43; video branch TASK 47):** event queue (cap 10) + 33ms dispatch ticker + `RenderFrame` cache-first live path + `UpdatePreview`; **`Advance(double)` is the deterministic test clock** (tests never start the timer); `ChatEventKind.None` rows (sub mentions) never enqueue; idle = transparent (null frame). Since TASK 47 a clip branch owns `IAlertClipDecoder` per play — ctor seams `(clipDecoderFactory, clipPathResolver, audioSink)`, fade in/out over `FadeDurationSeconds = 0.30` (straight-alpha copies + volume×fade audio), EOF freeze-frame → drain. The shared ticker renderer serves the AlertBox's active event and scene-local `SourceType.Ticker` layers' current+queued feed (transient; no history) |
 | `AlertClipDecoder.cs` | **Per-play alert video decoder (TASK 47):** `IAlertClipDecoder` (Start/Stop/Dispose + `FrameAvailable`/`AudioReady`/`Completed`) + ffmpeg child emitting `rawvideo bgra` (`-vf scale=W:H`, read via `RawVideoFrameReader`) and `f32le -ar 48000 -ac 2` on a **carry-buffer** audio loop (float boundary straddles never drop samples), both real-time paced; bgra is opaque (layer owns alpha). One-shot lifetime — created per alert, disposed at drain; tests inject a fake |
 | `LayoutStore.cs` | SQLite persistence (`Microsoft.Data.Sqlite`) at `%APPDATA%\ytLlive\ytLlive.db`; assets stored as BLOBs keyed by SHA-256 content hash; save/open layout files; schema `user_version` 10 (`Source.ClipShape`/`IsMirrored` via `ALTER TABLE` for pre-v2 DBs; v3 = singleton `Webcam` + per-scene `WebcamSceneConfig`, migrated idempotently **without backfill** — the stale `Source.DeviceId` column remains but is no longer read/written; v4 = `WebcamSceneConfig.RectWidth`/`RectHeight`, the pre-Round rect for the round-to-rect restore; v5 = `Source.IsBackdrop` + `Source.CaptureKey`, the live-capture backdrop; v6 = `Scene.HasBackdrop` — Live-only policy, one-time backfill turns Starting/BRB/Chat/Ending off + drops their backdrop sources; v9→v10 (TASK 39) = `YppSnapshot` history table; all later columns stay additive guarded ALTERs — TASK 51 adds `WebcamSceneConfig.BackgroundEffect`/`BackgroundStrength`; **TASK 57 (the "vv" feature) adds the seven `WebcamSceneConfig.Vertical*` columns** (`VerticalX`/`VerticalY`/`VerticalWidth`/`VerticalHeight`/`VerticalClipShape`/`VerticalRectWidth`/`VerticalRectHeight` — the vertical tier's own camera placement per scene; NULL = the scene keeps its 16:9 placement. The X/Y/W/H/ClipShape columns stay the **16:9** layout: while the vertical tier is live the save writes the model's parked `Landscape*` values there and the live ones into the `Vertical*` columns); TASK 47 adds the five alert `Source` columns (`AlertVideoAssetId`/`AlertVideoPath`/`AlertUseDefaultVideo`/`AlertShowTicker`/`AlertVideoVolume`) without a version bump; `MainViewModel.NormalizeBackgrounds` re-normalizes on every load — TASK 25: one locked "Background" per canonical screen (static art everywhere, DisplayCapture on Live), duplicates dropped, index 0, orphaned `BackgroundUseDefault_*`/`BackgroundPath_*` Settings keys purged at save). Settings key/value table holds app state: `MicSourceName`, `ReusableStream` (TASK 9 — the cached reusable stream's id/address/name so the pump has its RTMP URL at startup), `AlertDefaultVideoAssetId` (TASK 47 — the stamped built-in alert clip's asset row; save's prune exempts it via UNION) |
 | `VideoFrame.cs` | Normalized CPU frame seam (`Width`/`Height`/tightly-packed BGRA `byte[]`) — the only pixel type the rest of the app knows about; future capture sources (screen, background-removed webcam) feed the same seam |
@@ -49,7 +49,7 @@ External-facing logic: YouTube API, persistence. See
 | `Encoder/IFfmpegLocator.cs` | **TASK 4 ship step 2 seam**: resolves an absolute path to `ffmpeg.exe` (PATH first → cached `%APPDATA%\ytLlive\tools\ffmpeg.exe` → pinned BtbN LGPL-shared zip download). The encoder step and tests fake it |
 | `SocialValidator.cs` | `ISocialValidator` seam + `HttpSocialValidator` default: validates a social handle/URL by constructing the canonical profile URL and issuing an HTTP GET — the "act of validation" before adding to the bar. 200/redirect = exists; 404/connection failure = rejected. Fediverse `@user@domain` additionally does a best-effort nodeinfo lookup (`/.well-known/nodeinfo` → `software.name`) so the entry can show the instance's real logo; nodeinfo failure still validates (generic fediverse glyph). If the identity domain's nodeinfo is blocked (SSO) but the bare root 302s to the real instance (YunoHost default-app subdomains), the lookup follows the redirect and asks that host. Since the bar bug-fix branch the resolution **probes well-known subdomains** (`mastodon.`, `social.`, ... order in `FediverseSubdomainCandidates`) when both the identity domain and its redirect come up empty, bounded by a ~15s linked-CTS budget; `ResolveFediverseSoftwareAsync(domain, ct)` on the seam powers the load-time heal. Constructor takes optional `HttpClient` + `Action<string>` log for tests |
 | `Compositor/SocialBarRenderer.cs` | **Social bar output strip** (bar bug-fix branch): rasterizes the global social bar into a transparent straight-alpha BGRA8 `VideoFrame` strip (1920 wide, 40px content + 24px glow pad) via `RenderTargetBitmap` — one Path (logo) + one TextBlock (handle) per entry, white on transparent with the preview's green `#2ecc71` glow baked in (Pbgra32 → straight-alpha unpremultiply). UI thread only; the frame is immutable afterwards so the `FramePump` reads it from its own thread |
-| `Compositor/AlertTickerRenderer.cs` | **Alert message ticker strip (TASK 47):** marquee overlay rendered per call by pure byte-math onto a 1920×48 transparent BGRA frame — the text pill ("Author — Kind · amount") is rasterized once per text on the UI thread (cached, unpremultiplied straight alpha) and scrolled at 140px/s with a repeat-gap wrap, so the pump can call `Render(elapsed, text)` from its own thread without locking. **Dynamic overlay — never baked** (unlike the social bar) |
+| `Compositor/AlertTickerRenderer.cs` | **Shared ticker renderer (TASK 47):** marquee frame rendered per call by pure byte-math; the text pill is rasterized once per text on the UI thread (cached, unpremultiplied straight alpha). Supports AlertBox active-event tickers and ordinary scene-local ticker sources, with per-source `Ticker` settings. **Dynamic output — never baked** (unlike the social bar) |
 | `Encoder/EncoderOptions.cs` | One go-live's encoder config: full `RtmpUrl` (ingest + stream key), W×H/FPS/bitrate from the quality tier, `VideoEncoder` (null = probe), audio sample rate/channels, `GopSize` = FPS×4 (the ≤4s keyframe bound) |
 | `Encoder/IFfmpegEncoder.cs` | **TASK 4 ship step 3 seam**: start/feed/stop the live encoder; `HealthUpdated` (parsed `StreamHealth`), `ProcessFailed` on unexpected non-zero exit. Constructor-injected locator + process factory (tests fake both) |
 | `Encoder/FfmpegEncoder.cs` | The default encoder: spawn `ffmpeg.exe` (probe `-encoders` first → hardware NVENC/QSV/AMF, OpenH264 fallback — never libx264), feed raw BGRA frames into stdin, parse `-stats` lines into `StreamHealth`, graceful stop via stdin EOF + 10s kill watchdog. Constructed by `MainViewModel` since ship step 5 (`new FfmpegEncoder(new FfmpegLocator())`), driven by the `FramePump` |
@@ -58,7 +58,7 @@ External-facing logic: YouTube API, persistence. See
 | `Encoder/FfmpegArgs.cs` | Pure FFmpeg command-line builder: rawvideo `pipe:0` input, `anullsrc` silent audio (WASAPI replaces it), H.264+AAC, closed GOP (`-g fps×4 -keyint_min -sc_threshold 0 -bf 0`, `yuv420p`), FLV → RTMP |
 | `Encoder/FfmpegProgressParser.cs` | Pure parser for `frame=/fps=/size=/time=/bitrate=` stats lines → `FfmpegProgress` |
 | `Encoder/FfmpegEncoderPicker.cs` | Pure H.264 encoder picker from `-encoders` output: NVENC → QSV → AMF → OpenH264; **never returns libx264** (GPL) |
-| `Encoder/FramePump.cs` | **TASK 4 ship step 5**: the live frame producer — while live it snapshots the active scene each tick, resolves every element to its latest frame (`Func<SceneElement, VideoFrame?>` resolver), composites it into the tier's output frame, and paces frames into the encoder at the tier's FPS. All collaborators constructor-injected seams; free of WPF and the capture managers. `StartAsync` never throws (failures log + `Failed`); no RTMP URL = encoder skipped; `StopAsync` stops the encoder before awaiting the loop (backpressure deadlock); `ProcessFailed` self-stops. Since the bar bug-fix branch it takes an optional `socialBar: Func<(VideoFrame? Frame, SocialBarPosition Position)>?` seam — a pre-rendered bar strip composited last (above the flash) at the top edge or `SourceRectHeight − bar height`. **TASK 47:** adds an `alertTicker: Func<VideoFrame?>?` ctor seam (parallel to `socialBar`), read per tick and threaded through `RenderScene`/`RenderFull` + **mixed into `BuildFullRenderSignature`** so the ticker scroll changes the cache key. See [`docs/ai/frame-pipeline.md`](../docs/ai/frame-pipeline.md) → "Live frame pipeline". **2026-10-16:** owns a `CompositeTimings` collector, passes it through `RenderScene`/`RenderFull`/`GetBakedBase`/`CompositeLayers`, logs `FramePump parts (N renders/5s): …` (per-stage breakdown, slowest first) beside the stats line each 5s window, and dumps the scene shape — `FramePump scene dump:` header + one line per element (z-index, name, kind, type, visibility, rect, opacity, clip) — at pump start and on every scene change |
+| `Encoder/FramePump.cs` | **TASK 4 ship step 5**: the live frame producer — while live it snapshots the active scene each tick, resolves every element to its latest frame (`Func<SceneElement, VideoFrame?>` resolver), composites it into the tier's output frame, and paces frames into the encoder at the tier's FPS. All collaborators constructor-injected seams; free of WPF and the capture managers. `StartAsync` never throws (failures log + `Failed`); no RTMP URL = encoder skipped; `StopAsync` stops the encoder before awaiting the loop (backpressure deadlock); `ProcessFailed` self-stops. Since the bar bug-fix branch it takes an optional `socialBar: Func<(VideoFrame? Frame, SocialBarPosition Position)>?` seam — a pre-rendered bar strip composited last (above the flash) at the top edge or `SourceRectHeight − bar height`. **TASK 47 + scene ticker:** the `alertTicker: Func<Scene, VideoFrame?>?` seam selects the active scene's AlertBox ticker, threaded through `RenderScene`/`RenderFull` + **mixed into `BuildFullRenderSignature`**; standalone tickers are resolved as per-element dynamic sources. See [`docs/ai/frame-pipeline.md`](../docs/ai/frame-pipeline.md) → "Live frame pipeline". **2026-10-16:** owns a `CompositeTimings` collector, passes it through `RenderScene`/`RenderFull`/`GetBakedBase`/`CompositeLayers`, logs `FramePump parts (N renders/5s): …` (per-stage breakdown, slowest first) beside the stats line each 5s window, and dumps the scene shape — `FramePump scene dump:` header + one line per element (z-index, name, kind, type, visibility, rect, opacity, clip) — at pump start and on every scene change |
 | `Encoder/FfmpegLocator.cs` | The default locator: PATH probe wins, then the cache, then pull+extract (`ffmpeg.exe` **+ the `libav*.dll` family** via a staging dir, failures via `AppLog`). Pinned to BtbN `autobuild-2026-08-09-13-03` **lgpl-shared** (dynamic linking = LGPL compliance without static-relink §6 material; no GPL libx264; NVENC/QSV/AMF + libopenh264 + native AAC — see `ai.md` → Licensing). Search dirs / tools dir / downloader constructor-injected for hermetic tests. Wired into the encoder since ship step 5 |
 | `INotificationService.cs` | **Toast seam (TASK 24)**: `Show(title, message, AppNotificationSeverity)` + `AppNotificationSeverity { Info, Success, Warning, Error }` + `Info/Success/Warning/Error` extension methods — non-blocking user-facing messages; VMs/services raise through this so failures surface without MessageBox blocking the UI thread |
 | `NotificationService.cs` | The default seam impl (Notification.Wpf 11.0.0, MIT): wraps a library `NotificationManager`; routes to the in-window `NotificationArea` named `ToastArea` (MainWindow bottom-right above the footer); lifetimes via the pure `BuildRequest` mapping + `Cards` tint table — Info/Success ~4s, Warning ~8s auto-dismiss, Error sticky (`NeverExpires()` = `TimeSpan.MaxValue`, never null); dark card tints matching the health-banner language; all Show calls marshal to the captured Dispatcher. See [`../ai.md`](../ai.md) "Toast notifications" |