From 61f5a3beba16f112fb6396dd738b9d4f35f40f66 Mon Sep 17 00:00:00 2001
From: ClaudioESSilva <claudiosil100@gmail.com>
Date: Wed, 15 Apr 2026 17:20:53 +0100
Subject: [PATCH 01/49] Implements #843 in Lite

---
 Lite/Helpers/ScrollPanBehavior.cs | 271 ++++++++++++++++++++++++++++++
 Lite/Themes/CoolBreezeTheme.xaml  |   2 +
 Lite/Themes/DarkTheme.xaml        |   2 +
 Lite/Themes/LightTheme.xaml       |   2 +
 4 files changed, 277 insertions(+)
 create mode 100644 Lite/Helpers/ScrollPanBehavior.cs

diff --git a/Lite/Helpers/ScrollPanBehavior.cs b/Lite/Helpers/ScrollPanBehavior.cs
new file mode 100644
index 00000000..e823c8f9
--- /dev/null
+++ b/Lite/Helpers/ScrollPanBehavior.cs
@@ -0,0 +1,271 @@
+/*
+ * Copyright (c) 2026 Erik Darling, Darling Data LLC
+ *
+ * This file is part of the SQL Server Performance Monitor Lite.
+ *
+ * Licensed under the MIT License. See LICENSE file in the project root for full license information.
+ */
+
+using System;
+using System.Windows;
+using System.Windows.Controls;
+using System.Windows.Controls.Primitives;
+using System.Windows.Input;
+using System.Windows.Media;
+
+namespace PerformanceMonitorLite.Helpers;
+
+/// <summary>
+/// Enables middle-mouse drag panning for scrollable controls such as DataGrid and ListView.
+/// </summary>
+public static class ScrollPanBehavior
+{
+    public static readonly DependencyProperty EnableMiddleClickPanningProperty =
+        DependencyProperty.RegisterAttached(
+            "EnableMiddleClickPanning",
+            typeof(bool),
+            typeof(ScrollPanBehavior),
+            new PropertyMetadata(false, OnEnableMiddleClickPanningChanged));
+
+    private static readonly DependencyProperty PanStateProperty =
+        DependencyProperty.RegisterAttached(
+            "PanState",
+            typeof(PanState),
+            typeof(ScrollPanBehavior),
+            new PropertyMetadata(null));
+
+    public static bool GetEnableMiddleClickPanning(DependencyObject obj) => (bool)obj.GetValue(EnableMiddleClickPanningProperty);
+    public static void SetEnableMiddleClickPanning(DependencyObject obj, bool value) => obj.SetValue(EnableMiddleClickPanningProperty, value);
+
+    private static PanState GetOrCreatePanState(FrameworkElement element)
+    {
+        if (element.GetValue(PanStateProperty) is not PanState state)
+        {
+            state = new PanState();
+            element.SetValue(PanStateProperty, state);
+        }
+
+        return state;
+    }
+
+    private static void OnEnableMiddleClickPanningChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
+    {
+        if (d is not FrameworkElement element)
+        {
+            return;
+        }
+
+        var isEnabled = (bool)e.NewValue;
+
+        if (isEnabled)
+        {
+            element.Loaded += OnLoaded;
+            element.Unloaded += OnUnloaded;
+            element.PreviewMouseDown += OnPreviewMouseDown;
+            element.PreviewMouseMove += OnPreviewMouseMove;
+            element.PreviewMouseUp += OnPreviewMouseUp;
+            element.LostMouseCapture += OnLostMouseCapture;
+        }
+        else
+        {
+            element.Loaded -= OnLoaded;
+            element.Unloaded -= OnUnloaded;
+            element.PreviewMouseDown -= OnPreviewMouseDown;
+            element.PreviewMouseMove -= OnPreviewMouseMove;
+            element.PreviewMouseUp -= OnPreviewMouseUp;
+            element.LostMouseCapture -= OnLostMouseCapture;
+            StopPanning(element, restoreCursor: true);
+        }
+    }
+
+    private static void OnLoaded(object sender, RoutedEventArgs e)
+    {
+        if (sender is FrameworkElement element)
+        {
+            GetOrCreatePanState(element).ScrollViewer = FindVisualChild<ScrollViewer>(element);
+        }
+    }
+
+    private static void OnUnloaded(object sender, RoutedEventArgs e)
+    {
+        if (sender is FrameworkElement element)
+        {
+            StopPanning(element, restoreCursor: false);
+            GetOrCreatePanState(element).ScrollViewer = null;
+        }
+    }
+
+    private static void OnPreviewMouseDown(object sender, MouseButtonEventArgs e)
+    {
+        if (e.ChangedButton != MouseButton.Middle
+            || sender is not FrameworkElement element
+            || !CanStartPanning(e.OriginalSource as DependencyObject))
+        {
+            return;
+        }
+
+        var state = GetOrCreatePanState(element);
+        state.ScrollViewer ??= FindVisualChild<ScrollViewer>(element);
+
+        if (state.ScrollViewer is null)
+        {
+            return;
+        }
+
+        if (state.ScrollViewer.ScrollableWidth <= 0 && state.ScrollViewer.ScrollableHeight <= 0)
+        {
+            return;
+        }
+
+        state.IsPanning = true;
+        state.StartPoint = e.GetPosition(state.ScrollViewer);
+        state.StartHorizontalOffset = state.ScrollViewer.HorizontalOffset;
+        state.StartVerticalOffset = state.ScrollViewer.VerticalOffset;
+        state.OriginalCursor = element.Cursor;
+
+        element.Cursor = Cursors.ScrollAll;
+        element.CaptureMouse();
+        e.Handled = true;
+    }
+
+    private static void OnPreviewMouseMove(object sender, MouseEventArgs e)
+    {
+        if (sender is not FrameworkElement element)
+        {
+            return;
+        }
+
+        var state = GetOrCreatePanState(element);
+        if (!state.IsPanning || state.ScrollViewer is null)
+        {
+            return;
+        }
+
+        var currentPoint = e.GetPosition(state.ScrollViewer);
+        var deltaX = currentPoint.X - state.StartPoint.X;
+        var deltaY = currentPoint.Y - state.StartPoint.Y;
+
+        state.ScrollViewer.ScrollToHorizontalOffset(ClampOffset(state.StartHorizontalOffset - deltaX, state.ScrollViewer.ScrollableWidth));
+        state.ScrollViewer.ScrollToVerticalOffset(ClampOffset(state.StartVerticalOffset - deltaY, state.ScrollViewer.ScrollableHeight));
+        e.Handled = true;
+    }
+
+    private static void OnPreviewMouseUp(object sender, MouseButtonEventArgs e)
+    {
+        if (e.ChangedButton != MouseButton.Middle || sender is not FrameworkElement element)
+        {
+            return;
+        }
+
+        if (!GetOrCreatePanState(element).IsPanning)
+        {
+            return;
+        }
+
+        StopPanning(element, restoreCursor: true);
+        e.Handled = true;
+    }
+
+    private static void OnLostMouseCapture(object sender, MouseEventArgs e)
+    {
+        if (sender is FrameworkElement element)
+        {
+            StopPanning(element, restoreCursor: true);
+        }
+    }
+
+    private static void StopPanning(FrameworkElement element, bool restoreCursor)
+    {
+        var state = GetOrCreatePanState(element);
+        if (!state.IsPanning)
+        {
+            if (restoreCursor)
+            {
+                element.ClearValue(FrameworkElement.CursorProperty);
+            }
+
+            return;
+        }
+
+        state.IsPanning = false;
+
+        if (restoreCursor)
+        {
+            if (state.OriginalCursor is null)
+            {
+                element.ClearValue(FrameworkElement.CursorProperty);
+            }
+            else
+            {
+                element.Cursor = state.OriginalCursor;
+            }
+        }
+
+        state.OriginalCursor = null;
+
+        if (Mouse.Captured == element)
+        {
+            element.ReleaseMouseCapture();
+        }
+    }
+
+    private static bool CanStartPanning(DependencyObject? source)
+    {
+        while (source is not null)
+        {
+            if (source is ScrollBar
+                || source is Thumb
+                || source is DataGridColumnHeader
+                || source is GridViewColumnHeader
+                || source is TextBoxBase
+                || source is PasswordBox
+                || source is ComboBox
+                || source is ComboBoxItem
+                || source is ButtonBase)
+            {
+                return false;
+            }
+
+            source = VisualTreeHelper.GetParent(source);
+        }
+
+        return true;
+    }
+
+    private static double ClampOffset(double value, double maxValue) => Math.Max(0, Math.Min(maxValue, value));
+
+    private static T? FindVisualChild<T>(DependencyObject? parent) where T : DependencyObject
+    {
+        if (parent is null)
+        {
+            return null;
+        }
+
+        for (int i = 0; i < VisualTreeHelper.GetChildrenCount(parent); i++)
+        {
+            var child = VisualTreeHelper.GetChild(parent, i);
+            if (child is T target)
+            {
+                return target;
+            }
+
+            var nested = FindVisualChild<T>(child);
+            if (nested is not null)
+            {
+                return nested;
+            }
+        }
+
+        return null;
+    }
+
+    private sealed class PanState
+    {
+        public bool IsPanning { get; set; }
+        public Point StartPoint { get; set; }
+        public double StartHorizontalOffset { get; set; }
+        public double StartVerticalOffset { get; set; }
+        public Cursor? OriginalCursor { get; set; }
+        public ScrollViewer? ScrollViewer { get; set; }
+    }
+}
\ No newline at end of file
diff --git a/Lite/Themes/CoolBreezeTheme.xaml b/Lite/Themes/CoolBreezeTheme.xaml
index 739f20bb..d22edec4 100644
--- a/Lite/Themes/CoolBreezeTheme.xaml
+++ b/Lite/Themes/CoolBreezeTheme.xaml
@@ -600,6 +600,7 @@
     <!-- ============================================ -->
     <Style TargetType="DataGrid">
         <Setter Property="helpers:DataGridClipboardBehavior.FixHeaderCopy" Value="True"/>
+        <Setter Property="helpers:ScrollPanBehavior.EnableMiddleClickPanning" Value="True"/>
         <Setter Property="Background" Value="{StaticResource BackgroundDarkBrush}"/>
         <Setter Property="Foreground" Value="{StaticResource ForegroundBrush}"/>
         <Setter Property="BorderBrush" Value="{StaticResource BorderBrush}"/>
@@ -744,6 +745,7 @@
     <!-- ListView Style                               -->
     <!-- ============================================ -->
     <Style TargetType="ListView">
+        <Setter Property="helpers:ScrollPanBehavior.EnableMiddleClickPanning" Value="True"/>
         <Setter Property="Background" Value="{StaticResource BackgroundDarkBrush}"/>
         <Setter Property="Foreground" Value="{StaticResource ForegroundBrush}"/>
         <Setter Property="BorderBrush" Value="{StaticResource BorderBrush}"/>
diff --git a/Lite/Themes/DarkTheme.xaml b/Lite/Themes/DarkTheme.xaml
index db5aac54..3d64f59d 100644
--- a/Lite/Themes/DarkTheme.xaml
+++ b/Lite/Themes/DarkTheme.xaml
@@ -600,6 +600,7 @@
     <!-- ============================================ -->
     <Style TargetType="DataGrid">
         <Setter Property="helpers:DataGridClipboardBehavior.FixHeaderCopy" Value="True"/>
+        <Setter Property="helpers:ScrollPanBehavior.EnableMiddleClickPanning" Value="True"/>
         <Setter Property="Background" Value="{StaticResource BackgroundDarkBrush}"/>
         <Setter Property="Foreground" Value="{StaticResource ForegroundBrush}"/>
         <Setter Property="BorderBrush" Value="{StaticResource BorderBrush}"/>
@@ -744,6 +745,7 @@
     <!-- ListView Style                               -->
     <!-- ============================================ -->
     <Style TargetType="ListView">
+        <Setter Property="helpers:ScrollPanBehavior.EnableMiddleClickPanning" Value="True"/>
         <Setter Property="Background" Value="{StaticResource BackgroundDarkBrush}"/>
         <Setter Property="Foreground" Value="{StaticResource ForegroundBrush}"/>
         <Setter Property="BorderBrush" Value="{StaticResource BorderBrush}"/>
diff --git a/Lite/Themes/LightTheme.xaml b/Lite/Themes/LightTheme.xaml
index 063b3526..e47e2411 100644
--- a/Lite/Themes/LightTheme.xaml
+++ b/Lite/Themes/LightTheme.xaml
@@ -600,6 +600,7 @@
     <!-- ============================================ -->
     <Style TargetType="DataGrid">
         <Setter Property="helpers:DataGridClipboardBehavior.FixHeaderCopy" Value="True"/>
+        <Setter Property="helpers:ScrollPanBehavior.EnableMiddleClickPanning" Value="True"/>
         <Setter Property="Background" Value="{StaticResource BackgroundDarkBrush}"/>
         <Setter Property="Foreground" Value="{StaticResource ForegroundBrush}"/>
         <Setter Property="BorderBrush" Value="{StaticResource BorderBrush}"/>
@@ -744,6 +745,7 @@
     <!-- ListView Style                               -->
     <!-- ============================================ -->
     <Style TargetType="ListView">
+        <Setter Property="helpers:ScrollPanBehavior.EnableMiddleClickPanning" Value="True"/>
         <Setter Property="Background" Value="{StaticResource BackgroundDarkBrush}"/>
         <Setter Property="Foreground" Value="{StaticResource ForegroundBrush}"/>
         <Setter Property="BorderBrush" Value="{StaticResource BorderBrush}"/>

From d6b49a5d07aacd21cc1263e0b2a6617a34823f1a Mon Sep 17 00:00:00 2001
From: ClaudioESSilva <claudiosil100@gmail.com>
Date: Wed, 15 Apr 2026 18:31:48 +0100
Subject: [PATCH 02/49] Implements #843 for Full Dashboard

---
 Dashboard/Helpers/ScrollPanBehavior.cs | 271 +++++++++++++++++++++++++
 Dashboard/Themes/CoolBreezeTheme.xaml  |   2 +
 Dashboard/Themes/DarkTheme.xaml        |   2 +
 Dashboard/Themes/LightTheme.xaml       |   2 +
 4 files changed, 277 insertions(+)
 create mode 100644 Dashboard/Helpers/ScrollPanBehavior.cs

diff --git a/Dashboard/Helpers/ScrollPanBehavior.cs b/Dashboard/Helpers/ScrollPanBehavior.cs
new file mode 100644
index 00000000..485483b9
--- /dev/null
+++ b/Dashboard/Helpers/ScrollPanBehavior.cs
@@ -0,0 +1,271 @@
+/*
+ * Copyright (c) 2026 Erik Darling, Darling Data LLC
+ *
+ * This file is part of the SQL Server Performance Monitor.
+ *
+ * Licensed under the MIT License. See LICENSE file in the project root for full license information.
+ */
+
+using System;
+using System.Windows;
+using System.Windows.Controls;
+using System.Windows.Controls.Primitives;
+using System.Windows.Input;
+using System.Windows.Media;
+
+namespace PerformanceMonitorDashboard.Helpers;
+
+/// <summary>
+/// Enables middle-mouse drag panning for scrollable controls such as DataGrid and ListView.
+/// </summary>
+public static class ScrollPanBehavior
+{
+    public static readonly DependencyProperty EnableMiddleClickPanningProperty =
+        DependencyProperty.RegisterAttached(
+            "EnableMiddleClickPanning",
+            typeof(bool),
+            typeof(ScrollPanBehavior),
+            new PropertyMetadata(false, OnEnableMiddleClickPanningChanged));
+
+    private static readonly DependencyProperty PanStateProperty =
+        DependencyProperty.RegisterAttached(
+            "PanState",
+            typeof(PanState),
+            typeof(ScrollPanBehavior),
+            new PropertyMetadata(null));
+
+    public static bool GetEnableMiddleClickPanning(DependencyObject obj) => (bool)obj.GetValue(EnableMiddleClickPanningProperty);
+    public static void SetEnableMiddleClickPanning(DependencyObject obj, bool value) => obj.SetValue(EnableMiddleClickPanningProperty, value);
+
+    private static PanState GetOrCreatePanState(FrameworkElement element)
+    {
+        if (element.GetValue(PanStateProperty) is not PanState state)
+        {
+            state = new PanState();
+            element.SetValue(PanStateProperty, state);
+        }
+
+        return state;
+    }
+
+    private static void OnEnableMiddleClickPanningChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
+    {
+        if (d is not FrameworkElement element)
+        {
+            return;
+        }
+
+        var isEnabled = (bool)e.NewValue;
+
+        if (isEnabled)
+        {
+            element.Loaded += OnLoaded;
+            element.Unloaded += OnUnloaded;
+            element.PreviewMouseDown += OnPreviewMouseDown;
+            element.PreviewMouseMove += OnPreviewMouseMove;
+            element.PreviewMouseUp += OnPreviewMouseUp;
+            element.LostMouseCapture += OnLostMouseCapture;
+        }
+        else
+        {
+            element.Loaded -= OnLoaded;
+            element.Unloaded -= OnUnloaded;
+            element.PreviewMouseDown -= OnPreviewMouseDown;
+            element.PreviewMouseMove -= OnPreviewMouseMove;
+            element.PreviewMouseUp -= OnPreviewMouseUp;
+            element.LostMouseCapture -= OnLostMouseCapture;
+            StopPanning(element, restoreCursor: true);
+        }
+    }
+
+    private static void OnLoaded(object sender, RoutedEventArgs e)
+    {
+        if (sender is FrameworkElement element)
+        {
+            GetOrCreatePanState(element).ScrollViewer = FindVisualChild<ScrollViewer>(element);
+        }
+    }
+
+    private static void OnUnloaded(object sender, RoutedEventArgs e)
+    {
+        if (sender is FrameworkElement element)
+        {
+            StopPanning(element, restoreCursor: false);
+            GetOrCreatePanState(element).ScrollViewer = null;
+        }
+    }
+
+    private static void OnPreviewMouseDown(object sender, MouseButtonEventArgs e)
+    {
+        if (e.ChangedButton != MouseButton.Middle
+            || sender is not FrameworkElement element
+            || !CanStartPanning(e.OriginalSource as DependencyObject))
+        {
+            return;
+        }
+
+        var state = GetOrCreatePanState(element);
+        state.ScrollViewer ??= FindVisualChild<ScrollViewer>(element);
+
+        if (state.ScrollViewer is null)
+        {
+            return;
+        }
+
+        if (state.ScrollViewer.ScrollableWidth <= 0 && state.ScrollViewer.ScrollableHeight <= 0)
+        {
+            return;
+        }
+
+        state.IsPanning = true;
+        state.StartPoint = e.GetPosition(state.ScrollViewer);
+        state.StartHorizontalOffset = state.ScrollViewer.HorizontalOffset;
+        state.StartVerticalOffset = state.ScrollViewer.VerticalOffset;
+        state.OriginalCursor = element.Cursor;
+
+        element.Cursor = Cursors.ScrollAll;
+        element.CaptureMouse();
+        e.Handled = true;
+    }
+
+    private static void OnPreviewMouseMove(object sender, MouseEventArgs e)
+    {
+        if (sender is not FrameworkElement element)
+        {
+            return;
+        }
+
+        var state = GetOrCreatePanState(element);
+        if (!state.IsPanning || state.ScrollViewer is null)
+        {
+            return;
+        }
+
+        var currentPoint = e.GetPosition(state.ScrollViewer);
+        var deltaX = currentPoint.X - state.StartPoint.X;
+        var deltaY = currentPoint.Y - state.StartPoint.Y;
+
+        state.ScrollViewer.ScrollToHorizontalOffset(ClampOffset(state.StartHorizontalOffset - deltaX, state.ScrollViewer.ScrollableWidth));
+        state.ScrollViewer.ScrollToVerticalOffset(ClampOffset(state.StartVerticalOffset - deltaY, state.ScrollViewer.ScrollableHeight));
+        e.Handled = true;
+    }
+
+    private static void OnPreviewMouseUp(object sender, MouseButtonEventArgs e)
+    {
+        if (e.ChangedButton != MouseButton.Middle || sender is not FrameworkElement element)
+        {
+            return;
+        }
+
+        if (!GetOrCreatePanState(element).IsPanning)
+        {
+            return;
+        }
+
+        StopPanning(element, restoreCursor: true);
+        e.Handled = true;
+    }
+
+    private static void OnLostMouseCapture(object sender, MouseEventArgs e)
+    {
+        if (sender is FrameworkElement element)
+        {
+            StopPanning(element, restoreCursor: true);
+        }
+    }
+
+    private static void StopPanning(FrameworkElement element, bool restoreCursor)
+    {
+        var state = GetOrCreatePanState(element);
+        if (!state.IsPanning)
+        {
+            if (restoreCursor)
+            {
+                element.ClearValue(FrameworkElement.CursorProperty);
+            }
+
+            return;
+        }
+
+        state.IsPanning = false;
+
+        if (restoreCursor)
+        {
+            if (state.OriginalCursor is null)
+            {
+                element.ClearValue(FrameworkElement.CursorProperty);
+            }
+            else
+            {
+                element.Cursor = state.OriginalCursor;
+            }
+        }
+
+        state.OriginalCursor = null;
+
+        if (Mouse.Captured == element)
+        {
+            element.ReleaseMouseCapture();
+        }
+    }
+
+    private static bool CanStartPanning(DependencyObject? source)
+    {
+        while (source is not null)
+        {
+            if (source is ScrollBar
+                || source is Thumb
+                || source is DataGridColumnHeader
+                || source is GridViewColumnHeader
+                || source is TextBoxBase
+                || source is PasswordBox
+                || source is ComboBox
+                || source is ComboBoxItem
+                || source is ButtonBase)
+            {
+                return false;
+            }
+
+            source = VisualTreeHelper.GetParent(source);
+        }
+
+        return true;
+    }
+
+    private static double ClampOffset(double value, double maxValue) => Math.Max(0, Math.Min(maxValue, value));
+
+    private static T? FindVisualChild<T>(DependencyObject? parent) where T : DependencyObject
+    {
+        if (parent is null)
+        {
+            return null;
+        }
+
+        for (int i = 0; i < VisualTreeHelper.GetChildrenCount(parent); i++)
+        {
+            var child = VisualTreeHelper.GetChild(parent, i);
+            if (child is T target)
+            {
+                return target;
+            }
+
+            var nested = FindVisualChild<T>(child);
+            if (nested is not null)
+            {
+                return nested;
+            }
+        }
+
+        return null;
+    }
+
+    private sealed class PanState
+    {
+        public bool IsPanning { get; set; }
+        public Point StartPoint { get; set; }
+        public double StartHorizontalOffset { get; set; }
+        public double StartVerticalOffset { get; set; }
+        public Cursor? OriginalCursor { get; set; }
+        public ScrollViewer? ScrollViewer { get; set; }
+    }
+}
\ No newline at end of file
diff --git a/Dashboard/Themes/CoolBreezeTheme.xaml b/Dashboard/Themes/CoolBreezeTheme.xaml
index 4eb70025..933d65e4 100644
--- a/Dashboard/Themes/CoolBreezeTheme.xaml
+++ b/Dashboard/Themes/CoolBreezeTheme.xaml
@@ -649,6 +649,7 @@
     <!-- ============================================ -->
     <Style TargetType="DataGrid">
         <Setter Property="helpers:DataGridClipboardBehavior.FixHeaderCopy" Value="True"/>
+        <Setter Property="helpers:ScrollPanBehavior.EnableMiddleClickPanning" Value="True"/>
         <Setter Property="Background" Value="{StaticResource BackgroundDarkBrush}"/>
         <Setter Property="Foreground" Value="{StaticResource ForegroundBrush}"/>
         <Setter Property="BorderBrush" Value="{StaticResource BorderBrush}"/>
@@ -793,6 +794,7 @@
     <!-- ListView Style                               -->
     <!-- ============================================ -->
     <Style TargetType="ListView">
+        <Setter Property="helpers:ScrollPanBehavior.EnableMiddleClickPanning" Value="True"/>
         <Setter Property="Background" Value="{StaticResource BackgroundDarkBrush}"/>
         <Setter Property="Foreground" Value="{StaticResource ForegroundBrush}"/>
         <Setter Property="BorderBrush" Value="{StaticResource BorderBrush}"/>
diff --git a/Dashboard/Themes/DarkTheme.xaml b/Dashboard/Themes/DarkTheme.xaml
index 73cc58cb..5e0b8324 100644
--- a/Dashboard/Themes/DarkTheme.xaml
+++ b/Dashboard/Themes/DarkTheme.xaml
@@ -648,6 +648,7 @@
     <!-- ============================================ -->
     <Style TargetType="DataGrid">
         <Setter Property="helpers:DataGridClipboardBehavior.FixHeaderCopy" Value="True"/>
+        <Setter Property="helpers:ScrollPanBehavior.EnableMiddleClickPanning" Value="True"/>
         <Setter Property="Background" Value="{StaticResource BackgroundDarkBrush}"/>
         <Setter Property="Foreground" Value="{StaticResource ForegroundBrush}"/>
         <Setter Property="BorderBrush" Value="{StaticResource BorderBrush}"/>
@@ -792,6 +793,7 @@
     <!-- ListView Style                               -->
     <!-- ============================================ -->
     <Style TargetType="ListView">
+        <Setter Property="helpers:ScrollPanBehavior.EnableMiddleClickPanning" Value="True"/>
         <Setter Property="Background" Value="{StaticResource BackgroundDarkBrush}"/>
         <Setter Property="Foreground" Value="{StaticResource ForegroundBrush}"/>
         <Setter Property="BorderBrush" Value="{StaticResource BorderBrush}"/>
diff --git a/Dashboard/Themes/LightTheme.xaml b/Dashboard/Themes/LightTheme.xaml
index b2fff248..903203f3 100644
--- a/Dashboard/Themes/LightTheme.xaml
+++ b/Dashboard/Themes/LightTheme.xaml
@@ -649,6 +649,7 @@
     <!-- ============================================ -->
     <Style TargetType="DataGrid">
         <Setter Property="helpers:DataGridClipboardBehavior.FixHeaderCopy" Value="True"/>
+        <Setter Property="helpers:ScrollPanBehavior.EnableMiddleClickPanning" Value="True"/>
         <Setter Property="Background" Value="{StaticResource BackgroundDarkBrush}"/>
         <Setter Property="Foreground" Value="{StaticResource ForegroundBrush}"/>
         <Setter Property="BorderBrush" Value="{StaticResource BorderBrush}"/>
@@ -793,6 +794,7 @@
     <!-- ListView Style                               -->
     <!-- ============================================ -->
     <Style TargetType="ListView">
+        <Setter Property="helpers:ScrollPanBehavior.EnableMiddleClickPanning" Value="True"/>
         <Setter Property="Background" Value="{StaticResource BackgroundDarkBrush}"/>
         <Setter Property="Foreground" Value="{StaticResource ForegroundBrush}"/>
         <Setter Property="BorderBrush" Value="{StaticResource BorderBrush}"/>

From 214b64e4944e1710b90478fa015f518c0e0377a1 Mon Sep 17 00:00:00 2001
From: Erik Darling <2136037+erikdarlingdata@users.noreply.github.com>
Date: Wed, 15 Apr 2026 14:40:34 -0400
Subject: [PATCH 03/49] Add trailing newlines to ScrollPanBehavior files

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
---
 Dashboard/Helpers/ScrollPanBehavior.cs | 2 +-
 Lite/Helpers/ScrollPanBehavior.cs      | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/Dashboard/Helpers/ScrollPanBehavior.cs b/Dashboard/Helpers/ScrollPanBehavior.cs
index 485483b9..706d144e 100644
--- a/Dashboard/Helpers/ScrollPanBehavior.cs
+++ b/Dashboard/Helpers/ScrollPanBehavior.cs
@@ -268,4 +268,4 @@ private sealed class PanState
         public Cursor? OriginalCursor { get; set; }
         public ScrollViewer? ScrollViewer { get; set; }
     }
-}
\ No newline at end of file
+}
diff --git a/Lite/Helpers/ScrollPanBehavior.cs b/Lite/Helpers/ScrollPanBehavior.cs
index e823c8f9..daa92308 100644
--- a/Lite/Helpers/ScrollPanBehavior.cs
+++ b/Lite/Helpers/ScrollPanBehavior.cs
@@ -268,4 +268,4 @@ private sealed class PanState
         public Cursor? OriginalCursor { get; set; }
         public ScrollViewer? ScrollViewer { get; set; }
     }
-}
\ No newline at end of file
+}

From ccf82aae4b4547ecc97bc4842b79b7f51caf795b Mon Sep 17 00:00:00 2001
From: Erik Darling <2136037+erikdarlingdata@users.noreply.github.com>
Date: Wed, 15 Apr 2026 16:54:11 -0400
Subject: [PATCH 04/49] Harden DuckDB queries: parameterize values, escape
 paths, fix IsArchiving race

Addresses security findings from #840:
- #846: Escape single quotes in file paths interpolated into read_parquet() and COPY TO
- #847: Use DuckDB $1 parameters for DateTime values instead of string interpolation
- #849: Make IsArchiving volatile-backed to prevent stale reads across threads

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
---
 Lite/Database/DuckDbInitializer.cs |  8 ++++++--
 Lite/Services/ArchiveService.cs    | 33 ++++++++++++++++++++----------
 2 files changed, 28 insertions(+), 13 deletions(-)

diff --git a/Lite/Database/DuckDbInitializer.cs b/Lite/Database/DuckDbInitializer.cs
index 93b93053..c7295783 100644
--- a/Lite/Database/DuckDbInitializer.cs
+++ b/Lite/Database/DuckDbInitializer.cs
@@ -724,7 +724,7 @@ public async Task CreateArchiveViewsAsync()
                 string viewSql;
                 if (hasParquetFiles)
                 {
-                    var globPath = parquetGlob.Replace("\\", "/");
+                    var globPath = EscapeSqlPath(parquetGlob.Replace("\\", "/"));
                     if (table == "config_alert_log")
                     {
                         viewSql = $@"CREATE OR REPLACE VIEW v_{table} AS
@@ -935,5 +935,9 @@ public async Task ResetDatabaseAsync()
         await InitializeAsync();
     }
 
-
+    /// <summary>
+    /// Escapes single quotes in a file path for safe interpolation into DuckDB SQL.
+    /// DuckDB does not support parameterized paths in read_parquet() or COPY TO.
+    /// </summary>
+    internal static string EscapeSqlPath(string path) => path.Replace("'", "''");
 }
diff --git a/Lite/Services/ArchiveService.cs b/Lite/Services/ArchiveService.cs
index d286589b..35d9c7e1 100644
--- a/Lite/Services/ArchiveService.cs
+++ b/Lite/Services/ArchiveService.cs
@@ -33,8 +33,14 @@ public class ArchiveService
     /// <summary>
     /// Indicates whether an archival operation is currently in progress.
     /// UI code can check this to warn users before dismiss or show a status indicator.
+    /// Volatile-backed to ensure cross-thread visibility without locking.
     /// </summary>
-    public static bool IsArchiving { get; private set; }
+    private static volatile bool s_isArchiving;
+    public static bool IsArchiving
+    {
+        get => s_isArchiving;
+        private set => s_isArchiving = value;
+    }
 
     /* Tables eligible for archival with their time column.
        IMPORTANT: Every table with time-series data must be listed here,
@@ -133,7 +139,8 @@ Archive views use glob (*_table.parquet) to pick up all files. */
 
                     /* Delete archived rows from hot table */
                     using var deleteCmd = connection.CreateCommand();
-                    deleteCmd.CommandText = $"DELETE FROM {table} WHERE {timeColumn} < '{cutoffDate:yyyy-MM-dd HH:mm:ss}'";
+                    deleteCmd.CommandText = $"DELETE FROM {table} WHERE {timeColumn} < $1";
+                    deleteCmd.Parameters.Add(new DuckDBParameter { Value = cutoffDate });
                     await deleteCmd.ExecuteNonQueryAsync();
 
                     _logger?.LogInformation("Archived {Count} rows from {Table} to {Path}", rowCount, table, parquetPath);
@@ -161,7 +168,8 @@ Archive views use glob (*_table.parquet) to pick up all files. */
     private static async Task<long> GetRowCountBeforeCutoff(DuckDBConnection connection, string table, string timeColumn, DateTime cutoff)
     {
         using var cmd = connection.CreateCommand();
-        cmd.CommandText = $"SELECT COUNT(*) FROM {table} WHERE {timeColumn} < '{cutoff:yyyy-MM-dd HH:mm:ss}'";
+        cmd.CommandText = $"SELECT COUNT(*) FROM {table} WHERE {timeColumn} < $1";
+        cmd.Parameters.Add(new DuckDBParameter { Value = cutoff });
         var result = await cmd.ExecuteScalarAsync();
         return Convert.ToInt64(result);
     }
@@ -171,11 +179,14 @@ private static async Task ExportToParquet(DuckDBConnection connection, string ta
         using var cmd = connection.CreateCommand();
         cmd.CommandText = $@"
 COPY (
-    SELECT * FROM {table} WHERE {timeColumn} < '{cutoff:yyyy-MM-dd HH:mm:ss}'
-) TO '{filePath}' (FORMAT PARQUET, COMPRESSION ZSTD)";
+    SELECT * FROM {table} WHERE {timeColumn} < $1
+) TO '{EscapeSqlPath(filePath)}' (FORMAT PARQUET, COMPRESSION ZSTD)";
+        cmd.Parameters.Add(new DuckDBParameter { Value = cutoff });
         await cmd.ExecuteNonQueryAsync();
     }
 
+    private static string EscapeSqlPath(string path) => DuckDbInitializer.EscapeSqlPath(path);
+
     /* Columns to exclude during compaction — dead weight from legacy archives */
     private static readonly Dictionary<string, string[]> CompactionExcludeColumns = new()
     {
@@ -343,7 +354,7 @@ Each group gets its own DuckDB connection so memory is fully released between gr
                 {
                     using var schemaCon = new DuckDBConnection("DataSource=:memory:");
                     schemaCon.Open();
-                    var allPathList = string.Join(", ", sourcePaths.Select(p => $"'{p}'"));
+                    var allPathList = string.Join(", ", sourcePaths.Select(p => $"'{EscapeSqlPath(p)}'"));
                     using var schemaCmd = schemaCon.CreateCommand();
                     schemaCmd.CommandText = $"SELECT column_name FROM (DESCRIBE SELECT * FROM read_parquet([{allPathList}], union_by_name=true))";
                     using var reader = schemaCmd.ExecuteReader();
@@ -368,10 +379,10 @@ Each group gets its own DuckDB connection so memory is fully released between gr
                         pragma.ExecuteNonQuery();
                     }
 
-                    var pathList = string.Join(", ", sourcePaths.Select(p => $"'{p}'"));
+                    var pathList = string.Join(", ", sourcePaths.Select(p => $"'{EscapeSqlPath(p)}'"));
                     using var cmd = con.CreateCommand();
                     cmd.CommandText = $"COPY (SELECT {selectClause} FROM read_parquet([{pathList}], union_by_name=true)) " +
-                                      $"TO '{tempPath}' (FORMAT PARQUET, COMPRESSION ZSTD, ROW_GROUP_SIZE 122880)";
+                                      $"TO '{EscapeSqlPath(tempPath)}' (FORMAT PARQUET, COMPRESSION ZSTD, ROW_GROUP_SIZE 122880)";
                     cmd.ExecuteNonQuery();
                 }
                 else
@@ -399,10 +410,10 @@ Sort smallest-first so early merges are cheap. */
                             pragma.ExecuteNonQuery();
                         }
 
-                        var pairList = $"'{currentPath}', '{sorted[i]}'";
+                        var pairList = $"'{EscapeSqlPath(currentPath)}', '{EscapeSqlPath(sorted[i])}'";
                         using var cmd = con.CreateCommand();
                         cmd.CommandText = $"COPY (SELECT {selectClause} FROM read_parquet([{pairList}], union_by_name=true)) " +
-                                          $"TO '{stepOutput}' (FORMAT PARQUET, COMPRESSION ZSTD, ROW_GROUP_SIZE 122880)";
+                                          $"TO '{EscapeSqlPath(stepOutput)}' (FORMAT PARQUET, COMPRESSION ZSTD, ROW_GROUP_SIZE 122880)";
                         cmd.ExecuteNonQuery();
 
                         /* Clean up previous intermediate file */
@@ -511,7 +522,7 @@ Archive views use glob (*_table.parquet) to pick up all files. */
                             .Replace("\\", "/");
 
                         using var exportCmd = connection.CreateCommand();
-                        exportCmd.CommandText = $"COPY (SELECT * FROM {table}) TO '{parquetPath}' (FORMAT PARQUET, COMPRESSION ZSTD)";
+                        exportCmd.CommandText = $"COPY (SELECT * FROM {table}) TO '{EscapeSqlPath(parquetPath)}' (FORMAT PARQUET, COMPRESSION ZSTD)";
                         await exportCmd.ExecuteNonQueryAsync();
 
                         _logger?.LogInformation("Archived {Count} rows from {Table}", rowCount, table);

From c11608d931bc1f6bfabdf3f57a83c0921162e628 Mon Sep 17 00:00:00 2001
From: Erik Darling <2136037+erikdarlingdata@users.noreply.github.com>
Date: Wed, 15 Apr 2026 17:22:47 -0400
Subject: [PATCH 05/49] Encrypt webhook URLs with DPAPI via Windows Credential
 Manager

Moves Teams and Slack webhook URLs from plaintext settings.json/preferences.json
to Windows Credential Manager (DPAPI-encrypted), matching the existing pattern
used for SMTP passwords and SQL Server credentials.

Includes automatic migration: on first settings load, any plaintext URLs are
moved to Credential Manager and removed from the JSON file.

Closes #848

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
---
 Dashboard/Services/WebhookAlertService.cs | 57 +++++++++++++++++--
 Dashboard/SettingsWindow.xaml.cs          | 28 ++++++++--
 Lite/App.xaml.cs                          | 68 ++++++++++++++++++++++-
 Lite/Windows/SettingsWindow.xaml.cs       | 13 ++++-
 4 files changed, 154 insertions(+), 12 deletions(-)

diff --git a/Dashboard/Services/WebhookAlertService.cs b/Dashboard/Services/WebhookAlertService.cs
index f9cb68b2..1befa1e2 100644
--- a/Dashboard/Services/WebhookAlertService.cs
+++ b/Dashboard/Services/WebhookAlertService.cs
@@ -24,7 +24,10 @@ namespace PerformanceMonitorDashboard.Services
     public class WebhookAlertService
     {
         private const string EditionName = "Performance Monitor Dashboard";
+        private const string TeamsWebhookCredentialKey = "TeamsWebhook";
+        private const string SlackWebhookCredentialKey = "SlackWebhook";
         private static readonly JsonSerializerOptions s_jsonOptions = new() { PropertyNamingPolicy = null };
+        private static readonly CredentialService s_credentialService = new();
 
         private readonly UserPreferencesService _preferencesService;
         private readonly ConcurrentDictionary<string, DateTime> _cooldowns = new();
@@ -42,6 +45,50 @@ public WebhookAlertService(UserPreferencesService preferencesService)
             Current = this;
         }
 
+        /// <summary>
+        /// Gets a webhook URL from Windows Credential Manager.
+        /// </summary>
+        public static string GetWebhookUrl(string credentialKey)
+        {
+            try
+            {
+                var cred = s_credentialService.GetCredential(credentialKey);
+                return cred?.Password ?? "";
+            }
+            catch (Exception ex)
+            {
+                Logger.Error($"Failed to retrieve webhook URL for {credentialKey}: {ex.Message}");
+                return "";
+            }
+        }
+
+        /// <summary>
+        /// Saves a webhook URL to Windows Credential Manager.
+        /// </summary>
+        public static void SaveWebhookUrl(string credentialKey, string url)
+        {
+            try
+            {
+                if (string.IsNullOrWhiteSpace(url))
+                {
+                    s_credentialService.DeleteCredential(credentialKey);
+                }
+                else
+                {
+                    s_credentialService.SaveCredential(credentialKey, "webhook", url);
+                }
+            }
+            catch (Exception ex)
+            {
+                Logger.Error($"Failed to save webhook URL for {credentialKey}: {ex.Message}");
+            }
+        }
+
+        public static string GetTeamsWebhookUrl() => GetWebhookUrl(TeamsWebhookCredentialKey);
+        public static string GetSlackWebhookUrl() => GetWebhookUrl(SlackWebhookCredentialKey);
+        public static void SaveTeamsWebhookUrl(string url) => SaveWebhookUrl(TeamsWebhookCredentialKey, url);
+        public static void SaveSlackWebhookUrl(string url) => SaveWebhookUrl(SlackWebhookCredentialKey, url);
+
         /// <summary>
         /// Sends webhook alerts to all configured channels (Teams and/or Slack).
         /// Respects the email cooldown setting for throttling. Never throws.
@@ -67,12 +114,14 @@ public async Task<bool> TrySendWebhookAlertsAsync(
 
                 bool sent = false;
 
-                if (prefs.TeamsWebhookEnabled && !string.IsNullOrWhiteSpace(prefs.TeamsWebhookUrl))
+                var teamsUrl = GetTeamsWebhookUrl();
+                if (prefs.TeamsWebhookEnabled && !string.IsNullOrWhiteSpace(teamsUrl))
                 {
                     sent |= await TrySendTeamsAlertAsync(prefs, metricName, serverName, currentValue, thresholdValue, context);
                 }
 
-                if (prefs.SlackWebhookEnabled && !string.IsNullOrWhiteSpace(prefs.SlackWebhookUrl))
+                var slackUrl = GetSlackWebhookUrl();
+                if (prefs.SlackWebhookEnabled && !string.IsNullOrWhiteSpace(slackUrl))
                 {
                     sent |= await TrySendSlackAlertAsync(prefs, metricName, serverName, currentValue, thresholdValue, context);
                 }
@@ -148,7 +197,7 @@ private async Task<bool> TrySendTeamsAlertAsync(
             try
             {
                 var payload = BuildTeamsPayload(metricName, serverName, currentValue, thresholdValue, context: context);
-                var error = await PostWebhookAsync(prefs.TeamsWebhookUrl, payload, prefs.TeamsProxyAddress);
+                var error = await PostWebhookAsync(GetTeamsWebhookUrl(), payload, prefs.TeamsProxyAddress);
 
                 if (error != null)
                 {
@@ -268,7 +317,7 @@ private async Task<bool> TrySendSlackAlertAsync(
             try
             {
                 var payload = BuildSlackPayload(metricName, serverName, currentValue, thresholdValue, context: context);
-                var error = await PostWebhookAsync(prefs.SlackWebhookUrl, payload, prefs.SlackProxyAddress);
+                var error = await PostWebhookAsync(GetSlackWebhookUrl(), payload, prefs.SlackProxyAddress);
 
                 if (error != null)
                 {
diff --git a/Dashboard/SettingsWindow.xaml.cs b/Dashboard/SettingsWindow.xaml.cs
index d4491ac8..bbdbebe1 100644
--- a/Dashboard/SettingsWindow.xaml.cs
+++ b/Dashboard/SettingsWindow.xaml.cs
@@ -210,11 +210,27 @@ private void LoadSettings()
 
             // Webhook settings (Teams / Slack)
             TeamsWebhookEnabledCheckBox.IsChecked = prefs.TeamsWebhookEnabled;
-            TeamsWebhookUrlTextBox.Text = prefs.TeamsWebhookUrl;
             TeamsProxyAddressTextBox.Text = prefs.TeamsProxyAddress;
             SlackWebhookEnabledCheckBox.IsChecked = prefs.SlackWebhookEnabled;
-            SlackWebhookUrlTextBox.Text = prefs.SlackWebhookUrl;
             SlackProxyAddressTextBox.Text = prefs.SlackProxyAddress;
+
+            /* Migrate legacy plaintext webhook URLs to Credential Manager */
+            if (!string.IsNullOrWhiteSpace(prefs.TeamsWebhookUrl))
+            {
+                WebhookAlertService.SaveTeamsWebhookUrl(prefs.TeamsWebhookUrl);
+                prefs.TeamsWebhookUrl = "";
+                _preferencesService.SavePreferences(prefs);
+            }
+            if (!string.IsNullOrWhiteSpace(prefs.SlackWebhookUrl))
+            {
+                WebhookAlertService.SaveSlackWebhookUrl(prefs.SlackWebhookUrl);
+                prefs.SlackWebhookUrl = "";
+                _preferencesService.SavePreferences(prefs);
+            }
+
+            /* Load webhook URLs from Credential Manager */
+            TeamsWebhookUrlTextBox.Text = WebhookAlertService.GetTeamsWebhookUrl();
+            SlackWebhookUrlTextBox.Text = WebhookAlertService.GetSlackWebhookUrl();
             UpdateTeamsControlStates();
             UpdateSlackControlStates();
 
@@ -705,12 +721,16 @@ private async void OkButton_Click(object sender, RoutedEventArgs e)
 
             // Save webhook settings (Teams / Slack)
             prefs.TeamsWebhookEnabled = TeamsWebhookEnabledCheckBox.IsChecked == true;
-            prefs.TeamsWebhookUrl = TeamsWebhookUrlTextBox.Text?.Trim() ?? "";
+            prefs.TeamsWebhookUrl = "";  /* URLs stored in Credential Manager, not preferences */
             prefs.TeamsProxyAddress = TeamsProxyAddressTextBox.Text?.Trim() ?? "";
             prefs.SlackWebhookEnabled = SlackWebhookEnabledCheckBox.IsChecked == true;
-            prefs.SlackWebhookUrl = SlackWebhookUrlTextBox.Text?.Trim() ?? "";
+            prefs.SlackWebhookUrl = "";  /* URLs stored in Credential Manager, not preferences */
             prefs.SlackProxyAddress = SlackProxyAddressTextBox.Text?.Trim() ?? "";
 
+            /* Save webhook URLs to Credential Manager */
+            WebhookAlertService.SaveTeamsWebhookUrl(TeamsWebhookUrlTextBox.Text?.Trim() ?? "");
+            WebhookAlertService.SaveSlackWebhookUrl(SlackWebhookUrlTextBox.Text?.Trim() ?? "");
+
             // Save MCP server settings
             bool mcpWasEnabled = prefs.McpEnabled;
             prefs.McpEnabled = McpEnabledCheckBox.IsChecked == true;
diff --git a/Lite/App.xaml.cs b/Lite/App.xaml.cs
index 4b2ba29b..8583a087 100644
--- a/Lite/App.xaml.cs
+++ b/Lite/App.xaml.cs
@@ -128,6 +128,50 @@ private static string GetDefaultCsvSeparator()
     public static string SlackWebhookUrl { get; set; } = "";
     public static string SlackProxyAddress { get; set; } = "";
 
+    private const string TeamsWebhookCredentialKey = "TeamsWebhook";
+    private const string SlackWebhookCredentialKey = "SlackWebhook";
+
+    /// <summary>
+    /// Gets a webhook URL from Windows Credential Manager.
+    /// </summary>
+    public static string GetWebhookUrl(string credentialKey)
+    {
+        try
+        {
+            var credService = new Services.CredentialService();
+            var cred = credService.GetCredential(credentialKey);
+            return cred?.Password ?? "";
+        }
+        catch (Exception ex)
+        {
+            AppLogger.Error("App", $"Failed to retrieve webhook URL for {credentialKey}: {ex.Message}");
+            return "";
+        }
+    }
+
+    /// <summary>
+    /// Saves a webhook URL to Windows Credential Manager.
+    /// </summary>
+    public static void SaveWebhookUrl(string credentialKey, string url)
+    {
+        try
+        {
+            var credService = new Services.CredentialService();
+            if (string.IsNullOrWhiteSpace(url))
+            {
+                credService.DeleteCredential(credentialKey);
+            }
+            else
+            {
+                credService.SaveCredential(credentialKey, "webhook", url);
+            }
+        }
+        catch (Exception ex)
+        {
+            AppLogger.Error("App", $"Failed to save webhook URL for {credentialKey}: {ex.Message}");
+        }
+    }
+
     /* SMTP email alert settings */
     public static bool SmtpEnabled { get; set; } = false;
     public static string SmtpServer { get; set; } = "";
@@ -356,14 +400,34 @@ public static void LoadAlertSettings()
 
             /* Teams webhook settings */
             if (root.TryGetProperty("teams_webhook_enabled", out v)) TeamsWebhookEnabled = v.GetBoolean();
-            if (root.TryGetProperty("teams_webhook_url", out v)) TeamsWebhookUrl = v.GetString() ?? "";
             if (root.TryGetProperty("teams_proxy_address", out v)) TeamsProxyAddress = v.GetString() ?? "";
 
             /* Slack webhook settings */
             if (root.TryGetProperty("slack_webhook_enabled", out v)) SlackWebhookEnabled = v.GetBoolean();
-            if (root.TryGetProperty("slack_webhook_url", out v)) SlackWebhookUrl = v.GetString() ?? "";
             if (root.TryGetProperty("slack_proxy_address", out v)) SlackProxyAddress = v.GetString() ?? "";
 
+            /* Migrate webhook URLs from plaintext settings.json to Credential Manager */
+            if (root.TryGetProperty("teams_webhook_url", out v))
+            {
+                var legacyUrl = v.GetString() ?? "";
+                if (!string.IsNullOrWhiteSpace(legacyUrl))
+                {
+                    SaveWebhookUrl(TeamsWebhookCredentialKey, legacyUrl);
+                }
+            }
+            if (root.TryGetProperty("slack_webhook_url", out v))
+            {
+                var legacyUrl = v.GetString() ?? "";
+                if (!string.IsNullOrWhiteSpace(legacyUrl))
+                {
+                    SaveWebhookUrl(SlackWebhookCredentialKey, legacyUrl);
+                }
+            }
+
+            /* Load webhook URLs from Credential Manager */
+            TeamsWebhookUrl = GetWebhookUrl(TeamsWebhookCredentialKey);
+            SlackWebhookUrl = GetWebhookUrl(SlackWebhookCredentialKey);
+
             /* SMTP settings */
             if (root.TryGetProperty("smtp_enabled", out v)) SmtpEnabled = v.GetBoolean();
             if (root.TryGetProperty("smtp_server", out v)) SmtpServer = v.GetString() ?? "";
diff --git a/Lite/Windows/SettingsWindow.xaml.cs b/Lite/Windows/SettingsWindow.xaml.cs
index a0651587..c0c8f24e 100644
--- a/Lite/Windows/SettingsWindow.xaml.cs
+++ b/Lite/Windows/SettingsWindow.xaml.cs
@@ -983,6 +983,10 @@ private void SaveWebhookSettings()
         App.SlackWebhookUrl = SlackWebhookUrlBox.Text?.Trim() ?? "";
         App.SlackProxyAddress = SlackProxyAddressBox.Text?.Trim() ?? "";
 
+        /* Save webhook URLs to Credential Manager instead of settings.json */
+        App.SaveWebhookUrl("TeamsWebhook", App.TeamsWebhookUrl);
+        App.SaveWebhookUrl("SlackWebhook", App.SlackWebhookUrl);
+
         var settingsPath = Path.Combine(App.ConfigDirectory, "settings.json");
         try
         {
@@ -998,12 +1002,17 @@ private void SaveWebhookSettings()
             }
 
             root["teams_webhook_enabled"] = App.TeamsWebhookEnabled;
-            root["teams_webhook_url"] = App.TeamsWebhookUrl;
             root["teams_proxy_address"] = App.TeamsProxyAddress;
             root["slack_webhook_enabled"] = App.SlackWebhookEnabled;
-            root["slack_webhook_url"] = App.SlackWebhookUrl;
             root["slack_proxy_address"] = App.SlackProxyAddress;
 
+            /* Remove legacy plaintext webhook URLs from settings.json */
+            if (root is JsonObject obj)
+            {
+                obj.Remove("teams_webhook_url");
+                obj.Remove("slack_webhook_url");
+            }
+
             var options = new JsonSerializerOptions { WriteIndented = true };
             File.WriteAllText(settingsPath, root.ToJsonString(options));
         }

From 523a91c37b36232f79e419590a9945cda54e7c20 Mon Sep 17 00:00:00 2001
From: Erik Darling <2136037+erikdarlingdata@users.noreply.github.com>
Date: Thu, 16 Apr 2026 07:22:33 -0400
Subject: [PATCH 06/49] Lazy-load server tabs: only load visible tab on open,
 full-load on first visit
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Initial tab open and Refresh button now only load the currently visible tab.
First switch to any tab triggers a full refresh of that tab (all sub-tabs).
Subsequent refreshes only hit the active sub-tab.

Ctrl+Click on Refresh Tab (or Ctrl+F5) refreshes all tabs at once.
Apply to All Tabs retains existing full-refresh behavior.

Fixes #835 — prevents heavy queries (e.g. GetQueryStatsAsync) from running
on tab open when the user is only viewing Overview.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
---
 Dashboard/ServerTab.xaml    |  2 +-
 Dashboard/ServerTab.xaml.cs | 23 +++++++++++++++--------
 2 files changed, 16 insertions(+), 9 deletions(-)

diff --git a/Dashboard/ServerTab.xaml b/Dashboard/ServerTab.xaml
index 45904263..e6927176 100644
--- a/Dashboard/ServerTab.xaml
+++ b/Dashboard/ServerTab.xaml
@@ -101,7 +101,7 @@
                 <StackPanel Grid.Row="0" Grid.Column="1" Grid.ColumnSpan="2" Orientation="Vertical" Margin="15,0,0,0">
                     <StackPanel Orientation="Horizontal">
                         <Button x:Name="ApplyToAllButton" Content="Apply to All Tabs" Click="ApplyToAllTabs_Click" Margin="2,0" Padding="12,5" Style="{DynamicResource AccentButton}"/>
-                        <Button x:Name="RefreshButton" Content="Refresh Tab" Click="RefreshButton_Click" Margin="2,0" Padding="12,5" Style="{DynamicResource SuccessButton}"/>
+                        <Button x:Name="RefreshButton" Content="Refresh Tab" Click="RefreshButton_Click" Margin="2,0" Padding="12,5" Style="{DynamicResource SuccessButton}" ToolTip="Refresh the current tab. Ctrl+Click to refresh all tabs."/>
                         <ToggleButton x:Name="AutoRefreshToggle" Content="Auto-Refresh: Off" Click="AutoRefreshToggle_Click" Margin="8,0,2,0" Padding="12,5" MinWidth="130" ToolTip="Toggle auto-refresh on/off. Configure interval in Settings."/>
                         <Button Content="Edit Schedules" Click="EditSchedules_Click" Margin="8,0,2,0" Padding="12,5" Style="{DynamicResource AccentButton}" ToolTip="Edit collector schedules (frequency, retention, enabled/disabled)"/>
                         <TextBlock Text="|" VerticalAlignment="Center" Margin="8,0,4,0" Foreground="{DynamicResource ForegroundBrush}"/>
diff --git a/Dashboard/ServerTab.xaml.cs b/Dashboard/ServerTab.xaml.cs
index 4ba7629e..6c9f7b1f 100644
--- a/Dashboard/ServerTab.xaml.cs
+++ b/Dashboard/ServerTab.xaml.cs
@@ -51,6 +51,7 @@ public partial class ServerTab : UserControl
         private bool _isRefreshing;
         private DateTime _refreshStartedUtc;
         private bool _suppressPickerUpdates;
+        private readonly HashSet<string> _initializedTabs = new();
 
         // Filter state dictionaries for each DataGrid
 
@@ -424,6 +425,7 @@ public void CleanupOnClose()
             _autoRefreshCts?.Cancel();
             _autoRefreshTimer?.Stop();
             _autoRefreshTimer = null;
+            _initializedTabs.Clear();
 
             Helpers.ThemeManager.ThemeChanged -= OnThemeChanged;
             Loaded -= ServerTab_Loaded;
@@ -549,7 +551,8 @@ private async void ServerTab_KeyDown(object sender, System.Windows.Input.KeyEven
                 if (e.Key == System.Windows.Input.Key.F5)
                 {
                     e.Handled = true;
-                    await LoadDataAsync();
+                    bool fullRefresh = System.Windows.Input.Keyboard.Modifiers.HasFlag(System.Windows.Input.ModifierKeys.Control);
+                    await LoadDataAsync(fullRefresh);
                 }
                 else if (e.Key == System.Windows.Input.Key.V &&
                          System.Windows.Input.Keyboard.Modifiers == System.Windows.Input.ModifierKeys.Control &&
@@ -640,7 +643,7 @@ private async void ServerTab_Loaded(object sender, RoutedEventArgs e)
                 CriticalIssuesTab.SetTimeRange(_globalHoursBack, _globalFromDate, _globalToDate);
                 DefaultTraceTab.SetTimeRange(_globalHoursBack, _globalFromDate, _globalToDate);
 
-                await LoadDataAsync();
+                await LoadDataAsync(fullRefresh: false);
                 SetupAutoRefresh();
             }
             catch (Exception ex)
@@ -654,7 +657,8 @@ private async void RefreshButton_Click(object sender, RoutedEventArgs e)
         {
             try
             {
-                await LoadDataAsync();
+                bool fullRefresh = System.Windows.Input.Keyboard.Modifiers.HasFlag(System.Windows.Input.ModifierKeys.Control);
+                await LoadDataAsync(fullRefresh);
             }
             catch (Exception ex)
             {
@@ -1271,7 +1275,9 @@ private async Task RefreshAllTabsAsync()
         }
 
         /// <summary>
-        /// Refreshes only the currently visible tab — used on auto-refresh timer tick.
+        /// Refreshes only the currently visible tab. On first visit to a tab,
+        /// does a full refresh so all sub-tabs are populated. Subsequent visits
+        /// only refresh the active sub-tab for speed.
         /// </summary>
         private async Task RefreshVisibleTabAsync()
         {
@@ -1279,6 +1285,7 @@ private async Task RefreshVisibleTabAsync()
             if (selectedTab == null) return;
 
             var tabHeader = GetTabHeaderText(selectedTab);
+            bool firstVisit = _initializedTabs.Add(tabHeader);
 
             switch (tabHeader)
             {
@@ -1286,19 +1293,19 @@ private async Task RefreshVisibleTabAsync()
                     await RefreshOverviewTabAsync();
                     break;
                 case "Queries":
-                    await RefreshQueriesTabAsync(fullRefresh: false);
+                    await RefreshQueriesTabAsync(fullRefresh: firstVisit);
                     break;
                 case "Resource Metrics":
-                    await RefreshResourceMetricsTabAsync(fullRefresh: false);
+                    await RefreshResourceMetricsTabAsync(fullRefresh: firstVisit);
                     break;
                 case "Memory":
-                    await RefreshMemoryTabAsync(fullRefresh: false);
+                    await RefreshMemoryTabAsync(fullRefresh: firstVisit);
                     break;
                 case "Locking":
                     await RefreshLockingTabAsync();
                     break;
                 case "System Events":
-                    await RefreshSystemEventsTabAsync(fullRefresh: false);
+                    await RefreshSystemEventsTabAsync(fullRefresh: firstVisit);
                     break;
                 // Plan Viewer has no data to refresh
             }

From 3db895c2260151d3b46335661f3ce05ea153aca7 Mon Sep 17 00:00:00 2001
From: Erik Darling <2136037+erikdarlingdata@users.noreply.github.com>
Date: Thu, 16 Apr 2026 07:25:29 -0400
Subject: [PATCH 07/49] Cap query/procedure/query store grid results to TOP 500

GetQueryStatsAsync, GetProcedureStatsAsync, and GetQueryStoreDataAsync
were returning unbounded result sets. With 49 databases and 742K rows
in query_stats over 3 days, the GROUP BY with plan XML could produce
thousands of rows and timeout after 120 seconds.

TOP 500 ordered by avg CPU desc is plenty for a grid view and prevents
the query from consuming unbounded memory on large installations.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
---
 Dashboard/Services/DatabaseService.QueryPerformance.cs | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/Dashboard/Services/DatabaseService.QueryPerformance.cs b/Dashboard/Services/DatabaseService.QueryPerformance.cs
index bd0e1825..365b45ed 100644
--- a/Dashboard/Services/DatabaseService.QueryPerformance.cs
+++ b/Dashboard/Services/DatabaseService.QueryPerformance.cs
@@ -1110,7 +1110,7 @@ GROUP BY
                 qs.query_hash,
                 qs.creation_time
         )
-        SELECT
+        SELECT TOP (500)
             database_name = pl.database_name,
             query_hash = CONVERT(nvarchar(20), pl.query_hash, 1),
             object_type = MAX(pl.object_type),
@@ -1345,7 +1345,7 @@ GROUP BY
                 ps.object_name,
                 ps.cached_time
         )
-        SELECT
+        SELECT TOP (500)
             database_name = pl.database_name,
             object_id = MAX(pl.object_id),
             object_name = QUOTENAME(pl.schema_name) + N'.' + QUOTENAME(pl.object_name),
@@ -1520,7 +1520,7 @@ public async Task<List<QueryStoreItem>> GetQueryStoreDataAsync(int hoursBack = 2
                     string query = @"
         SET TRANSACTION ISOLATION LEVEL READ UNCOMMITTED;
 
-        SELECT
+        SELECT TOP (500)
             database_name = qsd.database_name,
             query_id = qsd.query_id,
             execution_type_desc = MAX(qsd.execution_type_desc),

From 50d10f5346d0acac886ffc412f066ee9388b590f Mon Sep 17 00:00:00 2001
From: Erik Darling <2136037+erikdarlingdata@users.noreply.github.com>
Date: Thu, 16 Apr 2026 07:48:17 -0400
Subject: [PATCH 08/49] Remove pointless WAITFOR DECOMPRESS filters from
 stats/store queries
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

The CAST(DECOMPRESS(...)) NOT LIKE N'WAITFOR%' filter was decompressing
query text on every row in query_stats and query_store_data just to skip
WAITFOR queries. WAITFOR has no plan and no meaningful stats — it only
matters in query snapshots (active sessions), where the filter remains.

On a 742K-row query_stats table, this was a significant contributor to
the 120-second query timeouts reported in #835.

The snapshot filters (report.query_snapshots) and MCP phased queries
are untouched — they filter after TOP on already-hydrated text.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
---
 Dashboard/Services/DatabaseService.QueryPerformance.cs | 4 +---
 1 file changed, 1 insertion(+), 3 deletions(-)

diff --git a/Dashboard/Services/DatabaseService.QueryPerformance.cs b/Dashboard/Services/DatabaseService.QueryPerformance.cs
index 365b45ed..1754d30d 100644
--- a/Dashboard/Services/DatabaseService.QueryPerformance.cs
+++ b/Dashboard/Services/DatabaseService.QueryPerformance.cs
@@ -1104,7 +1104,6 @@ FROM collect.query_stats AS qs
                     OR (qs.last_execution_time >= @fromDate AND qs.last_execution_time <= @toDate)
                     OR (qs.creation_time <= @fromDate AND qs.last_execution_time >= @toDate)))
             )
-            AND CAST(DECOMPRESS(qs.query_text) AS nvarchar(max)) NOT LIKE N'WAITFOR%'
             GROUP BY
                 qs.database_name,
                 qs.query_hash,
@@ -1477,7 +1476,7 @@ USE HINT('ENABLE_PARALLEL_PLAN_PREFERENCE')
     ISNULL(SUM(qsd.avg_physical_io_reads * qsd.count_executions), 0) AS total_physical_reads,
     ISNULL(SUM(qsd.avg_logical_io_writes * qsd.count_executions), 0) AS total_writes
 FROM collect.query_store_data AS qsd
-WHERE CAST(DECOMPRESS(qsd.query_sql_text) AS nvarchar(max)) NOT LIKE N'WAITFOR%'
+WHERE 1 = 1
 {timeFilter}
 GROUP BY DATEADD(HOUR, DATEDIFF(HOUR, 0, qsd.collection_time), 0)
 ORDER BY bucket_hour;";
@@ -1580,7 +1579,6 @@ FROM collect.query_store_data AS qsd
                 OR (qsd.server_last_execution_time >= @fromDate AND qsd.server_last_execution_time <= @toDate)
                 OR (qsd.server_first_execution_time <= @fromDate AND qsd.server_last_execution_time >= @toDate)))
         )
-        AND CAST(DECOMPRESS(qsd.query_sql_text) AS nvarchar(max)) NOT LIKE N'WAITFOR%'
         GROUP BY
             qsd.database_name,
             qsd.query_id

From 160921f8ee395e75cf66f8bb217e5026bff87401 Mon Sep 17 00:00:00 2001
From: Erik Darling <2136037+erikdarlingdata@users.noreply.github.com>
Date: Thu, 16 Apr 2026 09:16:10 -0400
Subject: [PATCH 09/49] Refactor query/procedure/query store stats to phased
 DECOMPRESS approach
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

All three grid queries now use a 3-phase pattern:
1. Aggregate numerics into temp table (no DECOMPRESS)
2. Sum across lifetimes, rank TOP 500
3. OUTER APPLY to decompress text/plan for only the 500 winners

On a 742K-row query_stats table, this reduces DECOMPRESS calls from
742K to 500 — eliminating the 16+ minute query times reported in #835.

Matches the existing phased pattern used by the MCP query tools.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
---
 .../DatabaseService.QueryPerformance.cs       | 457 ++++++++++++------
 1 file changed, 309 insertions(+), 148 deletions(-)

diff --git a/Dashboard/Services/DatabaseService.QueryPerformance.cs b/Dashboard/Services/DatabaseService.QueryPerformance.cs
index 1754d30d..7f5f0e27 100644
--- a/Dashboard/Services/DatabaseService.QueryPerformance.cs
+++ b/Dashboard/Services/DatabaseService.QueryPerformance.cs
@@ -64,7 +64,7 @@ FROM report.expensive_queries_today
                             OR    (first_execution_time <= @from_date AND last_execution_time >= @to_date)
                             ORDER BY
                                 avg_worker_time_ms DESC
-                            OPTION(HASH GROUP);";
+                            OPTION(RECOMPILE, HASH GROUP);";
                     }
                     else
                     {
@@ -96,7 +96,7 @@ FROM report.expensive_queries_today
                             WHERE last_execution_time >= DATEADD(HOUR, @hours_back, SYSDATETIME())
                             ORDER BY
                                 avg_worker_time_ms DESC
-                            OPTION(HASH GROUP);";
+                            OPTION(RECOMPILE, HASH GROUP);";
                     }
 
                     using var command = new SqlCommand(query, connection);
@@ -190,7 +190,8 @@ FROM collect.blocking_BlockedProcessReport AS b
                             ORDER BY
                                 b.event_time DESC,
                                 CASE b.activity WHEN N'blocking' THEN 0 ELSE 1 END,
-                                LEN(b.blocking_tree) - LEN(REPLACE(b.blocking_tree, N'>', N''));";
+                                LEN(b.blocking_tree) - LEN(REPLACE(b.blocking_tree, N'>', N''))
+                            OPTION(RECOMPILE);";
                     }
                     else
                     {
@@ -234,7 +235,8 @@ FROM collect.blocking_BlockedProcessReport AS b
                             ORDER BY
                                 b.event_time DESC,
                                 CASE b.activity WHEN N'blocking' THEN 0 ELSE 1 END,
-                                LEN(b.blocking_tree) - LEN(REPLACE(b.blocking_tree, N'>', N''));";
+                                LEN(b.blocking_tree) - LEN(REPLACE(b.blocking_tree, N'>', N''))
+                            OPTION(RECOMPILE);";
                     }
         
                     using var command = new SqlCommand(query, connection);
@@ -345,7 +347,8 @@ FROM collect.deadlocks AS d
                             WHERE d.event_date >= @from_date
                             AND   d.event_date <= @to_date
                             ORDER BY
-                                d.event_date DESC;";
+                                d.event_date DESC
+                            OPTION(RECOMPILE);";
                     }
                     else
                     {
@@ -398,7 +401,8 @@ SELECT TOP (100)
                             FROM collect.deadlocks AS d
                             WHERE d.event_date >= DATEADD(HOUR, @hours_back, SYSDATETIME())
                             ORDER BY
-                                d.event_date DESC;";
+                                d.event_date DESC
+                            OPTION(RECOMPILE);";
                     }
         
                     using var command = new SqlCommand(query, connection);
@@ -1048,67 +1052,75 @@ public async Task<List<QueryStatsItem>> GetQueryStatsAsync(int hoursBack = 24, D
 
                     bool useCustomDates = fromDate.HasValue && toDate.HasValue;
 
-                    // Aggregate inline from collect.query_stats with time filter applied
-                    // BEFORE the GROUP BY so counts/averages reflect only the selected time range.
-                    // Uses a CTE to first get MAX per plan lifetime (creation_time), then SUM across
-                    // lifetimes. This handles plan eviction correctly — when a plan is evicted and
-                    // re-cached, the cumulative counter resets, so MAX alone undercounts.
+                    // Phased approach: aggregate numerics first (no DECOMPRESS), rank TOP 500,
+                    // then hydrate text/plan for only the winners. This avoids decompressing
+                    // query_text and query_plan_text for every row in the table.
                     string query = @"
         SET TRANSACTION ISOLATION LEVEL READ UNCOMMITTED;
 
-        WITH per_lifetime AS
-        (
-            SELECT
-                database_name = qs.database_name,
-                query_hash = qs.query_hash,
-                object_type = MAX(qs.object_type),
-                schema_name = MAX(qs.schema_name),
-                object_name = MAX(qs.object_name),
-                first_execution_time = MIN(qs.creation_time),
-                last_execution_time = MAX(qs.last_execution_time),
-                execution_count = MAX(qs.execution_count),
-                total_worker_time = MAX(qs.total_worker_time),
-                min_worker_time = MIN(qs.min_worker_time),
-                max_worker_time = MAX(qs.max_worker_time),
-                total_elapsed_time = MAX(qs.total_elapsed_time),
-                min_elapsed_time = MIN(qs.min_elapsed_time),
-                max_elapsed_time = MAX(qs.max_elapsed_time),
-                total_logical_reads = MAX(qs.total_logical_reads),
-                total_logical_writes = MAX(qs.total_logical_writes),
-                total_physical_reads = MAX(qs.total_physical_reads),
-                min_physical_reads = MIN(qs.min_physical_reads),
-                max_physical_reads = MAX(qs.max_physical_reads),
-                total_rows = MAX(qs.total_rows),
-                min_rows = MIN(qs.min_rows),
-                max_rows = MAX(qs.max_rows),
-                min_dop = MIN(qs.min_dop),
-                max_dop = MAX(qs.max_dop),
-                min_grant_kb = MIN(qs.min_grant_kb),
-                max_grant_kb = MAX(qs.max_grant_kb),
-                total_spills = MAX(qs.total_spills),
-                min_spills = MIN(qs.min_spills),
-                max_spills = MAX(qs.max_spills),
-                query_text = CAST(DECOMPRESS(MAX(qs.query_text)) AS nvarchar(max)),
-                query_plan_text = CAST(DECOMPRESS(MAX(qs.query_plan_text)) AS nvarchar(max)),
-                query_plan_hash = MAX(qs.query_plan_hash),
-                sql_handle = MAX(qs.sql_handle),
-                plan_handle = MAX(qs.plan_handle)
-            FROM collect.query_stats AS qs
-            WHERE (
-                (@fromSlicer = 1 AND qs.collection_time >= @fromDate AND qs.collection_time <= @toDate)
-                OR
-                (@fromSlicer = 0 AND @useCustomDates = 0 AND qs.last_execution_time >= DATEADD(HOUR, -@hoursBack, SYSDATETIME()))
-                OR
-                (@fromSlicer = 0 AND @useCustomDates = 1 AND
-                    ((qs.creation_time >= @fromDate AND qs.creation_time <= @toDate)
-                    OR (qs.last_execution_time >= @fromDate AND qs.last_execution_time <= @toDate)
-                    OR (qs.creation_time <= @fromDate AND qs.last_execution_time >= @toDate)))
-            )
-            GROUP BY
-                qs.database_name,
-                qs.query_hash,
-                qs.creation_time
+        /*Phase 1: aggregate per plan lifetime — numeric only, no DECOMPRESS*/
+        DROP TABLE IF EXISTS #per_lifetime;
+
+        SELECT
+            qs.database_name,
+            qs.query_hash,
+            qs.creation_time,
+            object_type = MAX(qs.object_type),
+            schema_name = MAX(qs.schema_name),
+            object_name = MAX(qs.object_name),
+            last_execution_time = MAX(qs.last_execution_time),
+            execution_count = MAX(qs.execution_count),
+            total_worker_time = MAX(qs.total_worker_time),
+            min_worker_time = MIN(qs.min_worker_time),
+            max_worker_time = MAX(qs.max_worker_time),
+            total_elapsed_time = MAX(qs.total_elapsed_time),
+            min_elapsed_time = MIN(qs.min_elapsed_time),
+            max_elapsed_time = MAX(qs.max_elapsed_time),
+            total_logical_reads = MAX(qs.total_logical_reads),
+            total_logical_writes = MAX(qs.total_logical_writes),
+            total_physical_reads = MAX(qs.total_physical_reads),
+            min_physical_reads = MIN(qs.min_physical_reads),
+            max_physical_reads = MAX(qs.max_physical_reads),
+            total_rows = MAX(qs.total_rows),
+            min_rows = MIN(qs.min_rows),
+            max_rows = MAX(qs.max_rows),
+            min_dop = MIN(qs.min_dop),
+            max_dop = MAX(qs.max_dop),
+            min_grant_kb = MIN(qs.min_grant_kb),
+            max_grant_kb = MAX(qs.max_grant_kb),
+            total_spills = MAX(qs.total_spills),
+            min_spills = MIN(qs.min_spills),
+            max_spills = MAX(qs.max_spills),
+            query_plan_hash = MAX(qs.query_plan_hash),
+            sql_handle = MAX(qs.sql_handle),
+            plan_handle = MAX(qs.plan_handle)
+        INTO #per_lifetime
+        FROM collect.query_stats AS qs
+        WHERE (
+            (@fromSlicer = 1 AND qs.collection_time >= @fromDate AND qs.collection_time <= @toDate)
+            OR
+            (@fromSlicer = 0 AND @useCustomDates = 0 AND qs.last_execution_time >= DATEADD(HOUR, -@hoursBack, SYSDATETIME()))
+            OR
+            (@fromSlicer = 0 AND @useCustomDates = 1 AND
+                ((qs.creation_time >= @fromDate AND qs.creation_time <= @toDate)
+                OR (qs.last_execution_time >= @fromDate AND qs.last_execution_time <= @toDate)
+                OR (qs.creation_time <= @fromDate AND qs.last_execution_time >= @toDate)))
         )
+        GROUP BY
+            qs.database_name,
+            qs.query_hash,
+            qs.creation_time
+        OPTION
+        (
+            RECOMPILE,
+            HASH GROUP,
+            HASH JOIN,
+            USE HINT('ENABLE_PARALLEL_PLAN_PREFERENCE')
+        );
+
+        /*Phase 2: sum across lifetimes, rank, take TOP 500*/
+        DROP TABLE IF EXISTS #top_ranked;
+
         SELECT TOP (500)
             database_name = pl.database_name,
             query_hash = CONVERT(nvarchar(20), pl.query_hash, 1),
@@ -1119,7 +1131,7 @@ CASE MAX(pl.object_type)
                     THEN N'Adhoc'
                     ELSE QUOTENAME(MAX(pl.schema_name)) + N'.' + QUOTENAME(MAX(pl.object_name))
                 END,
-            first_execution_time = MIN(pl.first_execution_time),
+            first_execution_time = MIN(pl.creation_time),
             last_execution_time = MAX(pl.last_execution_time),
             execution_count = SUM(pl.execution_count),
             total_worker_time = SUM(pl.total_worker_time),
@@ -1149,12 +1161,11 @@ ELSE QUOTENAME(MAX(pl.schema_name)) + N'.' + QUOTENAME(MAX(pl.object_name))
             total_spills = SUM(pl.total_spills),
             min_spills = MIN(pl.min_spills),
             max_spills = MAX(pl.max_spills),
-            query_text = CONVERT(nvarchar(max), MAX(pl.query_text)),
-            query_plan_xml = MAX(pl.query_plan_text),
             query_plan_hash = CONVERT(nvarchar(20), MAX(pl.query_plan_hash), 1),
             sql_handle = CONVERT(nvarchar(130), MAX(pl.sql_handle), 1),
             plan_handle = CONVERT(nvarchar(130), MAX(pl.plan_handle), 1)
-        FROM per_lifetime AS pl
+        INTO #top_ranked
+        FROM #per_lifetime AS pl
         GROUP BY
             pl.database_name,
             pl.query_hash
@@ -1162,10 +1173,73 @@ ORDER BY
             avg_worker_time_ms DESC
         OPTION
         (
-            HASH GROUP,
-            HASH JOIN,
-            USE HINT('ENABLE_PARALLEL_PLAN_PREFERENCE')
-        );";
+            RECOMPILE,
+            HASH GROUP
+        );
+
+        /*Phase 3: hydrate text and plan XML for the TOP 500 winners only*/
+        SELECT
+            tr.database_name,
+            tr.query_hash,
+            tr.object_type,
+            tr.object_name,
+            tr.first_execution_time,
+            tr.last_execution_time,
+            tr.execution_count,
+            tr.total_worker_time,
+            tr.avg_worker_time_ms,
+            tr.min_worker_time_ms,
+            tr.max_worker_time_ms,
+            tr.total_elapsed_time,
+            tr.avg_elapsed_time_ms,
+            tr.min_elapsed_time_ms,
+            tr.max_elapsed_time_ms,
+            tr.total_logical_reads,
+            tr.avg_logical_reads,
+            tr.total_logical_writes,
+            tr.avg_logical_writes,
+            tr.total_physical_reads,
+            tr.avg_physical_reads,
+            tr.min_physical_reads,
+            tr.max_physical_reads,
+            tr.total_rows,
+            tr.avg_rows,
+            tr.min_rows,
+            tr.max_rows,
+            tr.min_dop,
+            tr.max_dop,
+            tr.min_grant_kb,
+            tr.max_grant_kb,
+            tr.total_spills,
+            tr.min_spills,
+            tr.max_spills,
+            qt.query_text,
+            qp.query_plan_xml,
+            tr.query_plan_hash,
+            tr.sql_handle,
+            tr.plan_handle
+        FROM #top_ranked AS tr
+        OUTER APPLY
+        (
+            SELECT TOP (1)
+                query_text = CAST(DECOMPRESS(qs2.query_text) AS nvarchar(max))
+            FROM collect.query_stats AS qs2
+            WHERE qs2.query_hash = CONVERT(binary(8), tr.query_hash, 1)
+            AND   qs2.database_name = tr.database_name
+            ORDER BY qs2.collection_time DESC
+        ) AS qt
+        OUTER APPLY
+        (
+            SELECT TOP (1)
+                query_plan_xml = CAST(DECOMPRESS(qs3.query_plan_text) AS nvarchar(max))
+            FROM collect.query_stats AS qs3
+            WHERE qs3.query_hash = CONVERT(binary(8), tr.query_hash, 1)
+            AND   qs3.database_name = tr.database_name
+            AND   qs3.query_plan_text IS NOT NULL
+            ORDER BY qs3.collection_time DESC
+        ) AS qp
+        ORDER BY
+            tr.avg_worker_time_ms DESC;";
 
                     using var command = new SqlCommand(query, connection);
                     command.CommandTimeout = 120;
@@ -1286,64 +1360,72 @@ public async Task<List<ProcedureStatsItem>> GetProcedureStatsAsync(int hoursBack
 
                     bool useCustomDates = fromDate.HasValue && toDate.HasValue;
 
-                    // Aggregate inline from collect.procedure_stats with time filter applied
-                    // BEFORE the GROUP BY so counts/averages reflect only the selected time range.
-                    // Uses a CTE to first get MAX per plan lifetime (cached_time), then SUM across
-                    // lifetimes. This handles plan eviction correctly — when a plan is evicted and
-                    // re-cached, the cumulative counter resets, so MAX alone undercounts.
+                    // Phased approach: aggregate numerics first (no DECOMPRESS), rank TOP 500,
+                    // then hydrate plan XML for only the winners.
                     string query = @"
         SET TRANSACTION ISOLATION LEVEL READ UNCOMMITTED;
 
-        WITH per_lifetime AS
-        (
-            SELECT
-                database_name = ps.database_name,
-                schema_name = ps.schema_name,
-                object_name = ps.object_name,
-                object_id = MAX(ps.object_id),
-                object_type = MAX(ps.object_type),
-                type_desc = MAX(ps.type_desc),
-                first_cached_time = MIN(ps.cached_time),
-                last_execution_time = MAX(ps.last_execution_time),
-                execution_count = MAX(ps.execution_count),
-                total_worker_time = MAX(ps.total_worker_time),
-                min_worker_time = MIN(ps.min_worker_time),
-                max_worker_time = MAX(ps.max_worker_time),
-                total_elapsed_time = MAX(ps.total_elapsed_time),
-                min_elapsed_time = MIN(ps.min_elapsed_time),
-                max_elapsed_time = MAX(ps.max_elapsed_time),
-                total_logical_reads = MAX(ps.total_logical_reads),
-                min_logical_reads = MIN(ps.min_logical_reads),
-                max_logical_reads = MAX(ps.max_logical_reads),
-                total_logical_writes = MAX(ps.total_logical_writes),
-                min_logical_writes = MIN(ps.min_logical_writes),
-                max_logical_writes = MAX(ps.max_logical_writes),
-                total_physical_reads = MAX(ps.total_physical_reads),
-                min_physical_reads = MIN(ps.min_physical_reads),
-                max_physical_reads = MAX(ps.max_physical_reads),
-                total_spills = MAX(ps.total_spills),
-                min_spills = MIN(ps.min_spills),
-                max_spills = MAX(ps.max_spills),
-                query_plan_text = CAST(DECOMPRESS(MAX(ps.query_plan_text)) AS nvarchar(max)),
-                sql_handle = MAX(ps.sql_handle),
-                plan_handle = MAX(ps.plan_handle)
-            FROM collect.procedure_stats AS ps
-            WHERE (
-                (@fromSlicer = 1 AND ps.collection_time >= @fromDate AND ps.collection_time <= @toDate)
-                OR
-                (@fromSlicer = 0 AND @useCustomDates = 0 AND ps.last_execution_time >= DATEADD(HOUR, -@hoursBack, SYSDATETIME()))
-                OR
-                (@fromSlicer = 0 AND @useCustomDates = 1 AND
-                    ((ps.cached_time >= @fromDate AND ps.cached_time <= @toDate)
-                    OR (ps.last_execution_time >= @fromDate AND ps.last_execution_time <= @toDate)
-                    OR (ps.cached_time <= @fromDate AND ps.last_execution_time >= @toDate)))
-            )
-            GROUP BY
-                ps.database_name,
-                ps.schema_name,
-                ps.object_name,
-                ps.cached_time
+        /*Phase 1: aggregate per plan lifetime — numeric only, no DECOMPRESS*/
+        DROP TABLE IF EXISTS #proc_per_lifetime;
+
+        SELECT
+            ps.database_name,
+            ps.schema_name,
+            ps.object_name,
+            ps.cached_time,
+            object_id = MAX(ps.object_id),
+            object_type = MAX(ps.object_type),
+            type_desc = MAX(ps.type_desc),
+            last_execution_time = MAX(ps.last_execution_time),
+            execution_count = MAX(ps.execution_count),
+            total_worker_time = MAX(ps.total_worker_time),
+            min_worker_time = MIN(ps.min_worker_time),
+            max_worker_time = MAX(ps.max_worker_time),
+            total_elapsed_time = MAX(ps.total_elapsed_time),
+            min_elapsed_time = MIN(ps.min_elapsed_time),
+            max_elapsed_time = MAX(ps.max_elapsed_time),
+            total_logical_reads = MAX(ps.total_logical_reads),
+            min_logical_reads = MIN(ps.min_logical_reads),
+            max_logical_reads = MAX(ps.max_logical_reads),
+            total_logical_writes = MAX(ps.total_logical_writes),
+            min_logical_writes = MIN(ps.min_logical_writes),
+            max_logical_writes = MAX(ps.max_logical_writes),
+            total_physical_reads = MAX(ps.total_physical_reads),
+            min_physical_reads = MIN(ps.min_physical_reads),
+            max_physical_reads = MAX(ps.max_physical_reads),
+            total_spills = MAX(ps.total_spills),
+            min_spills = MIN(ps.min_spills),
+            max_spills = MAX(ps.max_spills),
+            sql_handle = MAX(ps.sql_handle),
+            plan_handle = MAX(ps.plan_handle)
+        INTO #proc_per_lifetime
+        FROM collect.procedure_stats AS ps
+        WHERE (
+            (@fromSlicer = 1 AND ps.collection_time >= @fromDate AND ps.collection_time <= @toDate)
+            OR
+            (@fromSlicer = 0 AND @useCustomDates = 0 AND ps.last_execution_time >= DATEADD(HOUR, -@hoursBack, SYSDATETIME()))
+            OR
+            (@fromSlicer = 0 AND @useCustomDates = 1 AND
+                ((ps.cached_time >= @fromDate AND ps.cached_time <= @toDate)
+                OR (ps.last_execution_time >= @fromDate AND ps.last_execution_time <= @toDate)
+                OR (ps.cached_time <= @fromDate AND ps.last_execution_time >= @toDate)))
         )
+        GROUP BY
+            ps.database_name,
+            ps.schema_name,
+            ps.object_name,
+            ps.cached_time
+        OPTION
+        (
+            RECOMPILE,
+            HASH GROUP,
+            HASH JOIN,
+            USE HINT('ENABLE_PARALLEL_PLAN_PREFERENCE')
+        );
+
+        /*Phase 2: sum across lifetimes, rank, take TOP 500*/
+        DROP TABLE IF EXISTS #proc_top_ranked;
+
         SELECT TOP (500)
             database_name = pl.database_name,
             object_id = MAX(pl.object_id),
@@ -1352,7 +1434,7 @@ SELECT TOP (500)
             procedure_name = pl.object_name,
             object_type = MAX(pl.object_type),
             type_desc = MAX(pl.type_desc),
-            first_cached_time = MIN(pl.first_cached_time),
+            first_cached_time = MIN(pl.cached_time),
             last_execution_time = MAX(pl.last_execution_time),
             execution_count = SUM(pl.execution_count),
             total_worker_time = SUM(pl.total_worker_time),
@@ -1379,10 +1461,10 @@ SELECT TOP (500)
             avg_spills = SUM(pl.total_spills) / NULLIF(SUM(pl.execution_count), 0),
             min_spills = MIN(pl.min_spills),
             max_spills = MAX(pl.max_spills),
-            query_plan_xml = MAX(pl.query_plan_text),
             sql_handle = CONVERT(nvarchar(130), MAX(pl.sql_handle), 1),
             plan_handle = CONVERT(nvarchar(130), MAX(pl.plan_handle), 1)
-        FROM per_lifetime AS pl
+        INTO #proc_top_ranked
+        FROM #proc_per_lifetime AS pl
         GROUP BY
             pl.database_name,
             pl.schema_name,
@@ -1391,10 +1473,63 @@ ORDER BY
             avg_worker_time_ms DESC
         OPTION
         (
-            HASH GROUP,
-            HASH JOIN,
-            USE HINT('ENABLE_PARALLEL_PLAN_PREFERENCE')
-        );";
+            RECOMPILE,
+            HASH GROUP
+        );
+
+        /*Phase 3: hydrate plan XML for the TOP 500 winners only*/
+        SELECT
+            tr.database_name,
+            tr.object_id,
+            tr.object_name,
+            tr.schema_name,
+            tr.procedure_name,
+            tr.object_type,
+            tr.type_desc,
+            tr.first_cached_time,
+            tr.last_execution_time,
+            tr.execution_count,
+            tr.total_worker_time,
+            tr.avg_worker_time_ms,
+            tr.min_worker_time_ms,
+            tr.max_worker_time_ms,
+            tr.total_elapsed_time,
+            tr.avg_elapsed_time_ms,
+            tr.min_elapsed_time_ms,
+            tr.max_elapsed_time_ms,
+            tr.total_logical_reads,
+            tr.avg_logical_reads,
+            tr.min_logical_reads,
+            tr.max_logical_reads,
+            tr.total_logical_writes,
+            tr.avg_logical_writes,
+            tr.min_logical_writes,
+            tr.max_logical_writes,
+            tr.total_physical_reads,
+            tr.avg_physical_reads,
+            tr.min_physical_reads,
+            tr.max_physical_reads,
+            tr.total_spills,
+            tr.avg_spills,
+            tr.min_spills,
+            tr.max_spills,
+            qp.query_plan_xml,
+            tr.sql_handle,
+            tr.plan_handle
+        FROM #proc_top_ranked AS tr
+        OUTER APPLY
+        (
+            SELECT TOP (1)
+                query_plan_xml = CAST(DECOMPRESS(ps2.query_plan_text) AS nvarchar(max))
+            FROM collect.procedure_stats AS ps2
+            WHERE ps2.database_name = tr.database_name
+            AND   ps2.schema_name = tr.schema_name
+            AND   ps2.object_name = tr.procedure_name
+            AND   ps2.query_plan_text IS NOT NULL
+            ORDER BY ps2.collection_time DESC
+        ) AS qp
+        ORDER BY
+            tr.avg_worker_time_ms DESC;";
 
                     using var command = new SqlCommand(query, connection);
                     command.CommandTimeout = 120;
@@ -1513,12 +1648,15 @@ public async Task<List<QueryStoreItem>> GetQueryStoreDataAsync(int hoursBack = 2
 
                     bool useCustomDates = fromDate.HasValue && toDate.HasValue;
 
-                    // Aggregate inline from collect.query_store_data with time filter applied
-                    // BEFORE the GROUP BY so counts/averages reflect only the selected time range.
-                    // Note: query_plan_xml is NOT fetched here for performance - use GetQueryStorePlanXmlAsync on demand
+                    // Phased approach: aggregate numerics first (no DECOMPRESS), rank TOP 500,
+                    // then hydrate query text for only the winners.
+                    // Note: query_plan_xml is NOT fetched here — use GetQueryStorePlanXmlAsync on demand.
                     string query = @"
         SET TRANSACTION ISOLATION LEVEL READ UNCOMMITTED;
 
+        /*Phase 1: aggregate numerics, rank TOP 500 — no DECOMPRESS*/
+        DROP TABLE IF EXISTS #qs_top_ranked;
+
         SELECT TOP (500)
             database_name = qsd.database_name,
             query_id = qsd.query_id,
@@ -1557,7 +1695,6 @@ SELECT TOP (500)
             plan_type = MAX(qsd.plan_type),
             is_forced_plan = MAX(CONVERT(tinyint, qsd.is_forced_plan)),
             compatibility_level = MAX(qsd.compatibility_level),
-            query_sql_text = CAST(DECOMPRESS(MAX(qsd.query_sql_text)) AS nvarchar(max)),
             query_plan_hash = CONVERT(nvarchar(20), MAX(qsd.query_plan_hash), 1),
             force_failure_count = SUM(qsd.force_failure_count),
             last_force_failure_reason_desc = MAX(qsd.last_force_failure_reason_desc),
@@ -1568,6 +1705,7 @@ SELECT TOP (500)
             max_num_physical_io_reads = MAX(qsd.max_num_physical_io_reads),
             min_log_bytes_used = MIN(qsd.min_log_bytes_used),
             max_log_bytes_used = MAX(qsd.max_log_bytes_used)
+        INTO #qs_top_ranked
         FROM collect.query_store_data AS qsd
         WHERE (
             (@fromSlicer = 1 AND qsd.collection_time >= @fromDate AND qsd.collection_time <= @toDate)
@@ -1586,10 +1724,28 @@ ORDER BY
             avg_cpu_time_ms DESC
         OPTION
         (
+            RECOMPILE,
             HASH GROUP,
             HASH JOIN,
             USE HINT('ENABLE_PARALLEL_PLAN_PREFERENCE')
-        );";
+        );
+
+        /*Phase 2: hydrate query text for the TOP 500 winners only*/
+        SELECT
+            tr.*,
+            qt.query_sql_text
+        FROM #qs_top_ranked AS tr
+        OUTER APPLY
+        (
+            SELECT TOP (1)
+                query_sql_text = CAST(DECOMPRESS(qsd2.query_sql_text) AS nvarchar(max))
+            FROM collect.query_store_data AS qsd2
+            WHERE qsd2.database_name = tr.database_name
+            AND   qsd2.query_id = tr.query_id
+            ORDER BY qsd2.collection_time DESC
+        ) AS qt
+        ORDER BY
+            tr.avg_cpu_time_ms DESC;";
 
                     using var command = new SqlCommand(query, connection);
                     command.CommandTimeout = 120;
@@ -1642,17 +1798,17 @@ USE HINT('ENABLE_PARALLEL_PLAN_PREFERENCE')
                             PlanType = reader.IsDBNull(34) ? null : reader.GetString(34),
                             IsForcedPlan = !reader.IsDBNull(35) && reader.GetByte(35) == 1,
                             CompatibilityLevel = reader.IsDBNull(36) ? null : reader.GetInt16(36),
-                            QuerySqlText = reader.IsDBNull(37) ? null : reader.GetString(37),
-                            QueryPlanHash = reader.IsDBNull(38) ? null : reader.GetString(38),
-                            ForceFailureCount = reader.IsDBNull(39) ? null : reader.GetInt64(39),
-                            LastForceFailureReasonDesc = reader.IsDBNull(40) ? null : reader.GetString(40),
-                            PlanForcingType = reader.IsDBNull(41) ? null : reader.GetString(41),
-                            MinClrTimeMs = reader.IsDBNull(42) ? null : Convert.ToDouble(reader.GetValue(42), CultureInfo.InvariantCulture),
-                            MaxClrTimeMs = reader.IsDBNull(43) ? null : Convert.ToDouble(reader.GetValue(43), CultureInfo.InvariantCulture),
-                            MinNumPhysicalIoReads = reader.IsDBNull(44) ? null : reader.GetInt64(44),
-                            MaxNumPhysicalIoReads = reader.IsDBNull(45) ? null : reader.GetInt64(45),
-                            MinLogBytesUsed = reader.IsDBNull(46) ? null : reader.GetInt64(46),
-                            MaxLogBytesUsed = reader.IsDBNull(47) ? null : reader.GetInt64(47)
+                            QueryPlanHash = reader.IsDBNull(37) ? null : reader.GetString(37),
+                            ForceFailureCount = reader.IsDBNull(38) ? null : reader.GetInt64(38),
+                            LastForceFailureReasonDesc = reader.IsDBNull(39) ? null : reader.GetString(39),
+                            PlanForcingType = reader.IsDBNull(40) ? null : reader.GetString(40),
+                            MinClrTimeMs = reader.IsDBNull(41) ? null : Convert.ToDouble(reader.GetValue(41), CultureInfo.InvariantCulture),
+                            MaxClrTimeMs = reader.IsDBNull(42) ? null : Convert.ToDouble(reader.GetValue(42), CultureInfo.InvariantCulture),
+                            MinNumPhysicalIoReads = reader.IsDBNull(43) ? null : reader.GetInt64(43),
+                            MaxNumPhysicalIoReads = reader.IsDBNull(44) ? null : reader.GetInt64(44),
+                            MinLogBytesUsed = reader.IsDBNull(45) ? null : reader.GetInt64(45),
+                            MaxLogBytesUsed = reader.IsDBNull(46) ? null : reader.GetInt64(46),
+                            QuerySqlText = reader.IsDBNull(47) ? null : reader.GetString(47)
                             // QueryPlanXml is fetched on-demand via GetQueryStorePlanXmlAsync
                         });
                     }
@@ -4213,6 +4369,7 @@ GROUP BY
     qs.creation_time
 OPTION
 (
+    RECOMPILE,
     HASH GROUP,
     USE HINT('ENABLE_PARALLEL_PLAN_PREFERENCE')
 );
@@ -4274,6 +4431,7 @@ ORDER BY
     avg_worker_time_ms DESC
 OPTION
 (
+    RECOMPILE,
     HASH GROUP
 );
 
@@ -4450,6 +4608,7 @@ GROUP BY
     ps.cached_time
 OPTION
 (
+    RECOMPILE,
     HASH GROUP,
     USE HINT('ENABLE_PARALLEL_PLAN_PREFERENCE')
 );
@@ -4501,6 +4660,7 @@ ORDER BY
     avg_worker_time_ms DESC
 OPTION
 (
+    RECOMPILE,
     HASH GROUP
 );";
 
@@ -4638,6 +4798,7 @@ ORDER BY
     avg_cpu_time_ms DESC
 OPTION
 (
+    RECOMPILE,
     HASH GROUP,
     HASH JOIN,
     USE HINT('ENABLE_PARALLEL_PLAN_PREFERENCE')

From 4235f50fc6549753f9860ce274cd0d83f62234e8 Mon Sep 17 00:00:00 2001
From: Erik Darling <2136037+erikdarlingdata@users.noreply.github.com>
Date: Thu, 16 Apr 2026 09:45:10 -0400
Subject: [PATCH 10/49] Fix FinOps TDE recommendation on SQL Server 2019+
 (#854)

TDE moved to Standard Edition in SQL 2019, so dm_db_persisted_sku_features
no longer reports it as Enterprise-only. Add version check to give
version-appropriate licensing guidance instead of falsely claiming no
databases use TDE.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
---
 Dashboard/Services/DatabaseService.FinOps.cs | 115 +++++++++------
 Lite/Services/LocalDataService.FinOps.cs     | 145 ++++++++++++-------
 2 files changed, 163 insertions(+), 97 deletions(-)

diff --git a/Dashboard/Services/DatabaseService.FinOps.cs b/Dashboard/Services/DatabaseService.FinOps.cs
index 752e02e0..f593d22e 100644
--- a/Dashboard/Services/DatabaseService.FinOps.cs
+++ b/Dashboard/Services/DatabaseService.FinOps.cs
@@ -1852,19 +1852,51 @@ public async Task<List<FinOpsRecommendation>> GetFinOpsRecommendationsAsync(deci
             try
             {
                 using var editionCmd = new SqlCommand(
-                    "SELECT CAST(SERVERPROPERTY('Edition') AS NVARCHAR(128))", connection);
+                    "SELECT CAST(SERVERPROPERTY('Edition') AS NVARCHAR(128)), " +
+                    "CAST(SERVERPROPERTY('ProductMajorVersion') AS INT)", connection);
                 editionCmd.CommandTimeout = 30;
-                var edition = (string?)await editionCmd.ExecuteScalarAsync() ?? "";
+                using var editionReader = await editionCmd.ExecuteReaderAsync();
+                string edition = "";
+                int majorVersion = 0;
+                if (await editionReader.ReadAsync())
+                {
+                    edition = editionReader.IsDBNull(0) ? "" : editionReader.GetString(0);
+                    majorVersion = editionReader.IsDBNull(1) ? 0 : editionReader.GetInt32(1);
+                }
 
                 if (edition.Contains("Enterprise", StringComparison.OrdinalIgnoreCase))
                 {
-                    /*
-                    sys.dm_db_persisted_sku_features is database-scoped on all versions.
-                    Query across all online user databases for TDE usage — the only feature
-                    still Enterprise-only since 2016 SP1 (Compression, Partitioning,
-                    ColumnStoreIndex are all available in Standard).
-                    */
-                    using var featCmd = new SqlCommand(@"
+                    // SQL Server 2019 (major version 15) moved TDE to Standard Edition.
+                    // On 2019+, dm_db_persisted_sku_features won't report TDE since it's
+                    // no longer Enterprise-restricted — so we skip the TDE-specific check
+                    // and give version-appropriate guidance instead.
+                    if (majorVersion >= 15)
+                    {
+                        // 2019+: Most features that were Enterprise-only moved to Standard
+                        // in 2016 SP1, and TDE moved in 2019. Very few Enterprise-only
+                        // features remain (e.g., certain HA configurations).
+                        recommendations.Add(new FinOpsRecommendation
+                        {
+                            Category = "Licensing",
+                            Severity = "High",
+                            Confidence = "Medium",
+                            Finding = "Enterprise Edition may not be required",
+                            Detail = "Starting with SQL Server 2019, most previously Enterprise-only features " +
+                                     "(including TDE, compression, partitioning, and columnstore) are available " +
+                                     "in Standard Edition. Review whether remaining Enterprise-only features " +
+                                     "(such as Always On availability groups with multiple secondaries) are in use " +
+                                     "before considering a downgrade to Standard Edition.",
+                            EstMonthlySavings = monthlyCost > 0 ? monthlyCost * 0.40m : null
+                        });
+                    }
+                    else
+                    {
+                        /*
+                        Pre-2019: TDE is the only commonly-used feature still restricted
+                        to Enterprise Edition since 2016 SP1. Use dm_db_persisted_sku_features
+                        to detect it — the DMV correctly reports TDE on these versions.
+                        */
+                        using var featCmd = new SqlCommand(@"
 DECLARE
     @sql nvarchar(max) = N'';
 
@@ -1883,42 +1915,42 @@ IF @sql <> N''
     SET @sql = LEFT(@sql, LEN(@sql) - 10);
     EXEC sys.sp_executesql @sql;
 END;", connection);
-                    featCmd.CommandTimeout = 30;
+                        featCmd.CommandTimeout = 30;
 
-                    var tdeDbNames = new List<string>();
-                    using var featReader = await featCmd.ExecuteReaderAsync();
-                    while (await featReader.ReadAsync())
-                    {
-                        if (!featReader.IsDBNull(0))
-                            tdeDbNames.Add(featReader.GetString(0));
-                    }
+                        var tdeDbNames = new List<string>();
+                        using var featReader = await featCmd.ExecuteReaderAsync();
+                        while (await featReader.ReadAsync())
+                        {
+                            if (!featReader.IsDBNull(0))
+                                tdeDbNames.Add(featReader.GetString(0));
+                        }
 
-                    if (tdeDbNames.Count == 0)
-                    {
-                        recommendations.Add(new FinOpsRecommendation
+                        if (tdeDbNames.Count == 0)
                         {
-                            Category = "Licensing",
-                            Severity = "High",
-                            Confidence = "High",
-                            Finding = "Enterprise Edition with no Enterprise-only features detected",
-                            Detail = "No databases use Transparent Data Encryption (TDE), the only feature " +
-                                     "still restricted to Enterprise Edition since SQL Server 2016 SP1. " +
-                                     "Review whether Standard Edition would meet workload requirements for potential license savings.",
-                            EstMonthlySavings = monthlyCost > 0 ? monthlyCost * 0.40m : null
-                        });
-                    }
-                    else
-                    {
-                        recommendations.Add(new FinOpsRecommendation
+                            recommendations.Add(new FinOpsRecommendation
+                            {
+                                Category = "Licensing",
+                                Severity = "High",
+                                Confidence = "High",
+                                Finding = "Enterprise Edition with no Enterprise-only features detected",
+                                Detail = "No databases use Transparent Data Encryption (TDE), the only feature " +
+                                         "still restricted to Enterprise Edition since SQL Server 2016 SP1. " +
+                                         "Review whether Standard Edition would meet workload requirements for potential license savings.",
+                                EstMonthlySavings = monthlyCost > 0 ? monthlyCost * 0.40m : null
+                            });
+                        }
+                        else
                         {
-                            Category = "Licensing",
-                            Severity = "Low",
-                            Confidence = "High",
-                            Finding = "TDE in use — Enterprise Edition downgrade blocker",
-                            Detail = $"The following databases use Transparent Data Encryption: {string.Join(", ", tdeDbNames.Take(20))}" +
-                                     (tdeDbNames.Count > 20 ? $" and {tdeDbNames.Count - 20} more" : "") +
-                                     ". TDE must be removed before downgrading to Standard Edition."
-                        });
+                            recommendations.Add(new FinOpsRecommendation
+                            {
+                                Category = "Licensing",
+                                Severity = "Low",
+                                Confidence = "High",
+                                Finding = "TDE in use — Enterprise Edition downgrade blocker",
+                                Detail = $"The following databases use Transparent Data Encryption: {string.Join(", ", tdeDbNames.Take(20))}" +
+                                         (tdeDbNames.Count > 20 ? $" and {tdeDbNames.Count - 20} more" : "") +
+                                         ". TDE must be removed before downgrading to Standard Edition."
+                            });
 
                         // Check 10: License cost impact estimate (only when features ARE in use)
                         using var cpuInfoCmd = new SqlCommand(
@@ -1941,6 +1973,7 @@ IF @sql <> N''
                             });
                         }
                     }
+                    }
                 }
             }
             catch (Exception ex)
diff --git a/Lite/Services/LocalDataService.FinOps.cs b/Lite/Services/LocalDataService.FinOps.cs
index c2290f06..163cdf86 100644
--- a/Lite/Services/LocalDataService.FinOps.cs
+++ b/Lite/Services/LocalDataService.FinOps.cs
@@ -1578,19 +1578,51 @@ public async Task<List<RecommendationRow>> GetRecommendationsAsync(int serverId,
             await sqlConn.OpenAsync();
 
             using var editionCmd = new SqlCommand(
-                "SELECT CAST(SERVERPROPERTY('Edition') AS NVARCHAR(128))", sqlConn);
+                "SELECT CAST(SERVERPROPERTY('Edition') AS NVARCHAR(128)), " +
+                "CAST(SERVERPROPERTY('ProductMajorVersion') AS INT)", sqlConn);
             editionCmd.CommandTimeout = 30;
-            var edition = (string?)await editionCmd.ExecuteScalarAsync() ?? "";
+            using var editionReader = await editionCmd.ExecuteReaderAsync();
+            string edition = "";
+            int majorVersion = 0;
+            if (await editionReader.ReadAsync())
+            {
+                edition = editionReader.IsDBNull(0) ? "" : editionReader.GetString(0);
+                majorVersion = editionReader.IsDBNull(1) ? 0 : editionReader.GetInt32(1);
+            }
 
             if (edition.Contains("Enterprise", StringComparison.OrdinalIgnoreCase))
             {
-                /*
-                sys.dm_db_persisted_sku_features is database-scoped on all versions.
-                Query across all online user databases for TDE usage — the only feature
-                still Enterprise-only since 2016 SP1 (Compression, Partitioning,
-                ColumnStoreIndex are all available in Standard).
-                */
-                using var featCmd = new SqlCommand(@"
+                // SQL Server 2019 (major version 15) moved TDE to Standard Edition.
+                // On 2019+, dm_db_persisted_sku_features won't report TDE since it's
+                // no longer Enterprise-restricted — so we skip the TDE-specific check
+                // and give version-appropriate guidance instead.
+                if (majorVersion >= 15)
+                {
+                    // 2019+: Most features that were Enterprise-only moved to Standard
+                    // in 2016 SP1, and TDE moved in 2019. Very few Enterprise-only
+                    // features remain (e.g., certain HA configurations).
+                    recommendations.Add(new RecommendationRow
+                    {
+                        Category = "Licensing",
+                        Severity = "High",
+                        Confidence = "Medium",
+                        Finding = "Enterprise Edition may not be required",
+                        Detail = "Starting with SQL Server 2019, most previously Enterprise-only features " +
+                                 "(including TDE, compression, partitioning, and columnstore) are available " +
+                                 "in Standard Edition. Review whether remaining Enterprise-only features " +
+                                 "(such as Always On availability groups with multiple secondaries) are in use " +
+                                 "before considering a downgrade to Standard Edition.",
+                        EstMonthlySavings = monthlyCost > 0 ? monthlyCost * 0.40m : null
+                    });
+                }
+                else
+                {
+                    /*
+                    Pre-2019: TDE is the only commonly-used feature still restricted
+                    to Enterprise Edition since 2016 SP1. Use dm_db_persisted_sku_features
+                    to detect it — the DMV correctly reports TDE on these versions.
+                    */
+                    using var featCmd = new SqlCommand(@"
 DECLARE
     @sql nvarchar(max) = N'';
 
@@ -1609,62 +1641,63 @@ IF @sql <> N''
     SET @sql = LEFT(@sql, LEN(@sql) - 10);
     EXEC sys.sp_executesql @sql;
 END;", sqlConn);
-                featCmd.CommandTimeout = 30;
+                    featCmd.CommandTimeout = 30;
 
-                var tdeDbNames = new List<string>();
-                using var featReader = await featCmd.ExecuteReaderAsync();
-                while (await featReader.ReadAsync())
-                {
-                    if (!featReader.IsDBNull(0))
-                        tdeDbNames.Add(featReader.GetString(0));
-                }
-
-                if (tdeDbNames.Count == 0)
-                {
-                    recommendations.Add(new RecommendationRow
-                    {
-                        Category = "Licensing",
-                        Severity = "High",
-                        Confidence = "High",
-                        Finding = "Enterprise Edition with no Enterprise-only features detected",
-                        Detail = "No databases use Transparent Data Encryption (TDE), the only feature " +
-                                 "still restricted to Enterprise Edition since SQL Server 2016 SP1. " +
-                                 "Review whether Standard Edition would meet workload requirements for potential license savings.",
-                        EstMonthlySavings = monthlyCost > 0 ? monthlyCost * 0.40m : null
-                    });
-                }
-                else
-                {
-                    recommendations.Add(new RecommendationRow
+                    var tdeDbNames = new List<string>();
+                    using var featReader = await featCmd.ExecuteReaderAsync();
+                    while (await featReader.ReadAsync())
                     {
-                        Category = "Licensing",
-                        Severity = "Low",
-                        Confidence = "High",
-                        Finding = "TDE in use — Enterprise Edition downgrade blocker",
-                        Detail = $"The following databases use Transparent Data Encryption: {string.Join(", ", tdeDbNames.Take(20))}" +
-                                 (tdeDbNames.Count > 20 ? $" and {tdeDbNames.Count - 20} more" : "") +
-                                 ". TDE must be removed before downgrading to Standard Edition."
-                    });
+                        if (!featReader.IsDBNull(0))
+                            tdeDbNames.Add(featReader.GetString(0));
+                    }
 
-                    // Check 10: License cost impact estimate (only when features ARE in use)
-                    using var cpuInfoCmd = new SqlCommand(
-                        "SELECT cpu_count FROM sys.dm_os_sys_info", sqlConn);
-                    cpuInfoCmd.CommandTimeout = 30;
-                    var cpuCountObj = await cpuInfoCmd.ExecuteScalarAsync();
-                    var coreLicenseCount = cpuCountObj != null ? Convert.ToInt32(cpuCountObj) : 0;
-                    if (coreLicenseCount > 0)
+                    if (tdeDbNames.Count == 0)
+                    {
+                        recommendations.Add(new RecommendationRow
+                        {
+                            Category = "Licensing",
+                            Severity = "High",
+                            Confidence = "High",
+                            Finding = "Enterprise Edition with no Enterprise-only features detected",
+                            Detail = "No databases use Transparent Data Encryption (TDE), the only feature " +
+                                     "still restricted to Enterprise Edition since SQL Server 2016 SP1. " +
+                                     "Review whether Standard Edition would meet workload requirements for potential license savings.",
+                            EstMonthlySavings = monthlyCost > 0 ? monthlyCost * 0.40m : null
+                        });
+                    }
+                    else
                     {
-                        var monthlySavings = coreLicenseCount * 5000m / 12m;
                         recommendations.Add(new RecommendationRow
                         {
                             Category = "Licensing",
                             Severity = "Low",
-                            Confidence = "Low",
-                            Finding = $"Enterprise to Standard would save ~${monthlySavings:N0}/mo at list pricing ({coreLicenseCount} cores)",
-                            Detail = "Based on list pricing differential of ~$5,000/core/year between Enterprise and Standard. " +
-                                     "Actual savings depend on your licensing agreement. See Enterprise feature audit for downgrade blockers.",
-                            EstMonthlySavings = monthlySavings
+                            Confidence = "High",
+                            Finding = "TDE in use — Enterprise Edition downgrade blocker",
+                            Detail = $"The following databases use Transparent Data Encryption: {string.Join(", ", tdeDbNames.Take(20))}" +
+                                     (tdeDbNames.Count > 20 ? $" and {tdeDbNames.Count - 20} more" : "") +
+                                     ". TDE must be removed before downgrading to Standard Edition."
                         });
+
+                        // Check 10: License cost impact estimate (only when features ARE in use)
+                        using var cpuInfoCmd = new SqlCommand(
+                            "SELECT cpu_count FROM sys.dm_os_sys_info", sqlConn);
+                        cpuInfoCmd.CommandTimeout = 30;
+                        var cpuCountObj = await cpuInfoCmd.ExecuteScalarAsync();
+                        var coreLicenseCount = cpuCountObj != null ? Convert.ToInt32(cpuCountObj) : 0;
+                        if (coreLicenseCount > 0)
+                        {
+                            var monthlySavings = coreLicenseCount * 5000m / 12m;
+                            recommendations.Add(new RecommendationRow
+                            {
+                                Category = "Licensing",
+                                Severity = "Low",
+                                Confidence = "Low",
+                                Finding = $"Enterprise to Standard would save ~${monthlySavings:N0}/mo at list pricing ({coreLicenseCount} cores)",
+                                Detail = "Based on list pricing differential of ~$5,000/core/year between Enterprise and Standard. " +
+                                         "Actual savings depend on your licensing agreement. See Enterprise feature audit for downgrade blockers.",
+                                EstMonthlySavings = monthlySavings
+                            });
+                        }
                     }
                 }
             }

From e668b7627c2ce1843e4a4371b92fbb2f85a95098 Mon Sep 17 00:00:00 2001
From: Erik Darling <2136037+erikdarlingdata@users.noreply.github.com>
Date: Thu, 16 Apr 2026 14:06:13 -0400
Subject: [PATCH 11/49] Sync PlanAnalyzer and BenefitScorer from
 PerformanceStudio (Apr 9-16)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Port PS PRs #216, #217, #219, #224, #229, #230, #231 to PM.

PlanAnalyzer changes:
- Rule 5: Suppress for Key Lookups (point lookups mislead per-execution estimates)
- Rule 8: Enhanced parallel skew with batch mode sort detection and practical context
- Rule 9: Large memory grant shows top 3 consumers sorted by row count
- Rule 10: Key lookup overhaul — show output columns, check predicate filtering, softer advice
- Rules 11/12/29: Suppress on 0-execution nodes (operator never ran)
- Rule 11: I/O wait severity elevation when scan hits disk
- Rule 24: FormatNodeRef helper includes object name for data access operators
- Rule 26: Suppress when row goal prediction was correct, specific cause detection
- Wait stats: DescribeWaitType with full wait type coverage, multi-wait summary
- New helpers: GetWaitLabel, HasSignificantIoWaits, IdentifyRowGoalCause, FormatNodeRef
- GetOperatorOwnElapsedMs changed to internal for BenefitScorer access

BenefitScorer (new file):
- Stage 1: MaxBenefitPercent for operator-level rules (filter, spill, lookup, etc.)
- Stage 2: Wait stats benefit scoring with parallel allocation (Joe's formula)

PlanModels additions:
- MaxBenefitPercent and ActionableFix on PlanWarning
- WaitBenefit class and WaitBenefits list on PlanStatement

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
---
 Dashboard/Models/PlanModels.cs      |  19 +
 Dashboard/Services/BenefitScorer.cs | 653 ++++++++++++++++++++++++++++
 Dashboard/Services/PlanAnalyzer.cs  | 315 ++++++++++++--
 Lite/Models/PlanModels.cs           |  19 +
 Lite/Services/BenefitScorer.cs      | 653 ++++++++++++++++++++++++++++
 Lite/Services/PlanAnalyzer.cs       | 318 ++++++++++++--
 6 files changed, 1900 insertions(+), 77 deletions(-)
 create mode 100644 Dashboard/Services/BenefitScorer.cs
 create mode 100644 Lite/Services/BenefitScorer.cs

diff --git a/Dashboard/Models/PlanModels.cs b/Dashboard/Models/PlanModels.cs
index d3c75277..d645f73b 100644
--- a/Dashboard/Models/PlanModels.cs
+++ b/Dashboard/Models/PlanModels.cs
@@ -61,6 +61,7 @@ public class PlanStatement
     public SetOptionsInfo? SetOptions { get; set; }
     public List<PlanParameter> Parameters { get; set; } = new();
     public List<WaitStatInfo> WaitStats { get; set; } = new();
+    public List<WaitBenefit> WaitBenefits { get; set; } = new();
     public QueryTimeInfo? QueryTimeStats { get; set; }
 
     // Wave 2: MaxQueryMemory + QueryPlan-level warnings
@@ -370,6 +371,17 @@ public class PlanWarning
     public string Message { get; set; } = "";
     public PlanWarningSeverity Severity { get; set; }
     public SpillDetail? SpillDetails { get; set; }
+
+    /// <summary>
+    /// Maximum percentage of elapsed time that could be saved by addressing this finding.
+    /// null = not quantifiable, 0 = calculated as negligible.
+    /// </summary>
+    public double? MaxBenefitPercent { get; set; }
+
+    /// <summary>
+    /// Short actionable fix suggestion (e.g., "Add INCLUDE (columns) to index").
+    /// </summary>
+    public string? ActionableFix { get; set; }
 }
 
 public enum PlanWarningSeverity { Info, Warning, Critical }
@@ -433,6 +445,13 @@ public class PlanParameter
     public string? RuntimeValue { get; set; }
 }
 
+public class WaitBenefit
+{
+    public string WaitType { get; set; } = "";
+    public double MaxBenefitPercent { get; set; }
+    public string Category { get; set; } = "";
+}
+
 public class WaitStatInfo
 {
     public string WaitType { get; set; } = "";
diff --git a/Dashboard/Services/BenefitScorer.cs b/Dashboard/Services/BenefitScorer.cs
new file mode 100644
index 00000000..1acf26cf
--- /dev/null
+++ b/Dashboard/Services/BenefitScorer.cs
@@ -0,0 +1,653 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using PerformanceMonitorDashboard.Models;
+
+namespace PerformanceMonitorDashboard.Services;
+
+/// <summary>
+/// Second-pass analysis that calculates MaxBenefitPercent for each PlanWarning.
+/// Runs after PlanAnalyzer.Analyze() — the analyzer creates findings, the scorer quantifies them.
+/// Benefit = maximum % of elapsed time that could be saved by addressing the finding.
+/// </summary>
+public static class BenefitScorer
+{
+    // Warning types that map to specific scoring strategies
+    private static readonly HashSet<string> OperatorTimeRules = new(StringComparer.OrdinalIgnoreCase)
+    {
+        "Filter Operator",      // Rule 1
+        "Eager Index Spool",    // Rule 2
+        "Spill",                // Rule 7
+        // Key Lookup / RID Lookup (Rule 10) handled separately by ScoreKeyLookupWarning
+        "Scan With Predicate",  // Rule 11
+        "Non-SARGable Predicate", // Rule 12
+        "Scan Cardinality Misestimate", // Rule 32
+    };
+
+    public static void Score(ParsedPlan plan)
+    {
+        foreach (var batch in plan.Batches)
+        {
+            foreach (var stmt in batch.Statements)
+            {
+                ScoreStatementWarnings(stmt);
+
+                if (stmt.RootNode != null)
+                    ScoreNodeTree(stmt.RootNode, stmt);
+
+                if (stmt.WaitStats.Count > 0 && stmt.QueryTimeStats != null)
+                    ScoreWaitStats(stmt);
+            }
+        }
+    }
+
+    private static void ScoreStatementWarnings(PlanStatement stmt)
+    {
+        var elapsedMs = stmt.QueryTimeStats?.ElapsedTimeMs ?? 0;
+
+        foreach (var warning in stmt.PlanWarnings)
+        {
+            switch (warning.WarningType)
+            {
+                case "Ineffective Parallelism":   // Rule 25
+                case "Parallel Wait Bottleneck":  // Rule 31
+                    // These are meta-findings about parallelism efficiency.
+                    // The benefit is the gap between actual and ideal elapsed time.
+                    if (elapsedMs > 0 && stmt.QueryTimeStats != null)
+                    {
+                        var cpu = stmt.QueryTimeStats.CpuTimeMs;
+                        var dop = stmt.DegreeOfParallelism;
+                        if (dop > 1 && cpu > 0)
+                        {
+                            // Ideal elapsed = CPU / DOP. Benefit = (actual - ideal) / actual
+                            var idealElapsed = (double)cpu / dop;
+                            var benefit = Math.Max(0, (elapsedMs - idealElapsed) / elapsedMs * 100);
+                            warning.MaxBenefitPercent = Math.Min(100, Math.Round(benefit, 1));
+                        }
+                    }
+                    break;
+
+                case "Serial Plan": // Rule 3
+                    // Can't know how fast a parallel plan would be, but estimate:
+                    // CPU-bound: benefit up to (1 - 1/maxDOP) * 100%
+                    if (elapsedMs > 0 && stmt.QueryTimeStats != null)
+                    {
+                        var cpu = stmt.QueryTimeStats.CpuTimeMs;
+                        // Assume server max DOP — use a conservative 4 if unknown
+                        var potentialDop = 4;
+                        if (cpu >= elapsedMs)
+                        {
+                            // CPU-bound: parallelism could help significantly
+                            var benefit = (1.0 - 1.0 / potentialDop) * 100;
+                            warning.MaxBenefitPercent = Math.Round(benefit, 1);
+                        }
+                        else
+                        {
+                            // Not CPU-bound: parallelism helps less
+                            var cpuRatio = (double)cpu / elapsedMs;
+                            var benefit = cpuRatio * (1.0 - 1.0 / potentialDop) * 100;
+                            warning.MaxBenefitPercent = Math.Round(Math.Min(50, benefit), 1);
+                        }
+                    }
+                    break;
+
+                case "Memory Grant": // Rule 9
+                    // Grant wait is the only part that affects this query's elapsed time
+                    if (elapsedMs > 0 && stmt.MemoryGrant?.GrantWaitTimeMs > 0)
+                    {
+                        var benefit = (double)stmt.MemoryGrant.GrantWaitTimeMs / elapsedMs * 100;
+                        warning.MaxBenefitPercent = Math.Round(Math.Min(100, benefit), 1);
+                    }
+                    break;
+
+                case "High Compile CPU": // Rule 19
+                    if (elapsedMs > 0 && stmt.CompileCPUMs > 0)
+                    {
+                        var benefit = (double)stmt.CompileCPUMs / elapsedMs * 100;
+                        warning.MaxBenefitPercent = Math.Round(Math.Min(100, benefit), 1);
+                    }
+                    break;
+
+                // Rules that cannot be quantified: leave MaxBenefitPercent as null
+                // Rule 18 (Compile Memory Exceeded), Rule 20 (Local Variables),
+                // Rule 27 (Optimize For Unknown)
+            }
+        }
+    }
+
+    private static void ScoreNodeTree(PlanNode node, PlanStatement stmt)
+    {
+        ScoreNodeWarnings(node, stmt);
+
+        foreach (var child in node.Children)
+            ScoreNodeTree(child, stmt);
+    }
+
+    private static void ScoreNodeWarnings(PlanNode node, PlanStatement stmt)
+    {
+        var elapsedMs = stmt.QueryTimeStats?.ElapsedTimeMs ?? 0;
+
+        foreach (var warning in node.Warnings)
+        {
+            // Already scored (e.g., by a different pass)
+            if (warning.MaxBenefitPercent != null)
+                continue;
+
+            if (warning.WarningType == "UDF Execution") // Rule 4
+            {
+                ScoreUdfWarning(warning, node, elapsedMs);
+            }
+            else if (warning.WarningType == "Filter Operator") // Rule 1
+            {
+                ScoreFilterWarning(warning, node, stmt);
+            }
+            else if (warning.WarningType == "Nested Loops High Executions") // Rule 16
+            {
+                ScoreNestedLoopsWarning(warning, node, stmt);
+            }
+            else if (warning.SpillDetails != null) // Rule 7
+            {
+                ScoreSpillWarning(warning, node, stmt);
+            }
+            else if (warning.WarningType is "Key Lookup" or "RID Lookup") // Rule 10
+            {
+                ScoreKeyLookupWarning(warning, node, stmt);
+            }
+            else if (OperatorTimeRules.Contains(warning.WarningType))
+            {
+                ScoreByOperatorTime(warning, node, stmt);
+            }
+            else if (warning.WarningType == "Row Estimate Mismatch") // Rule 5
+            {
+                ScoreEstimateMismatchWarning(warning, node, stmt);
+            }
+            // Rules that stay null: Scalar UDF (Rule 6, informational reference),
+            // Parallel Skew (Rule 8 — will be integrated per-operator later),
+            // Data Type Mismatch (Rule 13),
+            // Lazy Spool Ineffective (Rule 14), Join OR Clause (Rule 15),
+            // Many-to-Many Merge Join (Rule 17), CTE Multiple References (Rule 21),
+            // Table Variable (Rule 22), Table-Valued Function (Rule 23),
+            // Top Above Scan (Rule 24), Row Goal (Rule 26),
+            // NOT IN with Nullable Column (Rule 28), Implicit Conversion (Rule 29),
+            // Wide Index Suggestion (Rule 30), Estimated Plan CE Guess (Rule 33)
+        }
+    }
+
+    /// <summary>
+    /// Rule 4: UDF Execution — benefit is UDF elapsed time / statement elapsed.
+    /// </summary>
+    private static void ScoreUdfWarning(PlanWarning warning, PlanNode node, long stmtElapsedMs)
+    {
+        if (stmtElapsedMs > 0 && node.UdfElapsedTimeMs > 0)
+        {
+            var benefit = (double)node.UdfElapsedTimeMs / stmtElapsedMs * 100;
+            warning.MaxBenefitPercent = Math.Round(Math.Min(100, benefit), 1);
+        }
+    }
+
+    /// <summary>
+    /// Rule 1: Filter Operator — benefit is child subtree elapsed / statement elapsed.
+    /// The filter discards rows late; eliminating it means the child subtree work was unnecessary.
+    /// </summary>
+    private static void ScoreFilterWarning(PlanWarning warning, PlanNode node, PlanStatement stmt)
+    {
+        var stmtMs = stmt.QueryTimeStats?.ElapsedTimeMs ?? 0;
+
+        if (node.HasActualStats && stmtMs > 0 && node.Children.Count > 0)
+        {
+            var childElapsed = node.Children.Max(c => c.ActualElapsedMs);
+            var benefit = (double)childElapsed / stmtMs * 100;
+            warning.MaxBenefitPercent = Math.Round(Math.Min(100, benefit), 1);
+        }
+        else if (!node.HasActualStats && stmt.StatementSubTreeCost > 0 && node.Children.Count > 0)
+        {
+            // Estimated plan fallback: child subtree cost / statement cost
+            var childCost = node.Children.Sum(c => c.EstimatedTotalSubtreeCost);
+            var benefit = childCost / stmt.StatementSubTreeCost * 100;
+            warning.MaxBenefitPercent = Math.Round(Math.Min(100, benefit), 1);
+        }
+    }
+
+    /// <summary>
+    /// Rule 16: Nested Loops High Executions — benefit is inner-side elapsed / statement elapsed.
+    /// </summary>
+    private static void ScoreNestedLoopsWarning(PlanWarning warning, PlanNode node, PlanStatement stmt)
+    {
+        var stmtMs = stmt.QueryTimeStats?.ElapsedTimeMs ?? 0;
+
+        if (node.Children.Count >= 2)
+        {
+            var innerChild = node.Children[1];
+
+            if (innerChild.HasActualStats && stmtMs > 0 && innerChild.ActualElapsedMs > 0)
+            {
+                var benefit = (double)innerChild.ActualElapsedMs / stmtMs * 100;
+                warning.MaxBenefitPercent = Math.Round(Math.Min(100, benefit), 1);
+            }
+            else if (!innerChild.HasActualStats && stmt.StatementSubTreeCost > 0)
+            {
+                var benefit = innerChild.EstimatedTotalSubtreeCost / stmt.StatementSubTreeCost * 100;
+                warning.MaxBenefitPercent = Math.Round(Math.Min(100, benefit), 1);
+            }
+        }
+    }
+
+    /// <summary>
+    /// Rule 7: Spill — benefit is the spilling operator's self-time / statement elapsed.
+    /// Exchange spills use the parallelism operator time (unreliable but best we have).
+    /// </summary>
+    private static void ScoreSpillWarning(PlanWarning warning, PlanNode node, PlanStatement stmt)
+    {
+        var stmtMs = stmt.QueryTimeStats?.ElapsedTimeMs ?? 0;
+        if (stmtMs <= 0) return;
+
+        long operatorMs;
+        if (warning.SpillDetails?.SpillType == "Exchange")
+            operatorMs = GetParallelismOperatorElapsedMs(node);
+        else
+            operatorMs = PlanAnalyzer.GetOperatorOwnElapsedMs(node);
+
+        if (operatorMs > 0)
+        {
+            var benefit = (double)operatorMs / stmtMs * 100;
+            warning.MaxBenefitPercent = Math.Round(Math.Min(100, benefit), 1);
+        }
+    }
+
+    /// <summary>
+    /// Generic operator-time scoring for rules where the fix would eliminate or
+    /// drastically reduce the operator's work: Key Lookup, RID Lookup,
+    /// Scan With Predicate, Non-SARGable Predicate, Eager Index Spool,
+    /// Scan Cardinality Misestimate.
+    /// </summary>
+    private static void ScoreByOperatorTime(PlanWarning warning, PlanNode node, PlanStatement stmt)
+    {
+        var stmtMs = stmt.QueryTimeStats?.ElapsedTimeMs ?? 0;
+
+        if (node.HasActualStats && stmtMs > 0)
+        {
+            var operatorMs = PlanAnalyzer.GetOperatorOwnElapsedMs(node);
+            if (operatorMs > 0)
+            {
+                var benefit = (double)operatorMs / stmtMs * 100;
+                warning.MaxBenefitPercent = Math.Round(Math.Min(100, benefit), 1);
+            }
+            else
+            {
+                // Operator self-time is 0 — negligible benefit
+                warning.MaxBenefitPercent = 0;
+            }
+        }
+        else if (!node.HasActualStats && stmt.StatementSubTreeCost > 0)
+        {
+            // Estimated plan fallback: use operator cost percentage
+            var benefit = (double)node.CostPercent;
+            warning.MaxBenefitPercent = Math.Round(Math.Min(100, benefit), 1);
+        }
+    }
+
+    /// <summary>
+    /// Rule 10: Key Lookup / RID Lookup — benefit includes the lookup operator's time,
+    /// plus the parent Nested Loops join when the NL only exists to drive the lookup
+    /// (inner child is the lookup, outer child is a seek/scan with no subtree).
+    /// </summary>
+    private static void ScoreKeyLookupWarning(PlanWarning warning, PlanNode node, PlanStatement stmt)
+    {
+        var stmtMs = stmt.QueryTimeStats?.ElapsedTimeMs ?? 0;
+
+        if (node.HasActualStats && stmtMs > 0)
+        {
+            var operatorMs = PlanAnalyzer.GetOperatorOwnElapsedMs(node);
+
+            // Check if the parent NL join is purely a lookup driver:
+            // - Parent is Nested Loops
+            // - Has exactly 2 children
+            // - This node (the lookup) is the inner child (index 1)
+            // - The outer child (index 0) is a simple seek/scan with no children
+            var parent = node.Parent;
+            if (parent != null
+                && parent.PhysicalOp == "Nested Loops"
+                && parent.Children.Count == 2
+                && parent.Children[1] == node
+                && parent.Children[0].Children.Count == 0)
+            {
+                operatorMs += PlanAnalyzer.GetOperatorOwnElapsedMs(parent);
+            }
+
+            if (operatorMs > 0)
+            {
+                var benefit = (double)operatorMs / stmtMs * 100;
+                warning.MaxBenefitPercent = Math.Round(Math.Min(100, benefit), 1);
+            }
+            else
+            {
+                warning.MaxBenefitPercent = 0;
+            }
+        }
+        else if (!node.HasActualStats && stmt.StatementSubTreeCost > 0)
+        {
+            var benefit = (double)node.CostPercent;
+            // Same parent-NL logic for estimated plans
+            var parent = node.Parent;
+            if (parent != null
+                && parent.PhysicalOp == "Nested Loops"
+                && parent.Children.Count == 2
+                && parent.Children[1] == node
+                && parent.Children[0].Children.Count == 0)
+            {
+                benefit += parent.CostPercent;
+            }
+            warning.MaxBenefitPercent = Math.Round(Math.Min(100, benefit), 1);
+        }
+    }
+
+    /// <summary>
+    /// Rule 5: Row Estimate Mismatch — benefit is the harmed operator's time.
+    /// If the mismatch caused a spill, benefit = spilling operator time.
+    /// If it caused a bad join choice, benefit = join operator time.
+    /// Otherwise, benefit is the misestimated operator's own time (conservative).
+    /// </summary>
+    private static void ScoreEstimateMismatchWarning(PlanWarning warning, PlanNode node, PlanStatement stmt)
+    {
+        var stmtMs = stmt.QueryTimeStats?.ElapsedTimeMs ?? 0;
+        if (stmtMs <= 0 || !node.HasActualStats) return;
+
+        // Walk up to find the harmed operator (same logic as AssessEstimateHarm)
+        var harmedNode = FindHarmedOperator(node);
+        if (harmedNode != null)
+        {
+            var operatorMs = PlanAnalyzer.GetOperatorOwnElapsedMs(harmedNode);
+            if (operatorMs > 0)
+            {
+                var benefit = (double)operatorMs / stmtMs * 100;
+                warning.MaxBenefitPercent = Math.Round(Math.Min(100, benefit), 1);
+                return;
+            }
+        }
+
+        // Fallback: use the misestimated node's own time
+        var ownMs = PlanAnalyzer.GetOperatorOwnElapsedMs(node);
+        if (ownMs > 0)
+        {
+            var benefit = (double)ownMs / stmtMs * 100;
+            warning.MaxBenefitPercent = Math.Round(Math.Min(100, benefit), 1);
+        }
+    }
+
+    /// <summary>
+    /// Walks up from a node with a bad row estimate to find the operator that was
+    /// harmed by it (spilling sort/hash, or join that chose the wrong strategy).
+    /// Returns null if no specific harm can be attributed.
+    /// </summary>
+    private static PlanNode? FindHarmedOperator(PlanNode node)
+    {
+        // The node itself has a spill — it harmed itself
+        if (node.Warnings.Any(w => w.SpillDetails != null))
+            return node;
+
+        // Walk up through transparent operators
+        var ancestor = node.Parent;
+        while (ancestor != null)
+        {
+            if (ancestor.PhysicalOp == "Parallelism" ||
+                ancestor.PhysicalOp == "Compute Scalar" ||
+                ancestor.PhysicalOp == "Segment" ||
+                ancestor.PhysicalOp == "Sequence Project" ||
+                ancestor.PhysicalOp == "Top" ||
+                ancestor.PhysicalOp == "Filter")
+            {
+                ancestor = ancestor.Parent;
+                continue;
+            }
+
+            // Parent join — bad row count from below caused wrong join choice
+            if (ancestor.LogicalOp.Contains("Join", StringComparison.OrdinalIgnoreCase))
+            {
+                if (ancestor.IsAdaptive)
+                    return null; // Adaptive join self-corrects
+                return ancestor;
+            }
+
+            // Parent Sort/Hash that spilled
+            if (ancestor.Warnings.Any(w => w.SpillDetails != null))
+                return ancestor;
+
+            // Parent Sort/Hash with no spill — benign
+            if (ancestor.PhysicalOp.Contains("Sort", StringComparison.OrdinalIgnoreCase) ||
+                ancestor.PhysicalOp.Contains("Hash", StringComparison.OrdinalIgnoreCase))
+                return null;
+
+            break;
+        }
+
+        return null;
+    }
+
+    /// <summary>
+    /// Calculates a Parallelism (exchange) operator's own elapsed time.
+    /// Mirrors PlanAnalyzer.GetParallelismOperatorElapsedMs but accessible here.
+    /// </summary>
+    private static long GetParallelismOperatorElapsedMs(PlanNode node)
+    {
+        if (node.Children.Count == 0)
+            return node.ActualElapsedMs;
+
+        if (node.PerThreadStats.Count > 1)
+            return PlanAnalyzer.GetOperatorOwnElapsedMs(node);
+
+        var maxChildElapsed = node.Children.Max(c => c.ActualElapsedMs);
+        return Math.Max(0, node.ActualElapsedMs - maxChildElapsed);
+    }
+
+    // ---------------------------------------------------------------
+    //  Stage 2: Wait Stats Benefit
+    // ---------------------------------------------------------------
+
+    /// <summary>
+    /// Calculates MaxBenefitPercent for each wait type in the statement's wait stats.
+    /// Serial plans: simple ratio of wait time to elapsed time.
+    /// Parallel plans: proportional allocation across relevant operators (Joe's formula).
+    /// </summary>
+    private static void ScoreWaitStats(PlanStatement stmt)
+    {
+        var elapsedMs = stmt.QueryTimeStats!.ElapsedTimeMs;
+        if (elapsedMs <= 0) return;
+
+        var isParallel = stmt.DegreeOfParallelism > 1 && stmt.RootNode != null;
+
+        // Collect all operators with per-thread stats for parallel benefit calculation
+        List<OperatorWaitProfile>? operatorProfiles = null;
+        if (isParallel)
+        {
+            operatorProfiles = new List<OperatorWaitProfile>();
+            CollectOperatorWaitProfiles(stmt.RootNode!, operatorProfiles);
+        }
+
+        foreach (var wait in stmt.WaitStats)
+        {
+            if (wait.WaitTimeMs <= 0) continue;
+
+            var category = ClassifyWaitType(wait.WaitType);
+            double benefitPct;
+
+            if (category == "Parallelism" && isParallel)
+            {
+                // CXPACKET/CXCONSUMER/CXSYNC: benefit is the parallelism efficiency gap,
+                // not the raw wait time. Threads waiting for other threads is a symptom
+                // of imperfect parallelism, not directly addressable time.
+                var cpu = stmt.QueryTimeStats!.CpuTimeMs;
+                var dop = stmt.DegreeOfParallelism;
+                if (cpu > 0 && dop > 1)
+                {
+                    var idealElapsed = (double)cpu / dop;
+                    benefitPct = Math.Max(0, (elapsedMs - idealElapsed) / elapsedMs * 100);
+                }
+                else
+                {
+                    benefitPct = (double)wait.WaitTimeMs / elapsedMs * 100;
+                }
+            }
+            else if (!isParallel || operatorProfiles == null || operatorProfiles.Count == 0)
+            {
+                // Serial plan or no operator data: simple ratio
+                benefitPct = (double)wait.WaitTimeMs / elapsedMs * 100;
+            }
+            else
+            {
+                // Parallel plan: proportional allocation across relevant operators
+                benefitPct = CalculateParallelWaitBenefit(wait, category, operatorProfiles, elapsedMs);
+            }
+
+            stmt.WaitBenefits.Add(new WaitBenefit
+            {
+                WaitType = wait.WaitType,
+                MaxBenefitPercent = Math.Round(Math.Min(100, Math.Max(0, benefitPct)), 1),
+                Category = category
+            });
+        }
+    }
+
+    /// <summary>
+    /// Parallel wait benefit using Joe's formula:
+    /// benefit = (SUM relevant operator max waits) * (total_wait_for_type) / (SUM relevant operator total waits)
+    /// Then convert to % of statement elapsed time.
+    /// </summary>
+    private static double CalculateParallelWaitBenefit(
+        WaitStatInfo wait, string category,
+        List<OperatorWaitProfile> profiles, long stmtElapsedMs)
+    {
+        // Filter to operators relevant for this wait category
+        var relevant = new List<OperatorWaitProfile>();
+        foreach (var p in profiles)
+        {
+            if (IsOperatorRelevantForCategory(p, category))
+                relevant.Add(p);
+        }
+
+        // If no operators match, fall back to simple ratio
+        if (relevant.Count == 0)
+            return (double)wait.WaitTimeMs / stmtElapsedMs * 100;
+
+        // Joe's formula:
+        // sum_max = SUM of each relevant operator's max per-thread wait time
+        // sum_total = SUM of each relevant operator's total wait time across all threads
+        // benefit_ms = sum_max * wait.WaitTimeMs / sum_total
+        double sumMax = 0;
+        double sumTotal = 0;
+        foreach (var p in relevant)
+        {
+            sumMax += p.MaxThreadWaitMs;
+            sumTotal += p.TotalWaitMs;
+        }
+
+        if (sumTotal <= 0)
+            return (double)wait.WaitTimeMs / stmtElapsedMs * 100;
+
+        var benefitMs = sumMax * wait.WaitTimeMs / sumTotal;
+        return benefitMs / stmtElapsedMs * 100;
+    }
+
+    /// <summary>
+    /// Determines if an operator is relevant for a given wait category.
+    /// </summary>
+    private static bool IsOperatorRelevantForCategory(OperatorWaitProfile profile, string category)
+    {
+        return category switch
+        {
+            "I/O" => profile.HasPhysicalReads,
+            "CPU" => profile.HasCpuWork,
+            "Parallelism" => profile.IsExchange,
+            "Hash" => profile.IsHashOperator,
+            "Sort" => profile.IsSortOperator,
+            "Latch" => profile.HasTempDbActivity,
+            "Lock" => true,  // any operator can be blocked by locks
+            "Network" => false,  // ASYNC_NETWORK_IO is client-side, not attributable to operators
+            "Memory" => false,  // memory waits are statement-level
+            _ => true,  // unknown category: include all operators
+        };
+    }
+
+    /// <summary>
+    /// Walks the operator tree and collects wait time profiles for each operator.
+    /// Wait time per thread = max(0, elapsed - cpu) for that thread.
+    /// </summary>
+    private static void CollectOperatorWaitProfiles(PlanNode node, List<OperatorWaitProfile> profiles)
+    {
+        if (node.HasActualStats && node.PerThreadStats.Count > 0)
+        {
+            long maxThreadWait = 0;
+            long totalWait = 0;
+
+            foreach (var ts in node.PerThreadStats)
+            {
+                var threadWait = Math.Max(0, ts.ActualElapsedMs - ts.ActualCPUMs);
+                totalWait += threadWait;
+                if (threadWait > maxThreadWait)
+                    maxThreadWait = threadWait;
+            }
+
+            if (totalWait > 0 || maxThreadWait > 0)
+            {
+                profiles.Add(new OperatorWaitProfile
+                {
+                    Node = node,
+                    MaxThreadWaitMs = maxThreadWait,
+                    TotalWaitMs = totalWait,
+                    HasPhysicalReads = node.ActualPhysicalReads > 0,
+                    HasCpuWork = node.ActualCPUMs > 0,
+                    IsExchange = node.PhysicalOp == "Parallelism",
+                    IsHashOperator = node.PhysicalOp.StartsWith("Hash", StringComparison.OrdinalIgnoreCase),
+                    IsSortOperator = node.PhysicalOp.StartsWith("Sort", StringComparison.OrdinalIgnoreCase),
+                    HasTempDbActivity = node.Warnings.Any(w => w.SpillDetails != null)
+                                     || node.PhysicalOp.Contains("Spool", StringComparison.OrdinalIgnoreCase)
+                });
+            }
+        }
+
+        foreach (var child in node.Children)
+            CollectOperatorWaitProfiles(child, profiles);
+    }
+
+    /// <summary>
+    /// Classifies a wait type into a category for operator-to-wait mapping.
+    /// </summary>
+    internal static string ClassifyWaitType(string waitType)
+    {
+        var wt = waitType.ToUpperInvariant();
+        return wt switch
+        {
+            _ when wt.StartsWith("PAGEIOLATCH") => "I/O",
+            _ when wt.Contains("IO_COMPLETION") => "I/O",
+            _ when wt.StartsWith("WRITELOG") => "I/O",
+            _ when wt == "SOS_SCHEDULER_YIELD" => "CPU",
+            _ when wt.StartsWith("CXPACKET") || wt.StartsWith("CXCONSUMER") => "Parallelism",
+            _ when wt.StartsWith("CXSYNC") => "Parallelism",
+            _ when wt.StartsWith("HT") => "Hash",
+            _ when wt == "BPSORT" => "Sort",
+            _ when wt == "BMPBUILD" => "Hash",
+            _ when wt.StartsWith("PAGELATCH") => "Latch",
+            _ when wt.StartsWith("LATCH_") => "Latch",
+            _ when wt.StartsWith("LCK_") => "Lock",
+            _ when wt == "ASYNC_NETWORK_IO" => "Network",
+            _ when wt.Contains("MEMORY_ALLOCATION") => "Memory",
+            _ when wt == "SOS_PHYS_PAGE_CACHE" => "Memory",
+            _ => "Other"
+        };
+    }
+
+    /// <summary>
+    /// Per-operator wait time profile used for parallel benefit allocation.
+    /// </summary>
+    private sealed class OperatorWaitProfile
+    {
+        public PlanNode Node { get; init; } = null!;
+        public long MaxThreadWaitMs { get; init; }
+        public long TotalWaitMs { get; init; }
+        public bool HasPhysicalReads { get; init; }
+        public bool HasCpuWork { get; init; }
+        public bool IsExchange { get; init; }
+        public bool IsHashOperator { get; init; }
+        public bool IsSortOperator { get; init; }
+        public bool HasTempDbActivity { get; init; }
+    }
+}
diff --git a/Dashboard/Services/PlanAnalyzer.cs b/Dashboard/Services/PlanAnalyzer.cs
index befa192c..254246d5 100644
--- a/Dashboard/Services/PlanAnalyzer.cs
+++ b/Dashboard/Services/PlanAnalyzer.cs
@@ -179,16 +179,24 @@ private static void AnalyzeStatement(PlanStatement stmt)
                 });
             }
 
-            // Large memory grant with sort/hash guidance
+            // Large memory grant with top consumers
             if (grant.GrantedMemoryKB >= 1048576 && stmt.RootNode != null)
             {
                 var consumers = new List<string>();
                 FindMemoryConsumers(stmt.RootNode, consumers);
 
                 var grantMB = grant.GrantedMemoryKB / 1024.0;
-                var guidance = consumers.Count > 0
-                    ? $" Memory consumers: {string.Join(", ", consumers)}. Check whether these operators are processing more rows than necessary."
-                    : "";
+                var guidance = "";
+                if (consumers.Count > 0)
+                {
+                    // Show only the top 3 consumers — listing 20+ is noise
+                    var shown = consumers.Take(3);
+                    var remaining = consumers.Count - 3;
+                    guidance = $" Largest consumers: {string.Join(", ", shown)}";
+                    if (remaining > 0)
+                        guidance += $", and {remaining} more";
+                    guidance += ".";
+                }
 
                 stmt.PlanWarnings.Add(new PlanWarning
                 {
@@ -517,7 +525,8 @@ private static void AnalyzeNode(PlanNode node, PlanStatement stmt)
         // - A parent join may have chosen the wrong strategy
         // - Root nodes with no parent to harm are skipped
         // - Nodes whose only parents are Parallelism/Top/Sort (no spill) are skipped
-        if (node.HasActualStats && node.EstimateRows > 0)
+        if (node.HasActualStats && node.EstimateRows > 0
+            && !node.Lookup) // Key lookups are point lookups (1 row per execution) — per-execution estimate is misleading
         {
             if (node.ActualRows == 0)
             {
@@ -642,11 +651,29 @@ private static void AnalyzeNode(PlanNode node, PlanStatement stmt)
                 var skewThreshold = workerThreads.Count <= 2 ? 0.80 : 0.50;
                 if (skewRatio >= skewThreshold)
                 {
+                    var message = $"Thread {maxThread.ThreadId} processed {skewRatio:P0} of rows ({maxThread.ActualRows:N0}/{totalRows:N0}). Work is heavily skewed to one thread, so parallelism isn't helping much.";
+                    var severity = PlanWarningSeverity.Warning;
+
+                    // Batch mode sorts produce all output on a single thread by design
+                    // unless their parent is a batch mode Window Aggregate
+                    if (node.PhysicalOp == "Sort"
+                        && (node.ActualExecutionMode ?? node.ExecutionMode) == "Batch"
+                        && node.Parent?.PhysicalOp != "Window Aggregate")
+                    {
+                        message += " Batch mode sorts produce all output rows on a single thread by design, unless feeding a batch mode Window Aggregate.";
+                        severity = PlanWarningSeverity.Info;
+                    }
+                    else
+                    {
+                        // Add practical context — skew is often hard to fix
+                        message += " Common causes: uneven data distribution across partitions or hash buckets, or a scan/seek whose predicate sends most rows to one range. Reducing DOP or rewriting the query to avoid the skewed operation may help.";
+                    }
+
                     node.Warnings.Add(new PlanWarning
                     {
                         WarningType = "Parallel Skew",
-                        Message = $"Thread {maxThread.ThreadId} processed {skewRatio:P0} of rows ({maxThread.ActualRows:N0}/{totalRows:N0}). Work is heavily skewed to one thread, so parallelism isn't helping much.",
-                        Severity = PlanWarningSeverity.Warning
+                        Message = message,
+                        Severity = severity
                     });
                 }
             }
@@ -667,18 +694,37 @@ private static void AnalyzeNode(PlanNode node, PlanStatement stmt)
                 Severity = PlanWarningSeverity.Warning
             });
         }
-        else if (node.Lookup && !string.IsNullOrEmpty(node.Predicate))
+        else if (node.Lookup)
         {
+            var lookupMsg = "Key Lookup — SQL Server found rows via a nonclustered index but had to go back to the clustered index for additional columns.";
+
+            // Show what columns the lookup is fetching
+            if (!string.IsNullOrEmpty(node.OutputColumns))
+                lookupMsg += $"\nColumns fetched: {Truncate(node.OutputColumns, 200)}";
+
+            // Only call out the predicate if it actually filters rows
+            if (!string.IsNullOrEmpty(node.Predicate))
+            {
+                var predicateFilters = node.HasActualStats && node.ActualExecutions > 0
+                    && node.ActualRows < node.ActualExecutions;
+                if (predicateFilters)
+                    lookupMsg += $"\nResidual predicate (filtered {node.ActualExecutions - node.ActualRows:N0} rows): {Truncate(node.Predicate, 200)}";
+            }
+
+            lookupMsg += "\nTo eliminate the lookup, consider adding the needed columns as INCLUDE columns on the nonclustered index. This widens the index, so weigh the read benefit against write and storage overhead.";
+
             node.Warnings.Add(new PlanWarning
             {
                 WarningType = "Key Lookup",
-                Message = $"Key Lookup — SQL Server found rows via a nonclustered index but had to go back to the clustered index for additional columns. Alter the nonclustered index to add the predicate column as a key column or as an INCLUDE column.\nPredicate: {Truncate(node.Predicate, 200)}",
+                Message = lookupMsg,
                 Severity = PlanWarningSeverity.Critical
             });
         }
 
         // Rule 12: Non-SARGable predicate on scan
-        var nonSargableReason = DetectNonSargablePredicate(node);
+        // Skip for 0-execution nodes — the operator never ran, so the warning is academic
+        var nonSargableReason = (node.HasActualStats && node.ActualExecutions == 0)
+            ? null : DetectNonSargablePredicate(node);
         if (nonSargableReason != null)
         {
             var nonSargableAdvice = nonSargableReason switch
@@ -707,19 +753,30 @@ _ when nonSargableReason.StartsWith("Function call", StringComparison.OrdinalIgn
 
         // Rule 11: Scan with residual predicate (skip if non-SARGable already flagged)
         // A PROBE() alone is just a bitmap filter — not a real residual predicate.
+        // Skip for 0-execution nodes — the operator never ran
         if (nonSargableReason == null && IsRowstoreScan(node) && !string.IsNullOrEmpty(node.Predicate) &&
-            !IsProbeOnly(node.Predicate))
+            !IsProbeOnly(node.Predicate) && !(node.HasActualStats && node.ActualExecutions == 0))
         {
             var displayPredicate = StripProbeExpressions(node.Predicate);
             var details = BuildScanImpactDetails(node, stmt);
             var severity = PlanWarningSeverity.Warning;
+
+            // Elevate to Critical if the scan dominates the plan
             if (details.CostPct >= 90 || details.ElapsedPct >= 90)
                 severity = PlanWarningSeverity.Critical;
+
             var message = "Scan with residual predicate — SQL Server is reading every row and filtering after the fact.";
             if (!string.IsNullOrEmpty(details.Summary))
                 message += $" {details.Summary}";
             message += " Check that you have appropriate indexes.";
+
+            // I/O waits specifically confirm the scan is hitting disk — elevate
+            if (HasSignificantIoWaits(stmt.WaitStats) && details.CostPct >= 50
+                && severity != PlanWarningSeverity.Critical)
+                severity = PlanWarningSeverity.Critical;
+
             message += $"\nPredicate: {Truncate(displayPredicate, 200)}";
+
             node.Warnings.Add(new PlanWarning
             {
                 WarningType = "Scan With Predicate",
@@ -995,7 +1052,7 @@ _ when nonSargableReason.StartsWith("Function call", StringComparison.OrdinalIgn
                     node.Warnings.Add(new PlanWarning
                     {
                         WarningType = "Top Above Scan",
-                        Message = $"{topLabel} reads from {scanCandidate.PhysicalOp} (Node {scanCandidate.NodeId}).{innerNote}{predInfo} An index on the ORDER BY columns could eliminate the scan and sort entirely.",
+                        Message = $"{topLabel} reads from {FormatNodeRef(scanCandidate)}.{innerNote}{predInfo} An index on the ORDER BY columns could eliminate the scan and sort entirely.",
                         Severity = onInner ? PlanWarningSeverity.Critical : PlanWarningSeverity.Warning
                     });
                 }
@@ -1014,12 +1071,28 @@ _ when nonSargableReason.StartsWith("Function call", StringComparison.OrdinalIgn
             // tiny floating-point differences that display identically are noise
             if (reduction >= 2.0)
             {
-                node.Warnings.Add(new PlanWarning
+                // If we have actual stats, check whether the row goal prediction was correct.
+                // When actual rows <= the row goal estimate, the optimizer stopped early as planned — benign.
+                var rowGoalWorked = false;
+                if (node.HasActualStats)
                 {
-                    WarningType = "Row Goal",
-                    Message = $"Row goal active: estimate reduced from {node.EstimateRowsWithoutRowGoal:N0} to {node.EstimateRows:N0} ({reduction:N0}x reduction) due to TOP, EXISTS, IN, or FAST hint. The optimizer chose this plan shape expecting to stop reading early. If the query reads all rows anyway, the plan choice may be suboptimal.",
-                    Severity = PlanWarningSeverity.Info
-                });
+                    var executions = node.ActualExecutions > 0 ? node.ActualExecutions : 1;
+                    var actualPerExec = (double)node.ActualRows / executions;
+                    rowGoalWorked = actualPerExec <= node.EstimateRows;
+                }
+
+                if (!rowGoalWorked)
+                {
+                    // Try to identify the specific row goal cause from the statement text
+                    var cause = IdentifyRowGoalCause(stmt.StatementText);
+
+                    node.Warnings.Add(new PlanWarning
+                    {
+                        WarningType = "Row Goal",
+                        Message = $"Row goal active: estimate reduced from {node.EstimateRowsWithoutRowGoal:N0} to {node.EstimateRows:N0} ({reduction:N0}x reduction) due to {cause}. The optimizer chose this plan shape expecting to stop reading early. If the query reads all rows anyway, the plan choice may be suboptimal.",
+                        Severity = PlanWarningSeverity.Info
+                    });
+                }
             }
         }
 
@@ -1041,9 +1114,11 @@ _ when nonSargableReason.StartsWith("Function call", StringComparison.OrdinalIgn
         }
 
         // Rule 29: Enhance implicit conversion warnings — Seek Plan is more severe
+        // Skip for 0-execution nodes — the operator never ran
+        if (!(node.HasActualStats && node.ActualExecutions == 0))
         foreach (var w in node.Warnings.ToList())
         {
-            if (w.WarningType == "Implicit Conversion" && w.Message.StartsWith("Seek Plan", StringComparison.Ordinal))
+            if (w.WarningType == "Implicit Conversion" && w.Message.StartsWith("Seek Plan"))
             {
                 w.Severity = PlanWarningSeverity.Critical;
                 w.Message = $"Implicit conversion prevented an index seek, forcing a scan instead. Fix the data type mismatch: ensure the parameter or variable type matches the column type exactly. {w.Message}";
@@ -1268,25 +1343,37 @@ private static bool IsOrExpansionChain(PlanNode concatenationNode)
     /// Finds Sort and Hash Match operators in the tree that consume memory.
     /// </summary>
     private static void FindMemoryConsumers(PlanNode node, List<string> consumers)
+    {
+        // Collect all consumers first, then sort by row count descending
+        var raw = new List<(string Label, double Rows)>();
+        FindMemoryConsumersRecursive(node, raw);
+
+        foreach (var (label, _) in raw.OrderByDescending(c => c.Rows))
+            consumers.Add(label);
+    }
+
+    private static void FindMemoryConsumersRecursive(PlanNode node, List<(string Label, double Rows)> consumers)
     {
         if (node.PhysicalOp.Contains("Sort", StringComparison.OrdinalIgnoreCase) &&
             !node.PhysicalOp.Contains("Spool", StringComparison.OrdinalIgnoreCase))
         {
+            var rowCount = node.HasActualStats ? node.ActualRows : node.EstimateRows;
             var rows = node.HasActualStats
                 ? $"{node.ActualRows:N0} actual rows"
                 : $"{node.EstimateRows:N0} estimated rows";
-            consumers.Add($"Sort (Node {node.NodeId}, {rows})");
+            consumers.Add(($"Sort (Node {node.NodeId}, {rows})", rowCount));
         }
         else if (node.PhysicalOp.Contains("Hash", StringComparison.OrdinalIgnoreCase))
         {
+            var rowCount = node.HasActualStats ? node.ActualRows : node.EstimateRows;
             var rows = node.HasActualStats
                 ? $"{node.ActualRows:N0} actual rows"
                 : $"{node.EstimateRows:N0} estimated rows";
-            consumers.Add($"Hash Match (Node {node.NodeId}, {rows})");
+            consumers.Add(($"Hash Match (Node {node.NodeId}, {rows})", rowCount));
         }
 
         foreach (var child in node.Children)
-            FindMemoryConsumers(child, consumers);
+            FindMemoryConsumersRecursive(child, consumers);
     }
 
     /// <summary>
@@ -1298,7 +1385,7 @@ private static void FindMemoryConsumers(PlanNode node, List<string> consumers)
     /// Exchange operators accumulate downstream wait time (e.g. from spilling
     /// children) so their self-time is unreliable — see sql.kiwi/2021/03.
     /// </summary>
-    private static long GetOperatorOwnElapsedMs(PlanNode node)
+    internal static long GetOperatorOwnElapsedMs(PlanNode node)
     {
         if (node.ActualExecutionMode == "Batch")
             return node.ActualElapsedMs;
@@ -1536,6 +1623,37 @@ private static string Truncate(string value, int maxLength)
         return value.Length <= maxLength ? value : value[..maxLength] + "...";
     }
 
+    /// <summary>
+    /// Returns a short label describing what a wait type means (e.g., "I/O — reading from disk").
+    /// Public for use by UI components that annotate wait stats inline.
+    /// </summary>
+    public static string GetWaitLabel(string waitType)
+    {
+        var wt = waitType.ToUpperInvariant();
+        return wt switch
+        {
+            _ when wt.StartsWith("PAGEIOLATCH", StringComparison.Ordinal) => "I/O — reading data from disk",
+            _ when wt.Contains("IO_COMPLETION", StringComparison.Ordinal) => "I/O — spills to TempDB or eager writes",
+            _ when wt == "SOS_SCHEDULER_YIELD" => "CPU — scheduler yielding",
+            _ when wt.StartsWith("CXPACKET", StringComparison.Ordinal) || wt.StartsWith("CXCONSUMER", StringComparison.Ordinal) => "parallelism — thread skew",
+            _ when wt.StartsWith("CXSYNC", StringComparison.Ordinal) => "parallelism — exchange synchronization",
+            _ when wt == "HTBUILD" => "hash — building hash table",
+            _ when wt == "HTDELETE" => "hash — cleaning up hash table",
+            _ when wt == "HTREPARTITION" => "hash — repartitioning",
+            _ when wt.StartsWith("HT", StringComparison.Ordinal) => "hash operation",
+            _ when wt == "BPSORT" => "batch sort",
+            _ when wt == "BMPBUILD" => "bitmap filter build",
+            _ when wt.Contains("MEMORY_ALLOCATION_EXT", StringComparison.Ordinal) => "memory allocation",
+            _ when wt.StartsWith("PAGELATCH", StringComparison.Ordinal) => "page latch — in-memory contention",
+            _ when wt.StartsWith("LATCH_", StringComparison.Ordinal) => "latch contention",
+            _ when wt.StartsWith("LCK_", StringComparison.Ordinal) => "lock contention",
+            _ when wt == "LOGBUFFER" => "transaction log writes",
+            _ when wt == "ASYNC_NETWORK_IO" => "network — client not consuming results",
+            _ when wt == "SOS_PHYS_PAGE_CACHE" => "physical page cache contention",
+            _ => ""
+        };
+    }
+
     /// <summary>
     /// Returns targeted advice based on statement-level wait stats, or null if no waits.
     /// When the dominant wait type is clear, gives specific guidance instead of generic advice.
@@ -1552,29 +1670,150 @@ private static string Truncate(string value, int maxLength)
         var top = waits.OrderByDescending(w => w.WaitTimeMs).First();
         var topPct = (double)top.WaitTimeMs / totalMs * 100;
 
-        // Only give targeted advice if the dominant wait is >= 80% of total wait time
-        if (topPct < 80)
-            return null;
+        // Single dominant wait — give targeted advice
+        if (topPct >= 80)
+            return DescribeWaitType(top.WaitType, topPct);
+
+        // Multiple waits — summarize the top contributors instead of guessing
+        var topWaits = waits.OrderByDescending(w => w.WaitTimeMs).Take(3)
+            .Select(w => $"{w.WaitType} ({(double)w.WaitTimeMs / totalMs * 100:N0}%)")
+            .ToList();
+        return $"Top waits: {string.Join(", ", topWaits)}.";
+    }
 
-        var waitType = top.WaitType.ToUpperInvariant();
-        var advice = waitType switch
+    /// <summary>
+    /// Maps a wait type to a human-readable description with percentage context.
+    /// Covers all wait types observed in real execution plan files.
+    /// </summary>
+    private static string DescribeWaitType(string rawWaitType, double topPct)
+    {
+        var waitType = rawWaitType.ToUpperInvariant();
+        return waitType switch
         {
+            // I/O: reading/writing data pages from disk
             _ when waitType.StartsWith("PAGEIOLATCH", StringComparison.Ordinal) =>
-                $"I/O bound — {topPct:N0}% of wait time is {top.WaitType}. Data is being read from disk rather than memory. Consider adding indexes to reduce I/O, or investigate memory pressure.",
+                $"I/O bound — {topPct:N0}% of wait time is {rawWaitType}. Data is being read from disk rather than memory. Consider adding indexes to reduce I/O, or investigate memory pressure.",
+            _ when waitType.Contains("IO_COMPLETION", StringComparison.Ordinal) =>
+                $"I/O bound — {topPct:N0}% of wait time is {rawWaitType}. Non-buffer I/O such as sort/hash spills to TempDB or eager writes.",
+
+            // CPU: thread yielding its scheduler quantum
+            _ when waitType == "SOS_SCHEDULER_YIELD" =>
+                $"CPU bound — {topPct:N0}% of wait time is {rawWaitType}. The query is consuming significant CPU. Look for expensive operators (scans, sorts, hash builds) that could be eliminated or reduced.",
+
+            // Parallelism: exchange and synchronization waits
+            _ when waitType.StartsWith("CXPACKET", StringComparison.Ordinal) || waitType.StartsWith("CXCONSUMER", StringComparison.Ordinal) =>
+                $"Parallel thread skew — {topPct:N0}% of wait time is {rawWaitType}. Work is unevenly distributed across parallel threads.",
+            _ when waitType.StartsWith("CXSYNC", StringComparison.Ordinal) =>
+                $"Parallel synchronization — {topPct:N0}% of wait time is {rawWaitType}. Threads are waiting at exchange operators to synchronize parallel execution.",
+
+            // Hash operations
+            _ when waitType.StartsWith("HT", StringComparison.Ordinal) =>
+                $"Hash operation — {topPct:N0}% of wait time is {rawWaitType}. Time spent building, repartitioning, or cleaning up hash tables. Large hash builds may indicate missing indexes or bad row estimates.",
+
+            // Sort/bitmap batch operations
+            _ when waitType == "BPSORT" =>
+                $"Batch sort — {topPct:N0}% of wait time is {rawWaitType}. Time spent in batch-mode sort operations.",
+            _ when waitType == "BMPBUILD" =>
+                $"Bitmap build — {topPct:N0}% of wait time is {rawWaitType}. Time spent building bitmap filters for hash joins.",
+
+            // Memory allocation
+            _ when waitType.Contains("MEMORY_ALLOCATION_EXT", StringComparison.Ordinal) =>
+                $"Memory allocation — {topPct:N0}% of wait time is {rawWaitType}. Frequent memory allocations during query execution.",
+
+            // Latch contention (non-I/O)
+            _ when waitType.StartsWith("PAGELATCH", StringComparison.Ordinal) =>
+                $"Page latch contention — {topPct:N0}% of wait time is {rawWaitType}. In-memory page contention, often on TempDB or hot pages.",
             _ when waitType.StartsWith("LATCH_", StringComparison.Ordinal) =>
-                $"Latch contention — {topPct:N0}% of wait time is {top.WaitType}.",
+                $"Latch contention — {topPct:N0}% of wait time is {rawWaitType}.",
+
+            // Lock contention
             _ when waitType.StartsWith("LCK_", StringComparison.Ordinal) =>
-                $"Lock contention — {topPct:N0}% of wait time is {top.WaitType}. Other sessions are holding locks that this query needs.",
-            _ when waitType.StartsWith("CXPACKET", StringComparison.Ordinal) || waitType.StartsWith("CXCONSUMER", StringComparison.Ordinal) =>
-                $"Parallel thread skew — {topPct:N0}% of wait time is {top.WaitType}. Work is unevenly distributed across parallel threads.",
-            _ when waitType.Contains("IO_COMPLETION", StringComparison.Ordinal) =>
-                $"I/O bound — {topPct:N0}% of wait time is {top.WaitType}.",
-            _ when waitType.StartsWith("RESOURCE_SEMAPHORE", StringComparison.Ordinal) =>
-                $"Memory grant wait — {topPct:N0}% of wait time is {top.WaitType}. The query had to wait for a memory grant.",
-            _ => $"Dominant wait is {top.WaitType} ({topPct:N0}% of wait time)."
+                $"Lock contention — {topPct:N0}% of wait time is {rawWaitType}. Other sessions are holding locks that this query needs.",
+
+            // Log writes
+            _ when waitType == "LOGBUFFER" =>
+                $"Log write — {topPct:N0}% of wait time is {rawWaitType}. Waiting for transaction log buffer flushes, typically from data modifications.",
+
+            // Network
+            _ when waitType == "ASYNC_NETWORK_IO" =>
+                $"Network bound — {topPct:N0}% of wait time is {rawWaitType}. The client application is not consuming results fast enough.",
+
+            // Physical page cache
+            _ when waitType == "SOS_PHYS_PAGE_CACHE" =>
+                $"Physical page cache — {topPct:N0}% of wait time is {rawWaitType}. Contention on the physical memory page allocator.",
+
+            _ => $"Dominant wait is {rawWaitType} ({topPct:N0}% of wait time)."
         };
+    }
+
+    /// <summary>
+    /// Returns true if the statement has significant I/O waits (PAGEIOLATCH_*, IO_COMPLETION).
+    /// Used for severity elevation decisions where I/O specifically indicates disk access.
+    /// Thresholds: I/O waits >= 20% of total wait time AND >= 100ms absolute.
+    /// </summary>
+    private static bool HasSignificantIoWaits(List<WaitStatInfo> waits)
+    {
+        if (waits.Count == 0)
+            return false;
+
+        var totalMs = waits.Sum(w => w.WaitTimeMs);
+        if (totalMs == 0)
+            return false;
+
+        long ioMs = 0;
+        foreach (var w in waits)
+        {
+            var wt = w.WaitType.ToUpperInvariant();
+            if (wt.StartsWith("PAGEIOLATCH", StringComparison.Ordinal) || wt.Contains("IO_COMPLETION", StringComparison.Ordinal))
+                ioMs += w.WaitTimeMs;
+        }
+
+        var pct = (double)ioMs / totalMs * 100;
+        return ioMs >= 100 && pct >= 20;
+    }
 
-        return advice;
+    /// <summary>
+    /// Formats a node reference for use in warning messages. Includes object name
+    /// for data access operators where it helps identify which table is involved.
+    /// </summary>
+    private static string FormatNodeRef(PlanNode node)
+    {
+        if (!string.IsNullOrEmpty(node.ObjectName))
+        {
+            var objRef = !string.IsNullOrEmpty(node.DatabaseName)
+                ? $"{node.DatabaseName}.{node.ObjectName}"
+                : node.ObjectName;
+            return $"{node.PhysicalOp} on {objRef} (Node {node.NodeId})";
+        }
+
+        return $"{node.PhysicalOp} (Node {node.NodeId})";
+    }
+
+    /// <summary>
+    /// Identifies the specific cause of a row goal from the statement text.
+    /// Returns a specific cause when detectable, or a generic list as fallback.
+    /// </summary>
+    private static string IdentifyRowGoalCause(string stmtText)
+    {
+        if (string.IsNullOrEmpty(stmtText))
+            return "TOP, EXISTS, IN, or FAST hint";
+
+        var text = stmtText.ToUpperInvariant();
+        var causes = new List<string>(4);
+
+        if (Regex.IsMatch(text, @"\bTOP\b"))
+            causes.Add("TOP");
+        if (Regex.IsMatch(text, @"\bEXISTS\b"))
+            causes.Add("EXISTS");
+        // IN with subquery — bare "IN (" followed by SELECT, not just "IN (1,2,3)"
+        if (Regex.IsMatch(text, @"\bIN\s*\(\s*SELECT\b"))
+            causes.Add("IN (subquery)");
+        if (Regex.IsMatch(text, @"\bFAST\b"))
+            causes.Add("FAST hint");
+
+        return causes.Count > 0
+            ? string.Join(", ", causes)
+            : "TOP, EXISTS, IN, or FAST hint";
     }
 
     /// <summary>
diff --git a/Lite/Models/PlanModels.cs b/Lite/Models/PlanModels.cs
index 50a33927..beac9c79 100644
--- a/Lite/Models/PlanModels.cs
+++ b/Lite/Models/PlanModels.cs
@@ -61,6 +61,7 @@ public class PlanStatement
     public SetOptionsInfo? SetOptions { get; set; }
     public List<PlanParameter> Parameters { get; set; } = new();
     public List<WaitStatInfo> WaitStats { get; set; } = new();
+    public List<WaitBenefit> WaitBenefits { get; set; } = new();
     public QueryTimeInfo? QueryTimeStats { get; set; }
 
     // Wave 2: MaxQueryMemory + QueryPlan-level warnings
@@ -370,6 +371,17 @@ public class PlanWarning
     public string Message { get; set; } = "";
     public PlanWarningSeverity Severity { get; set; }
     public SpillDetail? SpillDetails { get; set; }
+
+    /// <summary>
+    /// Maximum percentage of elapsed time that could be saved by addressing this finding.
+    /// null = not quantifiable, 0 = calculated as negligible.
+    /// </summary>
+    public double? MaxBenefitPercent { get; set; }
+
+    /// <summary>
+    /// Short actionable fix suggestion (e.g., "Add INCLUDE (columns) to index").
+    /// </summary>
+    public string? ActionableFix { get; set; }
 }
 
 public enum PlanWarningSeverity { Info, Warning, Critical }
@@ -433,6 +445,13 @@ public class PlanParameter
     public string? RuntimeValue { get; set; }
 }
 
+public class WaitBenefit
+{
+    public string WaitType { get; set; } = "";
+    public double MaxBenefitPercent { get; set; }
+    public string Category { get; set; } = "";
+}
+
 public class WaitStatInfo
 {
     public string WaitType { get; set; } = "";
diff --git a/Lite/Services/BenefitScorer.cs b/Lite/Services/BenefitScorer.cs
new file mode 100644
index 00000000..a922c9b7
--- /dev/null
+++ b/Lite/Services/BenefitScorer.cs
@@ -0,0 +1,653 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using PerformanceMonitorLite.Models;
+
+namespace PerformanceMonitorLite.Services;
+
+/// <summary>
+/// Second-pass analysis that calculates MaxBenefitPercent for each PlanWarning.
+/// Runs after PlanAnalyzer.Analyze() — the analyzer creates findings, the scorer quantifies them.
+/// Benefit = maximum % of elapsed time that could be saved by addressing the finding.
+/// </summary>
+public static class BenefitScorer
+{
+    // Warning types that map to specific scoring strategies
+    private static readonly HashSet<string> OperatorTimeRules = new(StringComparer.OrdinalIgnoreCase)
+    {
+        "Filter Operator",      // Rule 1
+        "Eager Index Spool",    // Rule 2
+        "Spill",                // Rule 7
+        // Key Lookup / RID Lookup (Rule 10) handled separately by ScoreKeyLookupWarning
+        "Scan With Predicate",  // Rule 11
+        "Non-SARGable Predicate", // Rule 12
+        "Scan Cardinality Misestimate", // Rule 32
+    };
+
+    public static void Score(ParsedPlan plan)
+    {
+        foreach (var batch in plan.Batches)
+        {
+            foreach (var stmt in batch.Statements)
+            {
+                ScoreStatementWarnings(stmt);
+
+                if (stmt.RootNode != null)
+                    ScoreNodeTree(stmt.RootNode, stmt);
+
+                if (stmt.WaitStats.Count > 0 && stmt.QueryTimeStats != null)
+                    ScoreWaitStats(stmt);
+            }
+        }
+    }
+
+    private static void ScoreStatementWarnings(PlanStatement stmt)
+    {
+        var elapsedMs = stmt.QueryTimeStats?.ElapsedTimeMs ?? 0;
+
+        foreach (var warning in stmt.PlanWarnings)
+        {
+            switch (warning.WarningType)
+            {
+                case "Ineffective Parallelism":   // Rule 25
+                case "Parallel Wait Bottleneck":  // Rule 31
+                    // These are meta-findings about parallelism efficiency.
+                    // The benefit is the gap between actual and ideal elapsed time.
+                    if (elapsedMs > 0 && stmt.QueryTimeStats != null)
+                    {
+                        var cpu = stmt.QueryTimeStats.CpuTimeMs;
+                        var dop = stmt.DegreeOfParallelism;
+                        if (dop > 1 && cpu > 0)
+                        {
+                            // Ideal elapsed = CPU / DOP. Benefit = (actual - ideal) / actual
+                            var idealElapsed = (double)cpu / dop;
+                            var benefit = Math.Max(0, (elapsedMs - idealElapsed) / elapsedMs * 100);
+                            warning.MaxBenefitPercent = Math.Min(100, Math.Round(benefit, 1));
+                        }
+                    }
+                    break;
+
+                case "Serial Plan": // Rule 3
+                    // Can't know how fast a parallel plan would be, but estimate:
+                    // CPU-bound: benefit up to (1 - 1/maxDOP) * 100%
+                    if (elapsedMs > 0 && stmt.QueryTimeStats != null)
+                    {
+                        var cpu = stmt.QueryTimeStats.CpuTimeMs;
+                        // Assume server max DOP — use a conservative 4 if unknown
+                        var potentialDop = 4;
+                        if (cpu >= elapsedMs)
+                        {
+                            // CPU-bound: parallelism could help significantly
+                            var benefit = (1.0 - 1.0 / potentialDop) * 100;
+                            warning.MaxBenefitPercent = Math.Round(benefit, 1);
+                        }
+                        else
+                        {
+                            // Not CPU-bound: parallelism helps less
+                            var cpuRatio = (double)cpu / elapsedMs;
+                            var benefit = cpuRatio * (1.0 - 1.0 / potentialDop) * 100;
+                            warning.MaxBenefitPercent = Math.Round(Math.Min(50, benefit), 1);
+                        }
+                    }
+                    break;
+
+                case "Memory Grant": // Rule 9
+                    // Grant wait is the only part that affects this query's elapsed time
+                    if (elapsedMs > 0 && stmt.MemoryGrant?.GrantWaitTimeMs > 0)
+                    {
+                        var benefit = (double)stmt.MemoryGrant.GrantWaitTimeMs / elapsedMs * 100;
+                        warning.MaxBenefitPercent = Math.Round(Math.Min(100, benefit), 1);
+                    }
+                    break;
+
+                case "High Compile CPU": // Rule 19
+                    if (elapsedMs > 0 && stmt.CompileCPUMs > 0)
+                    {
+                        var benefit = (double)stmt.CompileCPUMs / elapsedMs * 100;
+                        warning.MaxBenefitPercent = Math.Round(Math.Min(100, benefit), 1);
+                    }
+                    break;
+
+                // Rules that cannot be quantified: leave MaxBenefitPercent as null
+                // Rule 18 (Compile Memory Exceeded), Rule 20 (Local Variables),
+                // Rule 27 (Optimize For Unknown)
+            }
+        }
+    }
+
+    private static void ScoreNodeTree(PlanNode node, PlanStatement stmt)
+    {
+        ScoreNodeWarnings(node, stmt);
+
+        foreach (var child in node.Children)
+            ScoreNodeTree(child, stmt);
+    }
+
+    private static void ScoreNodeWarnings(PlanNode node, PlanStatement stmt)
+    {
+        var elapsedMs = stmt.QueryTimeStats?.ElapsedTimeMs ?? 0;
+
+        foreach (var warning in node.Warnings)
+        {
+            // Already scored (e.g., by a different pass)
+            if (warning.MaxBenefitPercent != null)
+                continue;
+
+            if (warning.WarningType == "UDF Execution") // Rule 4
+            {
+                ScoreUdfWarning(warning, node, elapsedMs);
+            }
+            else if (warning.WarningType == "Filter Operator") // Rule 1
+            {
+                ScoreFilterWarning(warning, node, stmt);
+            }
+            else if (warning.WarningType == "Nested Loops High Executions") // Rule 16
+            {
+                ScoreNestedLoopsWarning(warning, node, stmt);
+            }
+            else if (warning.SpillDetails != null) // Rule 7
+            {
+                ScoreSpillWarning(warning, node, stmt);
+            }
+            else if (warning.WarningType is "Key Lookup" or "RID Lookup") // Rule 10
+            {
+                ScoreKeyLookupWarning(warning, node, stmt);
+            }
+            else if (OperatorTimeRules.Contains(warning.WarningType))
+            {
+                ScoreByOperatorTime(warning, node, stmt);
+            }
+            else if (warning.WarningType == "Row Estimate Mismatch") // Rule 5
+            {
+                ScoreEstimateMismatchWarning(warning, node, stmt);
+            }
+            // Rules that stay null: Scalar UDF (Rule 6, informational reference),
+            // Parallel Skew (Rule 8 — will be integrated per-operator later),
+            // Data Type Mismatch (Rule 13),
+            // Lazy Spool Ineffective (Rule 14), Join OR Clause (Rule 15),
+            // Many-to-Many Merge Join (Rule 17), CTE Multiple References (Rule 21),
+            // Table Variable (Rule 22), Table-Valued Function (Rule 23),
+            // Top Above Scan (Rule 24), Row Goal (Rule 26),
+            // NOT IN with Nullable Column (Rule 28), Implicit Conversion (Rule 29),
+            // Wide Index Suggestion (Rule 30), Estimated Plan CE Guess (Rule 33)
+        }
+    }
+
+    /// <summary>
+    /// Rule 4: UDF Execution — benefit is UDF elapsed time / statement elapsed.
+    /// </summary>
+    private static void ScoreUdfWarning(PlanWarning warning, PlanNode node, long stmtElapsedMs)
+    {
+        if (stmtElapsedMs > 0 && node.UdfElapsedTimeMs > 0)
+        {
+            var benefit = (double)node.UdfElapsedTimeMs / stmtElapsedMs * 100;
+            warning.MaxBenefitPercent = Math.Round(Math.Min(100, benefit), 1);
+        }
+    }
+
+    /// <summary>
+    /// Rule 1: Filter Operator — benefit is child subtree elapsed / statement elapsed.
+    /// The filter discards rows late; eliminating it means the child subtree work was unnecessary.
+    /// </summary>
+    private static void ScoreFilterWarning(PlanWarning warning, PlanNode node, PlanStatement stmt)
+    {
+        var stmtMs = stmt.QueryTimeStats?.ElapsedTimeMs ?? 0;
+
+        if (node.HasActualStats && stmtMs > 0 && node.Children.Count > 0)
+        {
+            var childElapsed = node.Children.Max(c => c.ActualElapsedMs);
+            var benefit = (double)childElapsed / stmtMs * 100;
+            warning.MaxBenefitPercent = Math.Round(Math.Min(100, benefit), 1);
+        }
+        else if (!node.HasActualStats && stmt.StatementSubTreeCost > 0 && node.Children.Count > 0)
+        {
+            // Estimated plan fallback: child subtree cost / statement cost
+            var childCost = node.Children.Sum(c => c.EstimatedTotalSubtreeCost);
+            var benefit = childCost / stmt.StatementSubTreeCost * 100;
+            warning.MaxBenefitPercent = Math.Round(Math.Min(100, benefit), 1);
+        }
+    }
+
+    /// <summary>
+    /// Rule 16: Nested Loops High Executions — benefit is inner-side elapsed / statement elapsed.
+    /// </summary>
+    private static void ScoreNestedLoopsWarning(PlanWarning warning, PlanNode node, PlanStatement stmt)
+    {
+        var stmtMs = stmt.QueryTimeStats?.ElapsedTimeMs ?? 0;
+
+        if (node.Children.Count >= 2)
+        {
+            var innerChild = node.Children[1];
+
+            if (innerChild.HasActualStats && stmtMs > 0 && innerChild.ActualElapsedMs > 0)
+            {
+                var benefit = (double)innerChild.ActualElapsedMs / stmtMs * 100;
+                warning.MaxBenefitPercent = Math.Round(Math.Min(100, benefit), 1);
+            }
+            else if (!innerChild.HasActualStats && stmt.StatementSubTreeCost > 0)
+            {
+                var benefit = innerChild.EstimatedTotalSubtreeCost / stmt.StatementSubTreeCost * 100;
+                warning.MaxBenefitPercent = Math.Round(Math.Min(100, benefit), 1);
+            }
+        }
+    }
+
+    /// <summary>
+    /// Rule 7: Spill — benefit is the spilling operator's self-time / statement elapsed.
+    /// Exchange spills use the parallelism operator time (unreliable but best we have).
+    /// </summary>
+    private static void ScoreSpillWarning(PlanWarning warning, PlanNode node, PlanStatement stmt)
+    {
+        var stmtMs = stmt.QueryTimeStats?.ElapsedTimeMs ?? 0;
+        if (stmtMs <= 0) return;
+
+        long operatorMs;
+        if (warning.SpillDetails?.SpillType == "Exchange")
+            operatorMs = GetParallelismOperatorElapsedMs(node);
+        else
+            operatorMs = PlanAnalyzer.GetOperatorOwnElapsedMs(node);
+
+        if (operatorMs > 0)
+        {
+            var benefit = (double)operatorMs / stmtMs * 100;
+            warning.MaxBenefitPercent = Math.Round(Math.Min(100, benefit), 1);
+        }
+    }
+
+    /// <summary>
+    /// Generic operator-time scoring for rules where the fix would eliminate or
+    /// drastically reduce the operator's work: Key Lookup, RID Lookup,
+    /// Scan With Predicate, Non-SARGable Predicate, Eager Index Spool,
+    /// Scan Cardinality Misestimate.
+    /// </summary>
+    private static void ScoreByOperatorTime(PlanWarning warning, PlanNode node, PlanStatement stmt)
+    {
+        var stmtMs = stmt.QueryTimeStats?.ElapsedTimeMs ?? 0;
+
+        if (node.HasActualStats && stmtMs > 0)
+        {
+            var operatorMs = PlanAnalyzer.GetOperatorOwnElapsedMs(node);
+            if (operatorMs > 0)
+            {
+                var benefit = (double)operatorMs / stmtMs * 100;
+                warning.MaxBenefitPercent = Math.Round(Math.Min(100, benefit), 1);
+            }
+            else
+            {
+                // Operator self-time is 0 — negligible benefit
+                warning.MaxBenefitPercent = 0;
+            }
+        }
+        else if (!node.HasActualStats && stmt.StatementSubTreeCost > 0)
+        {
+            // Estimated plan fallback: use operator cost percentage
+            var benefit = (double)node.CostPercent;
+            warning.MaxBenefitPercent = Math.Round(Math.Min(100, benefit), 1);
+        }
+    }
+
+    /// <summary>
+    /// Rule 10: Key Lookup / RID Lookup — benefit includes the lookup operator's time,
+    /// plus the parent Nested Loops join when the NL only exists to drive the lookup
+    /// (inner child is the lookup, outer child is a seek/scan with no subtree).
+    /// </summary>
+    private static void ScoreKeyLookupWarning(PlanWarning warning, PlanNode node, PlanStatement stmt)
+    {
+        var stmtMs = stmt.QueryTimeStats?.ElapsedTimeMs ?? 0;
+
+        if (node.HasActualStats && stmtMs > 0)
+        {
+            var operatorMs = PlanAnalyzer.GetOperatorOwnElapsedMs(node);
+
+            // Check if the parent NL join is purely a lookup driver:
+            // - Parent is Nested Loops
+            // - Has exactly 2 children
+            // - This node (the lookup) is the inner child (index 1)
+            // - The outer child (index 0) is a simple seek/scan with no children
+            var parent = node.Parent;
+            if (parent != null
+                && parent.PhysicalOp == "Nested Loops"
+                && parent.Children.Count == 2
+                && parent.Children[1] == node
+                && parent.Children[0].Children.Count == 0)
+            {
+                operatorMs += PlanAnalyzer.GetOperatorOwnElapsedMs(parent);
+            }
+
+            if (operatorMs > 0)
+            {
+                var benefit = (double)operatorMs / stmtMs * 100;
+                warning.MaxBenefitPercent = Math.Round(Math.Min(100, benefit), 1);
+            }
+            else
+            {
+                warning.MaxBenefitPercent = 0;
+            }
+        }
+        else if (!node.HasActualStats && stmt.StatementSubTreeCost > 0)
+        {
+            var benefit = (double)node.CostPercent;
+            // Same parent-NL logic for estimated plans
+            var parent = node.Parent;
+            if (parent != null
+                && parent.PhysicalOp == "Nested Loops"
+                && parent.Children.Count == 2
+                && parent.Children[1] == node
+                && parent.Children[0].Children.Count == 0)
+            {
+                benefit += parent.CostPercent;
+            }
+            warning.MaxBenefitPercent = Math.Round(Math.Min(100, benefit), 1);
+        }
+    }
+
+    /// <summary>
+    /// Rule 5: Row Estimate Mismatch — benefit is the harmed operator's time.
+    /// If the mismatch caused a spill, benefit = spilling operator time.
+    /// If it caused a bad join choice, benefit = join operator time.
+    /// Otherwise, benefit is the misestimated operator's own time (conservative).
+    /// </summary>
+    private static void ScoreEstimateMismatchWarning(PlanWarning warning, PlanNode node, PlanStatement stmt)
+    {
+        var stmtMs = stmt.QueryTimeStats?.ElapsedTimeMs ?? 0;
+        if (stmtMs <= 0 || !node.HasActualStats) return;
+
+        // Walk up to find the harmed operator (same logic as AssessEstimateHarm)
+        var harmedNode = FindHarmedOperator(node);
+        if (harmedNode != null)
+        {
+            var operatorMs = PlanAnalyzer.GetOperatorOwnElapsedMs(harmedNode);
+            if (operatorMs > 0)
+            {
+                var benefit = (double)operatorMs / stmtMs * 100;
+                warning.MaxBenefitPercent = Math.Round(Math.Min(100, benefit), 1);
+                return;
+            }
+        }
+
+        // Fallback: use the misestimated node's own time
+        var ownMs = PlanAnalyzer.GetOperatorOwnElapsedMs(node);
+        if (ownMs > 0)
+        {
+            var benefit = (double)ownMs / stmtMs * 100;
+            warning.MaxBenefitPercent = Math.Round(Math.Min(100, benefit), 1);
+        }
+    }
+
+    /// <summary>
+    /// Walks up from a node with a bad row estimate to find the operator that was
+    /// harmed by it (spilling sort/hash, or join that chose the wrong strategy).
+    /// Returns null if no specific harm can be attributed.
+    /// </summary>
+    private static PlanNode? FindHarmedOperator(PlanNode node)
+    {
+        // The node itself has a spill — it harmed itself
+        if (node.Warnings.Any(w => w.SpillDetails != null))
+            return node;
+
+        // Walk up through transparent operators
+        var ancestor = node.Parent;
+        while (ancestor != null)
+        {
+            if (ancestor.PhysicalOp == "Parallelism" ||
+                ancestor.PhysicalOp == "Compute Scalar" ||
+                ancestor.PhysicalOp == "Segment" ||
+                ancestor.PhysicalOp == "Sequence Project" ||
+                ancestor.PhysicalOp == "Top" ||
+                ancestor.PhysicalOp == "Filter")
+            {
+                ancestor = ancestor.Parent;
+                continue;
+            }
+
+            // Parent join — bad row count from below caused wrong join choice
+            if (ancestor.LogicalOp.Contains("Join", StringComparison.OrdinalIgnoreCase))
+            {
+                if (ancestor.IsAdaptive)
+                    return null; // Adaptive join self-corrects
+                return ancestor;
+            }
+
+            // Parent Sort/Hash that spilled
+            if (ancestor.Warnings.Any(w => w.SpillDetails != null))
+                return ancestor;
+
+            // Parent Sort/Hash with no spill — benign
+            if (ancestor.PhysicalOp.Contains("Sort", StringComparison.OrdinalIgnoreCase) ||
+                ancestor.PhysicalOp.Contains("Hash", StringComparison.OrdinalIgnoreCase))
+                return null;
+
+            break;
+        }
+
+        return null;
+    }
+
+    /// <summary>
+    /// Calculates a Parallelism (exchange) operator's own elapsed time.
+    /// Mirrors PlanAnalyzer.GetParallelismOperatorElapsedMs but accessible here.
+    /// </summary>
+    private static long GetParallelismOperatorElapsedMs(PlanNode node)
+    {
+        if (node.Children.Count == 0)
+            return node.ActualElapsedMs;
+
+        if (node.PerThreadStats.Count > 1)
+            return PlanAnalyzer.GetOperatorOwnElapsedMs(node);
+
+        var maxChildElapsed = node.Children.Max(c => c.ActualElapsedMs);
+        return Math.Max(0, node.ActualElapsedMs - maxChildElapsed);
+    }
+
+    // ---------------------------------------------------------------
+    //  Stage 2: Wait Stats Benefit
+    // ---------------------------------------------------------------
+
+    /// <summary>
+    /// Calculates MaxBenefitPercent for each wait type in the statement's wait stats.
+    /// Serial plans: simple ratio of wait time to elapsed time.
+    /// Parallel plans: proportional allocation across relevant operators (Joe's formula).
+    /// </summary>
+    private static void ScoreWaitStats(PlanStatement stmt)
+    {
+        var elapsedMs = stmt.QueryTimeStats!.ElapsedTimeMs;
+        if (elapsedMs <= 0) return;
+
+        var isParallel = stmt.DegreeOfParallelism > 1 && stmt.RootNode != null;
+
+        // Collect all operators with per-thread stats for parallel benefit calculation
+        List<OperatorWaitProfile>? operatorProfiles = null;
+        if (isParallel)
+        {
+            operatorProfiles = new List<OperatorWaitProfile>();
+            CollectOperatorWaitProfiles(stmt.RootNode!, operatorProfiles);
+        }
+
+        foreach (var wait in stmt.WaitStats)
+        {
+            if (wait.WaitTimeMs <= 0) continue;
+
+            var category = ClassifyWaitType(wait.WaitType);
+            double benefitPct;
+
+            if (category == "Parallelism" && isParallel)
+            {
+                // CXPACKET/CXCONSUMER/CXSYNC: benefit is the parallelism efficiency gap,
+                // not the raw wait time. Threads waiting for other threads is a symptom
+                // of imperfect parallelism, not directly addressable time.
+                var cpu = stmt.QueryTimeStats!.CpuTimeMs;
+                var dop = stmt.DegreeOfParallelism;
+                if (cpu > 0 && dop > 1)
+                {
+                    var idealElapsed = (double)cpu / dop;
+                    benefitPct = Math.Max(0, (elapsedMs - idealElapsed) / elapsedMs * 100);
+                }
+                else
+                {
+                    benefitPct = (double)wait.WaitTimeMs / elapsedMs * 100;
+                }
+            }
+            else if (!isParallel || operatorProfiles == null || operatorProfiles.Count == 0)
+            {
+                // Serial plan or no operator data: simple ratio
+                benefitPct = (double)wait.WaitTimeMs / elapsedMs * 100;
+            }
+            else
+            {
+                // Parallel plan: proportional allocation across relevant operators
+                benefitPct = CalculateParallelWaitBenefit(wait, category, operatorProfiles, elapsedMs);
+            }
+
+            stmt.WaitBenefits.Add(new WaitBenefit
+            {
+                WaitType = wait.WaitType,
+                MaxBenefitPercent = Math.Round(Math.Min(100, Math.Max(0, benefitPct)), 1),
+                Category = category
+            });
+        }
+    }
+
+    /// <summary>
+    /// Parallel wait benefit using Joe's formula:
+    /// benefit = (SUM relevant operator max waits) * (total_wait_for_type) / (SUM relevant operator total waits)
+    /// Then convert to % of statement elapsed time.
+    /// </summary>
+    private static double CalculateParallelWaitBenefit(
+        WaitStatInfo wait, string category,
+        List<OperatorWaitProfile> profiles, long stmtElapsedMs)
+    {
+        // Filter to operators relevant for this wait category
+        var relevant = new List<OperatorWaitProfile>();
+        foreach (var p in profiles)
+        {
+            if (IsOperatorRelevantForCategory(p, category))
+                relevant.Add(p);
+        }
+
+        // If no operators match, fall back to simple ratio
+        if (relevant.Count == 0)
+            return (double)wait.WaitTimeMs / stmtElapsedMs * 100;
+
+        // Joe's formula:
+        // sum_max = SUM of each relevant operator's max per-thread wait time
+        // sum_total = SUM of each relevant operator's total wait time across all threads
+        // benefit_ms = sum_max * wait.WaitTimeMs / sum_total
+        double sumMax = 0;
+        double sumTotal = 0;
+        foreach (var p in relevant)
+        {
+            sumMax += p.MaxThreadWaitMs;
+            sumTotal += p.TotalWaitMs;
+        }
+
+        if (sumTotal <= 0)
+            return (double)wait.WaitTimeMs / stmtElapsedMs * 100;
+
+        var benefitMs = sumMax * wait.WaitTimeMs / sumTotal;
+        return benefitMs / stmtElapsedMs * 100;
+    }
+
+    /// <summary>
+    /// Determines if an operator is relevant for a given wait category.
+    /// </summary>
+    private static bool IsOperatorRelevantForCategory(OperatorWaitProfile profile, string category)
+    {
+        return category switch
+        {
+            "I/O" => profile.HasPhysicalReads,
+            "CPU" => profile.HasCpuWork,
+            "Parallelism" => profile.IsExchange,
+            "Hash" => profile.IsHashOperator,
+            "Sort" => profile.IsSortOperator,
+            "Latch" => profile.HasTempDbActivity,
+            "Lock" => true,  // any operator can be blocked by locks
+            "Network" => false,  // ASYNC_NETWORK_IO is client-side, not attributable to operators
+            "Memory" => false,  // memory waits are statement-level
+            _ => true,  // unknown category: include all operators
+        };
+    }
+
+    /// <summary>
+    /// Walks the operator tree and collects wait time profiles for each operator.
+    /// Wait time per thread = max(0, elapsed - cpu) for that thread.
+    /// </summary>
+    private static void CollectOperatorWaitProfiles(PlanNode node, List<OperatorWaitProfile> profiles)
+    {
+        if (node.HasActualStats && node.PerThreadStats.Count > 0)
+        {
+            long maxThreadWait = 0;
+            long totalWait = 0;
+
+            foreach (var ts in node.PerThreadStats)
+            {
+                var threadWait = Math.Max(0, ts.ActualElapsedMs - ts.ActualCPUMs);
+                totalWait += threadWait;
+                if (threadWait > maxThreadWait)
+                    maxThreadWait = threadWait;
+            }
+
+            if (totalWait > 0 || maxThreadWait > 0)
+            {
+                profiles.Add(new OperatorWaitProfile
+                {
+                    Node = node,
+                    MaxThreadWaitMs = maxThreadWait,
+                    TotalWaitMs = totalWait,
+                    HasPhysicalReads = node.ActualPhysicalReads > 0,
+                    HasCpuWork = node.ActualCPUMs > 0,
+                    IsExchange = node.PhysicalOp == "Parallelism",
+                    IsHashOperator = node.PhysicalOp.StartsWith("Hash", StringComparison.OrdinalIgnoreCase),
+                    IsSortOperator = node.PhysicalOp.StartsWith("Sort", StringComparison.OrdinalIgnoreCase),
+                    HasTempDbActivity = node.Warnings.Any(w => w.SpillDetails != null)
+                                     || node.PhysicalOp.Contains("Spool", StringComparison.OrdinalIgnoreCase)
+                });
+            }
+        }
+
+        foreach (var child in node.Children)
+            CollectOperatorWaitProfiles(child, profiles);
+    }
+
+    /// <summary>
+    /// Classifies a wait type into a category for operator-to-wait mapping.
+    /// </summary>
+    internal static string ClassifyWaitType(string waitType)
+    {
+        var wt = waitType.ToUpperInvariant();
+        return wt switch
+        {
+            _ when wt.StartsWith("PAGEIOLATCH") => "I/O",
+            _ when wt.Contains("IO_COMPLETION") => "I/O",
+            _ when wt.StartsWith("WRITELOG") => "I/O",
+            _ when wt == "SOS_SCHEDULER_YIELD" => "CPU",
+            _ when wt.StartsWith("CXPACKET") || wt.StartsWith("CXCONSUMER") => "Parallelism",
+            _ when wt.StartsWith("CXSYNC") => "Parallelism",
+            _ when wt.StartsWith("HT") => "Hash",
+            _ when wt == "BPSORT" => "Sort",
+            _ when wt == "BMPBUILD" => "Hash",
+            _ when wt.StartsWith("PAGELATCH") => "Latch",
+            _ when wt.StartsWith("LATCH_") => "Latch",
+            _ when wt.StartsWith("LCK_") => "Lock",
+            _ when wt == "ASYNC_NETWORK_IO" => "Network",
+            _ when wt.Contains("MEMORY_ALLOCATION") => "Memory",
+            _ when wt == "SOS_PHYS_PAGE_CACHE" => "Memory",
+            _ => "Other"
+        };
+    }
+
+    /// <summary>
+    /// Per-operator wait time profile used for parallel benefit allocation.
+    /// </summary>
+    private sealed class OperatorWaitProfile
+    {
+        public PlanNode Node { get; init; } = null!;
+        public long MaxThreadWaitMs { get; init; }
+        public long TotalWaitMs { get; init; }
+        public bool HasPhysicalReads { get; init; }
+        public bool HasCpuWork { get; init; }
+        public bool IsExchange { get; init; }
+        public bool IsHashOperator { get; init; }
+        public bool IsSortOperator { get; init; }
+        public bool HasTempDbActivity { get; init; }
+    }
+}
diff --git a/Lite/Services/PlanAnalyzer.cs b/Lite/Services/PlanAnalyzer.cs
index 866def3b..29d0a3d6 100644
--- a/Lite/Services/PlanAnalyzer.cs
+++ b/Lite/Services/PlanAnalyzer.cs
@@ -179,16 +179,24 @@ private static void AnalyzeStatement(PlanStatement stmt)
                 });
             }
 
-            // Large memory grant with sort/hash guidance
+            // Large memory grant with top consumers
             if (grant.GrantedMemoryKB >= 1048576 && stmt.RootNode != null)
             {
                 var consumers = new List<string>();
                 FindMemoryConsumers(stmt.RootNode, consumers);
 
                 var grantMB = grant.GrantedMemoryKB / 1024.0;
-                var guidance = consumers.Count > 0
-                    ? $" Memory consumers: {string.Join(", ", consumers)}. Check whether these operators are processing more rows than necessary."
-                    : "";
+                var guidance = "";
+                if (consumers.Count > 0)
+                {
+                    // Show only the top 3 consumers — listing 20+ is noise
+                    var shown = consumers.Take(3);
+                    var remaining = consumers.Count - 3;
+                    guidance = $" Largest consumers: {string.Join(", ", shown)}";
+                    if (remaining > 0)
+                        guidance += $", and {remaining} more";
+                    guidance += ".";
+                }
 
                 stmt.PlanWarnings.Add(new PlanWarning
                 {
@@ -517,7 +525,8 @@ private static void AnalyzeNode(PlanNode node, PlanStatement stmt)
         // - A parent join may have chosen the wrong strategy
         // - Root nodes with no parent to harm are skipped
         // - Nodes whose only parents are Parallelism/Top/Sort (no spill) are skipped
-        if (node.HasActualStats && node.EstimateRows > 0)
+        if (node.HasActualStats && node.EstimateRows > 0
+            && !node.Lookup) // Key lookups are point lookups (1 row per execution) — per-execution estimate is misleading
         {
             if (node.ActualRows == 0)
             {
@@ -642,11 +651,29 @@ private static void AnalyzeNode(PlanNode node, PlanStatement stmt)
                 var skewThreshold = workerThreads.Count <= 2 ? 0.80 : 0.50;
                 if (skewRatio >= skewThreshold)
                 {
+                    var message = $"Thread {maxThread.ThreadId} processed {skewRatio:P0} of rows ({maxThread.ActualRows:N0}/{totalRows:N0}). Work is heavily skewed to one thread, so parallelism isn't helping much.";
+                    var severity = PlanWarningSeverity.Warning;
+
+                    // Batch mode sorts produce all output on a single thread by design
+                    // unless their parent is a batch mode Window Aggregate
+                    if (node.PhysicalOp == "Sort"
+                        && (node.ActualExecutionMode ?? node.ExecutionMode) == "Batch"
+                        && node.Parent?.PhysicalOp != "Window Aggregate")
+                    {
+                        message += " Batch mode sorts produce all output rows on a single thread by design, unless feeding a batch mode Window Aggregate.";
+                        severity = PlanWarningSeverity.Info;
+                    }
+                    else
+                    {
+                        // Add practical context — skew is often hard to fix
+                        message += " Common causes: uneven data distribution across partitions or hash buckets, or a scan/seek whose predicate sends most rows to one range. Reducing DOP or rewriting the query to avoid the skewed operation may help.";
+                    }
+
                     node.Warnings.Add(new PlanWarning
                     {
                         WarningType = "Parallel Skew",
-                        Message = $"Thread {maxThread.ThreadId} processed {skewRatio:P0} of rows ({maxThread.ActualRows:N0}/{totalRows:N0}). Work is heavily skewed to one thread, so parallelism isn't helping much.",
-                        Severity = PlanWarningSeverity.Warning
+                        Message = message,
+                        Severity = severity
                     });
                 }
             }
@@ -667,18 +694,37 @@ private static void AnalyzeNode(PlanNode node, PlanStatement stmt)
                 Severity = PlanWarningSeverity.Warning
             });
         }
-        else if (node.Lookup && !string.IsNullOrEmpty(node.Predicate))
+        else if (node.Lookup)
         {
+            var lookupMsg = "Key Lookup — SQL Server found rows via a nonclustered index but had to go back to the clustered index for additional columns.";
+
+            // Show what columns the lookup is fetching
+            if (!string.IsNullOrEmpty(node.OutputColumns))
+                lookupMsg += $"\nColumns fetched: {Truncate(node.OutputColumns, 200)}";
+
+            // Only call out the predicate if it actually filters rows
+            if (!string.IsNullOrEmpty(node.Predicate))
+            {
+                var predicateFilters = node.HasActualStats && node.ActualExecutions > 0
+                    && node.ActualRows < node.ActualExecutions;
+                if (predicateFilters)
+                    lookupMsg += $"\nResidual predicate (filtered {node.ActualExecutions - node.ActualRows:N0} rows): {Truncate(node.Predicate, 200)}";
+            }
+
+            lookupMsg += "\nTo eliminate the lookup, consider adding the needed columns as INCLUDE columns on the nonclustered index. This widens the index, so weigh the read benefit against write and storage overhead.";
+
             node.Warnings.Add(new PlanWarning
             {
                 WarningType = "Key Lookup",
-                Message = $"Key Lookup — SQL Server found rows via a nonclustered index but had to go back to the clustered index for additional columns. Alter the nonclustered index to add the predicate column as a key column or as an INCLUDE column.\nPredicate: {Truncate(node.Predicate, 200)}",
+                Message = lookupMsg,
                 Severity = PlanWarningSeverity.Critical
             });
         }
 
         // Rule 12: Non-SARGable predicate on scan
-        var nonSargableReason = DetectNonSargablePredicate(node);
+        // Skip for 0-execution nodes — the operator never ran, so the warning is academic
+        var nonSargableReason = (node.HasActualStats && node.ActualExecutions == 0)
+            ? null : DetectNonSargablePredicate(node);
         if (nonSargableReason != null)
         {
             var nonSargableAdvice = nonSargableReason switch
@@ -707,19 +753,30 @@ _ when nonSargableReason.StartsWith("Function call", StringComparison.OrdinalIgn
 
         // Rule 11: Scan with residual predicate (skip if non-SARGable already flagged)
         // A PROBE() alone is just a bitmap filter — not a real residual predicate.
+        // Skip for 0-execution nodes — the operator never ran
         if (nonSargableReason == null && IsRowstoreScan(node) && !string.IsNullOrEmpty(node.Predicate) &&
-            !IsProbeOnly(node.Predicate))
+            !IsProbeOnly(node.Predicate) && !(node.HasActualStats && node.ActualExecutions == 0))
         {
             var displayPredicate = StripProbeExpressions(node.Predicate);
             var details = BuildScanImpactDetails(node, stmt);
             var severity = PlanWarningSeverity.Warning;
+
+            // Elevate to Critical if the scan dominates the plan
             if (details.CostPct >= 90 || details.ElapsedPct >= 90)
                 severity = PlanWarningSeverity.Critical;
+
             var message = "Scan with residual predicate — SQL Server is reading every row and filtering after the fact.";
             if (!string.IsNullOrEmpty(details.Summary))
                 message += $" {details.Summary}";
             message += " Check that you have appropriate indexes.";
+
+            // I/O waits specifically confirm the scan is hitting disk — elevate
+            if (HasSignificantIoWaits(stmt.WaitStats) && details.CostPct >= 50
+                && severity != PlanWarningSeverity.Critical)
+                severity = PlanWarningSeverity.Critical;
+
             message += $"\nPredicate: {Truncate(displayPredicate, 200)}";
+
             node.Warnings.Add(new PlanWarning
             {
                 WarningType = "Scan With Predicate",
@@ -804,7 +861,8 @@ _ when nonSargableReason.StartsWith("Function call", StringComparison.OrdinalIgn
 
         // Rule 14: Lazy Table Spool unfavorable rebind/rewind ratio
         // Rebinds = cache misses (child re-executes), rewinds = cache hits (reuse cached result)
-        if (node.LogicalOp == "Lazy Spool" && !node.PhysicalOp.Contains("Index", StringComparison.OrdinalIgnoreCase))
+        if (node.LogicalOp == "Lazy Spool"
+            && !node.PhysicalOp.Contains("Index", StringComparison.OrdinalIgnoreCase))
         {
             var rebinds = node.HasActualStats ? (double)node.ActualRebinds : node.EstimateRebinds;
             var rewinds = node.HasActualStats ? (double)node.ActualRewinds : node.EstimateRewinds;
@@ -994,7 +1052,7 @@ _ when nonSargableReason.StartsWith("Function call", StringComparison.OrdinalIgn
                     node.Warnings.Add(new PlanWarning
                     {
                         WarningType = "Top Above Scan",
-                        Message = $"{topLabel} reads from {scanCandidate.PhysicalOp} (Node {scanCandidate.NodeId}).{innerNote}{predInfo} An index on the ORDER BY columns could eliminate the scan and sort entirely.",
+                        Message = $"{topLabel} reads from {FormatNodeRef(scanCandidate)}.{innerNote}{predInfo} An index on the ORDER BY columns could eliminate the scan and sort entirely.",
                         Severity = onInner ? PlanWarningSeverity.Critical : PlanWarningSeverity.Warning
                     });
                 }
@@ -1013,12 +1071,28 @@ _ when nonSargableReason.StartsWith("Function call", StringComparison.OrdinalIgn
             // tiny floating-point differences that display identically are noise
             if (reduction >= 2.0)
             {
-                node.Warnings.Add(new PlanWarning
+                // If we have actual stats, check whether the row goal prediction was correct.
+                // When actual rows <= the row goal estimate, the optimizer stopped early as planned — benign.
+                var rowGoalWorked = false;
+                if (node.HasActualStats)
                 {
-                    WarningType = "Row Goal",
-                    Message = $"Row goal active: estimate reduced from {node.EstimateRowsWithoutRowGoal:N0} to {node.EstimateRows:N0} ({reduction:N0}x reduction) due to TOP, EXISTS, IN, or FAST hint. The optimizer chose this plan shape expecting to stop reading early. If the query reads all rows anyway, the plan choice may be suboptimal.",
-                    Severity = PlanWarningSeverity.Info
-                });
+                    var executions = node.ActualExecutions > 0 ? node.ActualExecutions : 1;
+                    var actualPerExec = (double)node.ActualRows / executions;
+                    rowGoalWorked = actualPerExec <= node.EstimateRows;
+                }
+
+                if (!rowGoalWorked)
+                {
+                    // Try to identify the specific row goal cause from the statement text
+                    var cause = IdentifyRowGoalCause(stmt.StatementText);
+
+                    node.Warnings.Add(new PlanWarning
+                    {
+                        WarningType = "Row Goal",
+                        Message = $"Row goal active: estimate reduced from {node.EstimateRowsWithoutRowGoal:N0} to {node.EstimateRows:N0} ({reduction:N0}x reduction) due to {cause}. The optimizer chose this plan shape expecting to stop reading early. If the query reads all rows anyway, the plan choice may be suboptimal.",
+                        Severity = PlanWarningSeverity.Info
+                    });
+                }
             }
         }
 
@@ -1040,9 +1114,11 @@ _ when nonSargableReason.StartsWith("Function call", StringComparison.OrdinalIgn
         }
 
         // Rule 29: Enhance implicit conversion warnings — Seek Plan is more severe
+        // Skip for 0-execution nodes — the operator never ran
+        if (!(node.HasActualStats && node.ActualExecutions == 0))
         foreach (var w in node.Warnings.ToList())
         {
-            if (w.WarningType == "Implicit Conversion" && w.Message.StartsWith("Seek Plan", StringComparison.Ordinal))
+            if (w.WarningType == "Implicit Conversion" && w.Message.StartsWith("Seek Plan"))
             {
                 w.Severity = PlanWarningSeverity.Critical;
                 w.Message = $"Implicit conversion prevented an index seek, forcing a scan instead. Fix the data type mismatch: ensure the parameter or variable type matches the column type exactly. {w.Message}";
@@ -1267,25 +1343,37 @@ private static bool IsOrExpansionChain(PlanNode concatenationNode)
     /// Finds Sort and Hash Match operators in the tree that consume memory.
     /// </summary>
     private static void FindMemoryConsumers(PlanNode node, List<string> consumers)
+    {
+        // Collect all consumers first, then sort by row count descending
+        var raw = new List<(string Label, double Rows)>();
+        FindMemoryConsumersRecursive(node, raw);
+
+        foreach (var (label, _) in raw.OrderByDescending(c => c.Rows))
+            consumers.Add(label);
+    }
+
+    private static void FindMemoryConsumersRecursive(PlanNode node, List<(string Label, double Rows)> consumers)
     {
         if (node.PhysicalOp.Contains("Sort", StringComparison.OrdinalIgnoreCase) &&
             !node.PhysicalOp.Contains("Spool", StringComparison.OrdinalIgnoreCase))
         {
+            var rowCount = node.HasActualStats ? node.ActualRows : node.EstimateRows;
             var rows = node.HasActualStats
                 ? $"{node.ActualRows:N0} actual rows"
                 : $"{node.EstimateRows:N0} estimated rows";
-            consumers.Add($"Sort (Node {node.NodeId}, {rows})");
+            consumers.Add(($"Sort (Node {node.NodeId}, {rows})", rowCount));
         }
         else if (node.PhysicalOp.Contains("Hash", StringComparison.OrdinalIgnoreCase))
         {
+            var rowCount = node.HasActualStats ? node.ActualRows : node.EstimateRows;
             var rows = node.HasActualStats
                 ? $"{node.ActualRows:N0} actual rows"
                 : $"{node.EstimateRows:N0} estimated rows";
-            consumers.Add($"Hash Match (Node {node.NodeId}, {rows})");
+            consumers.Add(($"Hash Match (Node {node.NodeId}, {rows})", rowCount));
         }
 
         foreach (var child in node.Children)
-            FindMemoryConsumers(child, consumers);
+            FindMemoryConsumersRecursive(child, consumers);
     }
 
     /// <summary>
@@ -1297,7 +1385,7 @@ private static void FindMemoryConsumers(PlanNode node, List<string> consumers)
     /// Exchange operators accumulate downstream wait time (e.g. from spilling
     /// children) so their self-time is unreliable — see sql.kiwi/2021/03.
     /// </summary>
-    private static long GetOperatorOwnElapsedMs(PlanNode node)
+    internal static long GetOperatorOwnElapsedMs(PlanNode node)
     {
         if (node.ActualExecutionMode == "Batch")
             return node.ActualElapsedMs;
@@ -1535,6 +1623,37 @@ private static string Truncate(string value, int maxLength)
         return value.Length <= maxLength ? value : value[..maxLength] + "...";
     }
 
+    /// <summary>
+    /// Returns a short label describing what a wait type means (e.g., "I/O — reading from disk").
+    /// Public for use by UI components that annotate wait stats inline.
+    /// </summary>
+    public static string GetWaitLabel(string waitType)
+    {
+        var wt = waitType.ToUpperInvariant();
+        return wt switch
+        {
+            _ when wt.StartsWith("PAGEIOLATCH", StringComparison.Ordinal) => "I/O — reading data from disk",
+            _ when wt.Contains("IO_COMPLETION", StringComparison.Ordinal) => "I/O — spills to TempDB or eager writes",
+            _ when wt == "SOS_SCHEDULER_YIELD" => "CPU — scheduler yielding",
+            _ when wt.StartsWith("CXPACKET", StringComparison.Ordinal) || wt.StartsWith("CXCONSUMER", StringComparison.Ordinal) => "parallelism — thread skew",
+            _ when wt.StartsWith("CXSYNC", StringComparison.Ordinal) => "parallelism — exchange synchronization",
+            _ when wt == "HTBUILD" => "hash — building hash table",
+            _ when wt == "HTDELETE" => "hash — cleaning up hash table",
+            _ when wt == "HTREPARTITION" => "hash — repartitioning",
+            _ when wt.StartsWith("HT", StringComparison.Ordinal) => "hash operation",
+            _ when wt == "BPSORT" => "batch sort",
+            _ when wt == "BMPBUILD" => "bitmap filter build",
+            _ when wt.Contains("MEMORY_ALLOCATION_EXT", StringComparison.Ordinal) => "memory allocation",
+            _ when wt.StartsWith("PAGELATCH", StringComparison.Ordinal) => "page latch — in-memory contention",
+            _ when wt.StartsWith("LATCH_", StringComparison.Ordinal) => "latch contention",
+            _ when wt.StartsWith("LCK_", StringComparison.Ordinal) => "lock contention",
+            _ when wt == "LOGBUFFER" => "transaction log writes",
+            _ when wt == "ASYNC_NETWORK_IO" => "network — client not consuming results",
+            _ when wt == "SOS_PHYS_PAGE_CACHE" => "physical page cache contention",
+            _ => ""
+        };
+    }
+
     /// <summary>
     /// Returns targeted advice based on statement-level wait stats, or null if no waits.
     /// When the dominant wait type is clear, gives specific guidance instead of generic advice.
@@ -1551,29 +1670,150 @@ private static string Truncate(string value, int maxLength)
         var top = waits.OrderByDescending(w => w.WaitTimeMs).First();
         var topPct = (double)top.WaitTimeMs / totalMs * 100;
 
-        // Only give targeted advice if the dominant wait is >= 80% of total wait time
-        if (topPct < 80)
-            return null;
+        // Single dominant wait — give targeted advice
+        if (topPct >= 80)
+            return DescribeWaitType(top.WaitType, topPct);
+
+        // Multiple waits — summarize the top contributors instead of guessing
+        var topWaits = waits.OrderByDescending(w => w.WaitTimeMs).Take(3)
+            .Select(w => $"{w.WaitType} ({(double)w.WaitTimeMs / totalMs * 100:N0}%)")
+            .ToList();
+        return $"Top waits: {string.Join(", ", topWaits)}.";
+    }
 
-        var waitType = top.WaitType.ToUpperInvariant();
-        var advice = waitType switch
+    /// <summary>
+    /// Maps a wait type to a human-readable description with percentage context.
+    /// Covers all wait types observed in real execution plan files.
+    /// </summary>
+    private static string DescribeWaitType(string rawWaitType, double topPct)
+    {
+        var waitType = rawWaitType.ToUpperInvariant();
+        return waitType switch
         {
+            // I/O: reading/writing data pages from disk
             _ when waitType.StartsWith("PAGEIOLATCH", StringComparison.Ordinal) =>
-                $"I/O bound — {topPct:N0}% of wait time is {top.WaitType}. Data is being read from disk rather than memory. Consider adding indexes to reduce I/O, or investigate memory pressure.",
+                $"I/O bound — {topPct:N0}% of wait time is {rawWaitType}. Data is being read from disk rather than memory. Consider adding indexes to reduce I/O, or investigate memory pressure.",
+            _ when waitType.Contains("IO_COMPLETION", StringComparison.Ordinal) =>
+                $"I/O bound — {topPct:N0}% of wait time is {rawWaitType}. Non-buffer I/O such as sort/hash spills to TempDB or eager writes.",
+
+            // CPU: thread yielding its scheduler quantum
+            _ when waitType == "SOS_SCHEDULER_YIELD" =>
+                $"CPU bound — {topPct:N0}% of wait time is {rawWaitType}. The query is consuming significant CPU. Look for expensive operators (scans, sorts, hash builds) that could be eliminated or reduced.",
+
+            // Parallelism: exchange and synchronization waits
+            _ when waitType.StartsWith("CXPACKET", StringComparison.Ordinal) || waitType.StartsWith("CXCONSUMER", StringComparison.Ordinal) =>
+                $"Parallel thread skew — {topPct:N0}% of wait time is {rawWaitType}. Work is unevenly distributed across parallel threads.",
+            _ when waitType.StartsWith("CXSYNC", StringComparison.Ordinal) =>
+                $"Parallel synchronization — {topPct:N0}% of wait time is {rawWaitType}. Threads are waiting at exchange operators to synchronize parallel execution.",
+
+            // Hash operations
+            _ when waitType.StartsWith("HT", StringComparison.Ordinal) =>
+                $"Hash operation — {topPct:N0}% of wait time is {rawWaitType}. Time spent building, repartitioning, or cleaning up hash tables. Large hash builds may indicate missing indexes or bad row estimates.",
+
+            // Sort/bitmap batch operations
+            _ when waitType == "BPSORT" =>
+                $"Batch sort — {topPct:N0}% of wait time is {rawWaitType}. Time spent in batch-mode sort operations.",
+            _ when waitType == "BMPBUILD" =>
+                $"Bitmap build — {topPct:N0}% of wait time is {rawWaitType}. Time spent building bitmap filters for hash joins.",
+
+            // Memory allocation
+            _ when waitType.Contains("MEMORY_ALLOCATION_EXT", StringComparison.Ordinal) =>
+                $"Memory allocation — {topPct:N0}% of wait time is {rawWaitType}. Frequent memory allocations during query execution.",
+
+            // Latch contention (non-I/O)
+            _ when waitType.StartsWith("PAGELATCH", StringComparison.Ordinal) =>
+                $"Page latch contention — {topPct:N0}% of wait time is {rawWaitType}. In-memory page contention, often on TempDB or hot pages.",
             _ when waitType.StartsWith("LATCH_", StringComparison.Ordinal) =>
-                $"Latch contention — {topPct:N0}% of wait time is {top.WaitType}.",
+                $"Latch contention — {topPct:N0}% of wait time is {rawWaitType}.",
+
+            // Lock contention
             _ when waitType.StartsWith("LCK_", StringComparison.Ordinal) =>
-                $"Lock contention — {topPct:N0}% of wait time is {top.WaitType}. Other sessions are holding locks that this query needs.",
-            _ when waitType.StartsWith("CXPACKET", StringComparison.Ordinal) || waitType.StartsWith("CXCONSUMER", StringComparison.Ordinal) =>
-                $"Parallel thread skew — {topPct:N0}% of wait time is {top.WaitType}. Work is unevenly distributed across parallel threads.",
-            _ when waitType.Contains("IO_COMPLETION", StringComparison.Ordinal) =>
-                $"I/O bound — {topPct:N0}% of wait time is {top.WaitType}.",
-            _ when waitType.StartsWith("RESOURCE_SEMAPHORE", StringComparison.Ordinal) =>
-                $"Memory grant wait — {topPct:N0}% of wait time is {top.WaitType}. The query had to wait for a memory grant.",
-            _ => $"Dominant wait is {top.WaitType} ({topPct:N0}% of wait time)."
+                $"Lock contention — {topPct:N0}% of wait time is {rawWaitType}. Other sessions are holding locks that this query needs.",
+
+            // Log writes
+            _ when waitType == "LOGBUFFER" =>
+                $"Log write — {topPct:N0}% of wait time is {rawWaitType}. Waiting for transaction log buffer flushes, typically from data modifications.",
+
+            // Network
+            _ when waitType == "ASYNC_NETWORK_IO" =>
+                $"Network bound — {topPct:N0}% of wait time is {rawWaitType}. The client application is not consuming results fast enough.",
+
+            // Physical page cache
+            _ when waitType == "SOS_PHYS_PAGE_CACHE" =>
+                $"Physical page cache — {topPct:N0}% of wait time is {rawWaitType}. Contention on the physical memory page allocator.",
+
+            _ => $"Dominant wait is {rawWaitType} ({topPct:N0}% of wait time)."
         };
+    }
+
+    /// <summary>
+    /// Returns true if the statement has significant I/O waits (PAGEIOLATCH_*, IO_COMPLETION).
+    /// Used for severity elevation decisions where I/O specifically indicates disk access.
+    /// Thresholds: I/O waits >= 20% of total wait time AND >= 100ms absolute.
+    /// </summary>
+    private static bool HasSignificantIoWaits(List<WaitStatInfo> waits)
+    {
+        if (waits.Count == 0)
+            return false;
+
+        var totalMs = waits.Sum(w => w.WaitTimeMs);
+        if (totalMs == 0)
+            return false;
+
+        long ioMs = 0;
+        foreach (var w in waits)
+        {
+            var wt = w.WaitType.ToUpperInvariant();
+            if (wt.StartsWith("PAGEIOLATCH", StringComparison.Ordinal) || wt.Contains("IO_COMPLETION", StringComparison.Ordinal))
+                ioMs += w.WaitTimeMs;
+        }
+
+        var pct = (double)ioMs / totalMs * 100;
+        return ioMs >= 100 && pct >= 20;
+    }
 
-        return advice;
+    /// <summary>
+    /// Formats a node reference for use in warning messages. Includes object name
+    /// for data access operators where it helps identify which table is involved.
+    /// </summary>
+    private static string FormatNodeRef(PlanNode node)
+    {
+        if (!string.IsNullOrEmpty(node.ObjectName))
+        {
+            var objRef = !string.IsNullOrEmpty(node.DatabaseName)
+                ? $"{node.DatabaseName}.{node.ObjectName}"
+                : node.ObjectName;
+            return $"{node.PhysicalOp} on {objRef} (Node {node.NodeId})";
+        }
+
+        return $"{node.PhysicalOp} (Node {node.NodeId})";
+    }
+
+    /// <summary>
+    /// Identifies the specific cause of a row goal from the statement text.
+    /// Returns a specific cause when detectable, or a generic list as fallback.
+    /// </summary>
+    private static string IdentifyRowGoalCause(string stmtText)
+    {
+        if (string.IsNullOrEmpty(stmtText))
+            return "TOP, EXISTS, IN, or FAST hint";
+
+        var text = stmtText.ToUpperInvariant();
+        var causes = new List<string>(4);
+
+        if (Regex.IsMatch(text, @"\bTOP\b"))
+            causes.Add("TOP");
+        if (Regex.IsMatch(text, @"\bEXISTS\b"))
+            causes.Add("EXISTS");
+        // IN with subquery — bare "IN (" followed by SELECT, not just "IN (1,2,3)"
+        if (Regex.IsMatch(text, @"\bIN\s*\(\s*SELECT\b"))
+            causes.Add("IN (subquery)");
+        if (Regex.IsMatch(text, @"\bFAST\b"))
+            causes.Add("FAST hint");
+
+        return causes.Count > 0
+            ? string.Join(", ", causes)
+            : "TOP, EXISTS, IN, or FAST hint";
     }
 
     /// <summary>

From 3e950a5c68c8014ead31be3847e5332e9a02a4f4 Mon Sep 17 00:00:00 2001
From: Erik Darling <2136037+erikdarlingdata@users.noreply.github.com>
Date: Fri, 17 Apr 2026 08:55:45 -0400
Subject: [PATCH 12/49] Fall back to single-database mode when Azure master is
 inaccessible (#857)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

On Azure SQL DB, some logins (e.g. Microsoft Dynamics 365 FO) are granted
access only to a specific user database and not to master. The three
collectors that enumerate databases via master — query_stats,
database_size_stats, file_io_stats — would fail the first time and
produce an empty screen.

GetAzureDatabaseListAsync now catches known access-denied/login-failed
errors from the master connection, caches the per-server decision, and
returns the connection's InitialCatalog as a single-element list. The
three callers already loop per-database, so single-DB mode works without
further changes.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
---
 Lite/Services/RemoteCollectorService.cs | 95 ++++++++++++++++++++++---
 1 file changed, 85 insertions(+), 10 deletions(-)

diff --git a/Lite/Services/RemoteCollectorService.cs b/Lite/Services/RemoteCollectorService.cs
index aa2918f3..c3564a71 100644
--- a/Lite/Services/RemoteCollectorService.cs
+++ b/Lite/Services/RemoteCollectorService.cs
@@ -102,6 +102,14 @@ public partial class RemoteCollectorService
     private int _logInsertFailures;
     private string? _lastLogInsertError;
 
+    /// <summary>
+    /// Per-server flag indicating that master DB enumeration has failed with an access-denied
+    /// error and should not be retried. Used on Azure SQL DB where per-database logins may not
+    /// have master access (e.g. Microsoft Dynamics 365 FO). See issue #857.
+    /// </summary>
+    private readonly Dictionary<int, bool> _azureMasterInaccessible = new();
+    private readonly object _azureMasterInaccessibleLock = new();
+
     public RemoteCollectorService(
         DuckDbInitializer duckDb,
         ServerManager serverManager,
@@ -561,10 +569,30 @@ INSERT INTO collection_log (log_id, server_id, server_name, collector_name, coll
     /// Enumerates online databases on an Azure SQL DB logical server.
     /// HAS_DBACCESS() returns false for user databases from master on Azure SQL DB,
     /// so we skip that filter — inaccessible databases should be handled by callers via try/catch.
+    ///
+    /// On Azure SQL DB, logins are sometimes granted access only to a specific user database and
+    /// not to master (e.g. Microsoft Dynamics 365 FO). In that case, master enumeration fails with
+    /// an access/login error; we fall back to returning the connection's initial catalog as a
+    /// single-database list, and cache that decision per server so we don't retry master each cycle.
+    /// See issue #857.
     /// </summary>
     protected async Task<List<string>> GetAzureDatabaseListAsync(ServerConnection server, CancellationToken cancellationToken)
     {
+        var serverId = GetServerId(server);
         var baseConnStr = server.GetConnectionString(_serverManager.CredentialService);
+        var targetDb = new SqlConnectionStringBuilder(baseConnStr).InitialCatalog;
+
+        bool knownInaccessible;
+        lock (_azureMasterInaccessibleLock)
+        {
+            _azureMasterInaccessible.TryGetValue(serverId, out knownInaccessible);
+        }
+
+        if (knownInaccessible)
+        {
+            return SingleDbOrEmpty(targetDb);
+        }
+
         var connStr = new SqlConnectionStringBuilder(baseConnStr)
         {
             ConnectTimeout = ConnectionTimeoutSeconds,
@@ -572,16 +600,63 @@ protected async Task<List<string>> GetAzureDatabaseListAsync(ServerConnection se
         }.ConnectionString;
 
         var databases = new List<string>();
-        using var conn = new SqlConnection(connStr);
-        await conn.OpenAsync(cancellationToken);
-        using var cmd = new SqlCommand(
-            "SELECT name FROM sys.databases WHERE state_desc = N'ONLINE' AND database_id > 0 ORDER BY name;",
-            conn)
-        { CommandTimeout = CommandTimeoutSeconds };
-        using var reader = await cmd.ExecuteReaderAsync(cancellationToken);
-        while (await reader.ReadAsync(cancellationToken))
-            databases.Add(reader.GetString(0));
-        return databases;
+        try
+        {
+            using var conn = new SqlConnection(connStr);
+            await conn.OpenAsync(cancellationToken);
+            using var cmd = new SqlCommand(
+                "SELECT name FROM sys.databases WHERE state_desc = N'ONLINE' AND database_id > 0 ORDER BY name;",
+                conn)
+            { CommandTimeout = CommandTimeoutSeconds };
+            using var reader = await cmd.ExecuteReaderAsync(cancellationToken);
+            while (await reader.ReadAsync(cancellationToken))
+                databases.Add(reader.GetString(0));
+            return databases;
+        }
+        catch (SqlException ex) when (IsMasterAccessDeniedError(ex))
+        {
+            lock (_azureMasterInaccessibleLock)
+            {
+                _azureMasterInaccessible[serverId] = true;
+            }
+
+            var fallback = SingleDbOrEmpty(targetDb);
+            if (fallback.Count > 0)
+            {
+                AppLogger.Info("Collector", $"  [{server.DisplayName}] master DB inaccessible (SQL error {ex.Number}) — collecting from '{targetDb}' only.");
+            }
+            else
+            {
+                AppLogger.Warn("Collector", $"  [{server.DisplayName}] master DB inaccessible (SQL error {ex.Number}) and no target database in connection string — no data will be collected for database-scoped collectors.");
+            }
+            return fallback;
+        }
+    }
+
+    private static List<string> SingleDbOrEmpty(string? targetDb)
+    {
+        if (string.IsNullOrEmpty(targetDb) || string.Equals(targetDb, "master", StringComparison.OrdinalIgnoreCase))
+            return new List<string>();
+        return new List<string> { targetDb };
+    }
+
+    /// <summary>
+    /// Error numbers indicating the login cannot open or read from master on Azure SQL DB.
+    /// Trigger a fallback to single-database mode when we see one of these.
+    /// </summary>
+    private static bool IsMasterAccessDeniedError(SqlException ex)
+    {
+        return ex.Number switch
+        {
+            229   => true, // Permission denied on object
+            230   => true, // Permission denied on column
+            916   => true, // Server principal is not able to access the database under the current security context
+            4060  => true, // Cannot open database requested by the login
+            18456 => true, // Login failed for user
+            40613 => true, // Database 'master' on server is not currently available
+            40615 => true, // Cannot open server — login denied (firewall/auth)
+            _     => false
+        };
     }
 
     /// <summary>

From 694ead6290d7c9c4c38d6f80b2b865571e7a9959 Mon Sep 17 00:00:00 2001
From: Erik Darling <2136037+erikdarlingdata@users.noreply.github.com>
Date: Fri, 17 Apr 2026 11:03:02 -0400
Subject: [PATCH 13/49] Add nonclustered indexes for query/procedure/query
 store lookups
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Phase 3 OUTER APPLY hydration of compressed query_text/plan_text was forcing
an Eager Index Spool over the full collect.query_stats table (and similar
for procedure_stats / query_store_data), which took 104 seconds on a
742K-row table in #835.

Changes:
- Remove CONVERT(binary(8), nvarchar-hash, 1) anti-pattern from OUTER APPLY
  WHERE clauses by keeping query_hash as native binary(8) in temp tables.
  query_hash is only converted to nvarchar(20) in the final output projection.
- Add three nonclustered indexes (install script and upgrade script):
    IX_query_stats_hash_lookup (query_hash, database_name, collection_time DESC)
    IX_procedure_stats_name_lookup (database_name, schema_name, object_name, collection_time DESC)
    IX_query_store_data_id_lookup (database_name, query_id, collection_time DESC)
- Indexes use SORT_IN_TEMPDB = ON and DATA_COMPRESSION = PAGE.
- ONLINE = ON is applied conditionally via dynamic SQL based on
  SERVERPROPERTY('EngineEdition') — Enterprise/Developer/Azure only, since
  Standard/Web/Express don't support online index operations.

Tested against CADelete's 742K-row table: Phase 3 went from 104s to
well under 1s (5s total for the full three-phase query).

Fixes #835

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
---
 .../DatabaseService.QueryPerformance.cs       | 14 +--
 install/02_create_tables.sql                  | 78 +++++++++++++++
 .../01_add_query_lookup_indexes.sql           | 98 +++++++++++++++++++
 upgrades/2.7.0-to-2.8.0/upgrade.txt           |  1 +
 4 files changed, 184 insertions(+), 7 deletions(-)
 create mode 100644 upgrades/2.7.0-to-2.8.0/01_add_query_lookup_indexes.sql
 create mode 100644 upgrades/2.7.0-to-2.8.0/upgrade.txt

diff --git a/Dashboard/Services/DatabaseService.QueryPerformance.cs b/Dashboard/Services/DatabaseService.QueryPerformance.cs
index 7f5f0e27..9ca0fec5 100644
--- a/Dashboard/Services/DatabaseService.QueryPerformance.cs
+++ b/Dashboard/Services/DatabaseService.QueryPerformance.cs
@@ -1123,7 +1123,7 @@ USE HINT('ENABLE_PARALLEL_PLAN_PREFERENCE')
 
         SELECT TOP (500)
             database_name = pl.database_name,
-            query_hash = CONVERT(nvarchar(20), pl.query_hash, 1),
+            query_hash = pl.query_hash,
             object_type = MAX(pl.object_type),
             object_name =
                 CASE MAX(pl.object_type)
@@ -1180,7 +1180,7 @@ HASH GROUP
         /*Phase 3: hydrate text and plan XML for the TOP 500 winners only*/
         SELECT
             tr.database_name,
-            tr.query_hash,
+            query_hash = CONVERT(nvarchar(20), tr.query_hash, 1),
             tr.object_type,
             tr.object_name,
             tr.first_execution_time,
@@ -1224,7 +1224,7 @@ OUTER APPLY
             SELECT TOP (1)
                 query_text = CAST(DECOMPRESS(qs2.query_text) AS nvarchar(max))
             FROM collect.query_stats AS qs2
-            WHERE qs2.query_hash = CONVERT(binary(8), tr.query_hash, 1)
+            WHERE qs2.query_hash = tr.query_hash
             AND   qs2.database_name = tr.database_name
             ORDER BY qs2.collection_time DESC
         ) AS qt
@@ -1233,7 +1233,7 @@ OUTER APPLY
             SELECT TOP (1)
                 query_plan_xml = CAST(DECOMPRESS(qs3.query_plan_text) AS nvarchar(max))
             FROM collect.query_stats AS qs3
-            WHERE qs3.query_hash = CONVERT(binary(8), tr.query_hash, 1)
+            WHERE qs3.query_hash = tr.query_hash
             AND   qs3.database_name = tr.database_name
             AND   qs3.query_plan_text IS NOT NULL
             ORDER BY qs3.collection_time DESC
@@ -4379,7 +4379,7 @@ USE HINT('ENABLE_PARALLEL_PLAN_PREFERENCE')
 
 SELECT TOP (@top + 5)
     database_name = pl.database_name,
-    query_hash = CONVERT(nvarchar(20), pl.query_hash, 1),
+    query_hash = pl.query_hash,
     object_type = MAX(pl.object_type),
     object_name =
         CASE MAX(pl.object_type)
@@ -4438,7 +4438,7 @@ HASH GROUP
 /*Phase 3: hydrate text for winners only, apply WAITFOR filter*/
 SELECT TOP (@top)
     tr.database_name,
-    tr.query_hash,
+    query_hash = CONVERT(nvarchar(20), tr.query_hash, 1),
     tr.object_type,
     tr.object_name,
     tr.first_execution_time,
@@ -4481,7 +4481,7 @@ OUTER APPLY
     SELECT TOP (1)
         query_text = CAST(DECOMPRESS(qs2.query_text) AS nvarchar(max))
     FROM collect.query_stats AS qs2
-    WHERE qs2.query_hash = CONVERT(binary(8), tr.query_hash, 1)
+    WHERE qs2.query_hash = tr.query_hash
     AND   qs2.database_name = tr.database_name
     ORDER BY qs2.collection_time DESC
 ) AS qt
diff --git a/install/02_create_tables.sql b/install/02_create_tables.sql
index 2a94183b..9cd74877 100644
--- a/install/02_create_tables.sql
+++ b/install/02_create_tables.sql
@@ -1495,5 +1495,83 @@ BEGIN
     PRINT 'Created collect.server_properties table';
 END;
 
+/*
+Nonclustered indexes to support OUTER APPLY lookups in the Dashboard's
+query/procedure/query store grid queries. Without these, the optimizer builds
+an Eager Index Spool over the entire table to service the lookups, which can
+take minutes on large installations (see #835).
+
+ONLINE = ON is only supported on Enterprise/Developer/Azure editions. The
+options string is built dynamically based on SERVERPROPERTY('EngineEdition').
+*/
+DECLARE @online_option nvarchar(20) =
+    CASE
+        WHEN CAST(SERVERPROPERTY(N'EngineEdition') AS integer) IN (3, 5, 8)
+        THEN N', ONLINE = ON'
+        ELSE N''
+    END;
+
+DECLARE @index_sql nvarchar(max);
+
+IF NOT EXISTS
+(
+    SELECT
+        1/0
+    FROM sys.indexes
+    WHERE object_id = OBJECT_ID(N'collect.query_stats')
+    AND   name = N'IX_query_stats_hash_lookup'
+)
+BEGIN
+    SET @index_sql = N'
+    CREATE NONCLUSTERED INDEX
+        IX_query_stats_hash_lookup
+    ON collect.query_stats
+        (query_hash, database_name, collection_time DESC)
+    WITH
+        (SORT_IN_TEMPDB = ON, DATA_COMPRESSION = PAGE' + @online_option + N');';
+    EXEC sys.sp_executesql @index_sql;
+    PRINT 'Created collect.query_stats.IX_query_stats_hash_lookup index';
+END;
+
+IF NOT EXISTS
+(
+    SELECT
+        1/0
+    FROM sys.indexes
+    WHERE object_id = OBJECT_ID(N'collect.procedure_stats')
+    AND   name = N'IX_procedure_stats_name_lookup'
+)
+BEGIN
+    SET @index_sql = N'
+    CREATE NONCLUSTERED INDEX
+        IX_procedure_stats_name_lookup
+    ON collect.procedure_stats
+        (database_name, schema_name, object_name, collection_time DESC)
+    WITH
+        (SORT_IN_TEMPDB = ON, DATA_COMPRESSION = PAGE' + @online_option + N');';
+    EXEC sys.sp_executesql @index_sql;
+    PRINT 'Created collect.procedure_stats.IX_procedure_stats_name_lookup index';
+END;
+
+IF NOT EXISTS
+(
+    SELECT
+        1/0
+    FROM sys.indexes
+    WHERE object_id = OBJECT_ID(N'collect.query_store_data')
+    AND   name = N'IX_query_store_data_id_lookup'
+)
+BEGIN
+    SET @index_sql = N'
+    CREATE NONCLUSTERED INDEX
+        IX_query_store_data_id_lookup
+    ON collect.query_store_data
+        (database_name, query_id, collection_time DESC)
+    WITH
+        (SORT_IN_TEMPDB = ON, DATA_COMPRESSION = PAGE' + @online_option + N');';
+    EXEC sys.sp_executesql @index_sql;
+    PRINT 'Created collect.query_store_data.IX_query_store_data_id_lookup index';
+END;
+
 PRINT 'All collection tables created successfully';
 GO
diff --git a/upgrades/2.7.0-to-2.8.0/01_add_query_lookup_indexes.sql b/upgrades/2.7.0-to-2.8.0/01_add_query_lookup_indexes.sql
new file mode 100644
index 00000000..698aff92
--- /dev/null
+++ b/upgrades/2.7.0-to-2.8.0/01_add_query_lookup_indexes.sql
@@ -0,0 +1,98 @@
+/*
+Copyright 2026 Darling Data, LLC
+https://www.erikdarling.com/
+
+Upgrade from 2.7.0 to 2.8.0
+
+Add nonclustered indexes on collect.query_stats, collect.procedure_stats, and
+collect.query_store_data to support OUTER APPLY lookups in the Dashboard's
+grid queries. Without these, the optimizer builds an Eager Index Spool over
+the entire table to service the lookups, which can take minutes on large
+installations (see #835).
+
+ONLINE = ON is only supported on Enterprise/Developer/Azure editions. The
+options string is built dynamically based on SERVERPROPERTY('EngineEdition').
+*/
+
+SET ANSI_NULLS ON;
+SET ANSI_PADDING ON;
+SET ANSI_WARNINGS ON;
+SET ARITHABORT ON;
+SET CONCAT_NULL_YIELDS_NULL ON;
+SET QUOTED_IDENTIFIER ON;
+SET NUMERIC_ROUNDABORT OFF;
+SET IMPLICIT_TRANSACTIONS OFF;
+SET STATISTICS TIME, IO OFF;
+GO
+
+USE PerformanceMonitor;
+GO
+
+DECLARE @online_option nvarchar(20) =
+    CASE
+        WHEN CAST(SERVERPROPERTY(N'EngineEdition') AS integer) IN (3, 5, 8)
+        THEN N', ONLINE = ON'
+        ELSE N''
+    END;
+
+DECLARE @index_sql nvarchar(max);
+
+IF NOT EXISTS
+(
+    SELECT
+        1/0
+    FROM sys.indexes
+    WHERE object_id = OBJECT_ID(N'collect.query_stats')
+    AND   name = N'IX_query_stats_hash_lookup'
+)
+BEGIN
+    SET @index_sql = N'
+    CREATE NONCLUSTERED INDEX
+        IX_query_stats_hash_lookup
+    ON collect.query_stats
+        (query_hash, database_name, collection_time DESC)
+    WITH
+        (SORT_IN_TEMPDB = ON, DATA_COMPRESSION = PAGE' + @online_option + N');';
+    EXEC sys.sp_executesql @index_sql;
+    PRINT 'Created collect.query_stats.IX_query_stats_hash_lookup index';
+END;
+
+IF NOT EXISTS
+(
+    SELECT
+        1/0
+    FROM sys.indexes
+    WHERE object_id = OBJECT_ID(N'collect.procedure_stats')
+    AND   name = N'IX_procedure_stats_name_lookup'
+)
+BEGIN
+    SET @index_sql = N'
+    CREATE NONCLUSTERED INDEX
+        IX_procedure_stats_name_lookup
+    ON collect.procedure_stats
+        (database_name, schema_name, object_name, collection_time DESC)
+    WITH
+        (SORT_IN_TEMPDB = ON, DATA_COMPRESSION = PAGE' + @online_option + N');';
+    EXEC sys.sp_executesql @index_sql;
+    PRINT 'Created collect.procedure_stats.IX_procedure_stats_name_lookup index';
+END;
+
+IF NOT EXISTS
+(
+    SELECT
+        1/0
+    FROM sys.indexes
+    WHERE object_id = OBJECT_ID(N'collect.query_store_data')
+    AND   name = N'IX_query_store_data_id_lookup'
+)
+BEGIN
+    SET @index_sql = N'
+    CREATE NONCLUSTERED INDEX
+        IX_query_store_data_id_lookup
+    ON collect.query_store_data
+        (database_name, query_id, collection_time DESC)
+    WITH
+        (SORT_IN_TEMPDB = ON, DATA_COMPRESSION = PAGE' + @online_option + N');';
+    EXEC sys.sp_executesql @index_sql;
+    PRINT 'Created collect.query_store_data.IX_query_store_data_id_lookup index';
+END;
diff --git a/upgrades/2.7.0-to-2.8.0/upgrade.txt b/upgrades/2.7.0-to-2.8.0/upgrade.txt
new file mode 100644
index 00000000..8c221a3a
--- /dev/null
+++ b/upgrades/2.7.0-to-2.8.0/upgrade.txt
@@ -0,0 +1 @@
+01_add_query_lookup_indexes.sql

From a5829ba9576f70dbe42e8c437a0453bf1f6e268d Mon Sep 17 00:00:00 2001
From: Erik Darling <2136037+erikdarlingdata@users.noreply.github.com>
Date: Sat, 18 Apr 2026 10:25:01 -0400
Subject: [PATCH 14/49] Scope query snapshots to current database on Azure SQL
 DB (#857)

On Azure SQL Database, logins without access to master can't resolve
cross-database rows returned by sys.dm_exec_requests, which caused the
Live Snapshot button and the query snapshots collector to error in
D365FO-style environments (reported by @TrudAX in #857 after PR #858).

BuildQuerySnapshotsQuery now takes an isAzureSqlDatabase flag and emits
AND der.database_id = DB_ID() only when true. Boxed SQL Server, MI, and
elastic pool behavior is unchanged. The Live Snapshot button path gets
the flag through a new ServerTab constructor parameter wired from the
cached ServerConnectionStatus.SqlEngineEdition.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
---
 Lite/Controls/ServerTab.xaml.cs               |  6 ++++--
 Lite/MainWindow.xaml.cs                       |  2 +-
 .../RemoteCollectorService.QuerySnapshots.cs  | 21 ++++++++++++++-----
 3 files changed, 21 insertions(+), 8 deletions(-)

diff --git a/Lite/Controls/ServerTab.xaml.cs b/Lite/Controls/ServerTab.xaml.cs
index 6035727d..caeabfed 100644
--- a/Lite/Controls/ServerTab.xaml.cs
+++ b/Lite/Controls/ServerTab.xaml.cs
@@ -112,6 +112,7 @@ public partial class ServerTab : UserControl
 
     public int UtcOffsetMinutes { get; }
     private readonly bool _hasMsdbAccess;
+    private readonly bool _isAzureSqlDatabase;
 
     /// <summary>
     /// Raised after each data refresh with alert counts for tab badge display.
@@ -120,7 +121,7 @@ public partial class ServerTab : UserControl
     public event Action<int>? ApplyTimeRangeRequested; /* selectedIndex */
     public event Func<Task>? ManualRefreshRequested;
 
-    public ServerTab(ServerConnection server, DuckDbInitializer duckDb, CredentialService credentialService, int utcOffsetMinutes = 0, bool hasMsdbAccess = true)
+    public ServerTab(ServerConnection server, DuckDbInitializer duckDb, CredentialService credentialService, int utcOffsetMinutes = 0, bool hasMsdbAccess = true, bool isAzureSqlDatabase = false)
     {
         InitializeComponent();
 
@@ -130,6 +131,7 @@ public ServerTab(ServerConnection server, DuckDbInitializer duckDb, CredentialSe
         _credentialService = credentialService;
         UtcOffsetMinutes = utcOffsetMinutes;
         _hasMsdbAccess = hasMsdbAccess;
+        _isAzureSqlDatabase = isAzureSqlDatabase;
         ServerTimeHelper.UtcOffsetMinutes = utcOffsetMinutes;
 
         ServerNameText.Text = server.ReadOnlyIntent ? $"{server.DisplayName} (Read-Only)" : server.DisplayName;
@@ -5137,7 +5139,7 @@ private async void LiveSnapshot_Click(object sender, RoutedEventArgs e)
                 ConnectTimeout = 15
             };
 
-            var query = RemoteCollectorService.BuildQuerySnapshotsQuery(supportsLiveQueryPlan: true);
+            var query = RemoteCollectorService.BuildQuerySnapshotsQuery(supportsLiveQueryPlan: true, isAzureSqlDatabase: _isAzureSqlDatabase);
 
             await using var connection = new SqlConnection(builder.ConnectionString);
             await connection.OpenAsync();
diff --git a/Lite/MainWindow.xaml.cs b/Lite/MainWindow.xaml.cs
index 0573ada5..21e15930 100644
--- a/Lite/MainWindow.xaml.cs
+++ b/Lite/MainWindow.xaml.cs
@@ -523,7 +523,7 @@ private async void ConnectToServer(ServerConnection server)
         }
 
         var utcOffset = status.UtcOffsetMinutes ?? 0;
-        var serverTab = new ServerTab(server, _databaseInitializer, _serverManager.CredentialService, utcOffset, status.HasMsdbAccess);
+        var serverTab = new ServerTab(server, _databaseInitializer, _serverManager.CredentialService, utcOffset, status.HasMsdbAccess, status.SqlEngineEdition == 5);
         var tabHeader = CreateTabHeader(server);
         var tabItem = new TabItem
         {
diff --git a/Lite/Services/RemoteCollectorService.QuerySnapshots.cs b/Lite/Services/RemoteCollectorService.QuerySnapshots.cs
index da031295..7ab3765d 100644
--- a/Lite/Services/RemoteCollectorService.QuerySnapshots.cs
+++ b/Lite/Services/RemoteCollectorService.QuerySnapshots.cs
@@ -81,6 +81,7 @@ WHERE der.session_id <> @@SPID
 AND   der.session_id >= 50
 AND   dest.text IS NOT NULL
 AND   der.database_id <> ISNULL(DB_ID(N'PerformanceMonitor'), 0)
+{2}
 ORDER BY der.cpu_time DESC, der.parallel_worker_count DESC
 OPTION(MAXDOP 1, RECOMPILE);
 """;
@@ -89,12 +90,21 @@ AND   dest.text IS NOT NULL
     /// <summary>
     /// Builds the query snapshots SQL with or without live query plan support.
     /// Used by both the collector and the live snapshot button.
+    /// On Azure SQL Database the result set is scoped to the current database only,
+    /// because logins without access to master can't resolve cross-database requests (see #857).
     /// </summary>
-    internal static string BuildQuerySnapshotsQuery(bool supportsLiveQueryPlan)
+    internal static string BuildQuerySnapshotsQuery(bool supportsLiveQueryPlan, bool isAzureSqlDatabase)
     {
-        return supportsLiveQueryPlan
-            ? string.Format(null, QuerySnapshotsBaseFormat, "live_query_plan = deqs.query_plan,", "OUTER APPLY sys.dm_exec_query_statistics_xml(der.session_id) AS deqs")
-            : string.Format(null, QuerySnapshotsBaseFormat, "live_query_plan = CONVERT(xml, NULL),", "");
+        var liveQueryPlanColumn = supportsLiveQueryPlan
+            ? "live_query_plan = deqs.query_plan,"
+            : "live_query_plan = CONVERT(xml, NULL),";
+        var liveQueryPlanApply = supportsLiveQueryPlan
+            ? "OUTER APPLY sys.dm_exec_query_statistics_xml(der.session_id) AS deqs"
+            : "";
+        var azureScopePredicate = isAzureSqlDatabase
+            ? "AND   der.database_id = DB_ID()"
+            : "";
+        return string.Format(null, QuerySnapshotsBaseFormat, liveQueryPlanColumn, liveQueryPlanApply, azureScopePredicate);
     }
 
     /// <summary>
@@ -106,8 +116,9 @@ private async Task<int> CollectQuerySnapshotsAsync(ServerConnection server, Canc
         var serverStatus = _serverManager.GetConnectionStatus(server.Id);
         var supportsLiveQueryPlan = serverStatus.SqlMajorVersion >= 13 || serverStatus.SqlMajorVersion == 0
             || serverStatus.SqlEngineEdition == 5 || serverStatus.SqlEngineEdition == 8;
+        var isAzureSqlDatabase = serverStatus.SqlEngineEdition == 5;
 
-        var query = BuildQuerySnapshotsQuery(supportsLiveQueryPlan);
+        var query = BuildQuerySnapshotsQuery(supportsLiveQueryPlan, isAzureSqlDatabase);
 
         var serverId = GetServerId(server);
         var collectionTime = DateTime.UtcNow;

From b81547253fc77890c53d9939933426a38136c6e8 Mon Sep 17 00:00:00 2001
From: Erik Darling <2136037+erikdarlingdata@users.noreply.github.com>
Date: Sat, 18 Apr 2026 11:35:29 -0400
Subject: [PATCH 15/49] Polish Lite chart axes and sub-tab styling
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

- Chart X-axis prints the date line only on the first tick and on ticks
  where the date changes; all other ticks show time only. Format respects
  current culture (en-GB → dd/MM, de-DE → dd.MM, 24h clocks, etc.).
  Implemented as a DateTimeTicksBottomDateChange() extension in
  Lite/Helpers/AxesExtensions.cs and applied to every DateTimeTicksBottom
  call site in ServerTab and CorrelatedTimelineLanesControl.
- Server name no longer duplicated in the ServerTab header status line;
  ConnectionStatusText now shows just "Connecting..." / "Last refresh: ...".
- Chart tick label font bumped from 12 to 13 for readability.
- New SubTabItemStyle (thin accent underline, transparent background) in
  all three themes, applied to Queries / Memory / File I/O / Blocking /
  Perfmon / Running Jobs sub-TabControls so sub-tab selection no longer
  looks identical to main-tab selection.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
---
 .../CorrelatedTimelineLanesControl.xaml.cs    |  4 +-
 Lite/Controls/ServerTab.xaml                  | 12 ++--
 Lite/Controls/ServerTab.xaml.cs               | 64 ++++++++++---------
 Lite/Helpers/AxesExtensions.cs                | 45 +++++++++++++
 Lite/Themes/CoolBreezeTheme.xaml              | 34 ++++++++++
 Lite/Themes/DarkTheme.xaml                    | 34 ++++++++++
 Lite/Themes/LightTheme.xaml                   | 34 ++++++++++
 7 files changed, 189 insertions(+), 38 deletions(-)
 create mode 100644 Lite/Helpers/AxesExtensions.cs

diff --git a/Lite/Controls/CorrelatedTimelineLanesControl.xaml.cs b/Lite/Controls/CorrelatedTimelineLanesControl.xaml.cs
index d39775af..beb4c572 100644
--- a/Lite/Controls/CorrelatedTimelineLanesControl.xaml.cs
+++ b/Lite/Controls/CorrelatedTimelineLanesControl.xaml.cs
@@ -287,7 +287,7 @@ private void UpdateBlockingLane(List<(double Time, double Value)> blockingData,
             meanLine.LineWidth = 1;
         }
 
-        BlockingChart.Plot.Axes.DateTimeTicksBottom();
+        BlockingChart.Plot.Axes.DateTimeTicksBottomDateChange();
         BlockingChart.Plot.Axes.Bottom.TickLabelStyle.IsVisible = false;
         ReapplyAxisColors(BlockingChart);
 
@@ -363,7 +363,7 @@ private void UpdateLane(ScottPlot.WPF.WpfPlot chart, string title,
 
         _crosshairManager?.SetLaneData(chart, times, values);
 
-        chart.Plot.Axes.DateTimeTicksBottom();
+        chart.Plot.Axes.DateTimeTicksBottomDateChange();
         // Hide bottom tick labels on all lanes except the last (File I/O)
         if (chart != FileIoChart)
             chart.Plot.Axes.Bottom.TickLabelStyle.IsVisible = false;
diff --git a/Lite/Controls/ServerTab.xaml b/Lite/Controls/ServerTab.xaml
index c04d23d4..e85bc382 100644
--- a/Lite/Controls/ServerTab.xaml
+++ b/Lite/Controls/ServerTab.xaml
@@ -202,7 +202,7 @@
             <!-- Query Performance Tab -->
             <TabItem Header="Queries">
                 <Grid Margin="8">
-                    <TabControl x:Name="QueriesSubTabControl" Background="Transparent" BorderThickness="0">
+                    <TabControl x:Name="QueriesSubTabControl" Background="Transparent" BorderThickness="0" ItemContainerStyle="{DynamicResource SubTabItemStyle}">
                         <TabItem Header="Performance Trends">
                             <Grid>
                                 <Grid.RowDefinitions>
@@ -1046,7 +1046,7 @@
 
             <!-- Memory Tab -->
             <TabItem Header="Memory">
-                <TabControl x:Name="MemorySubTabControl" Background="Transparent" BorderThickness="0">
+                <TabControl x:Name="MemorySubTabControl" Background="Transparent" BorderThickness="0" ItemContainerStyle="{DynamicResource SubTabItemStyle}">
                     <!-- Memory Overview Sub-Tab -->
                     <TabItem Header="Overview">
                         <Grid Margin="8">
@@ -1182,7 +1182,7 @@
             <!-- File I/O Tab -->
             <TabItem Header="File I/O">
                 <Grid Margin="8">
-                    <TabControl Background="Transparent" BorderThickness="0">
+                    <TabControl Background="Transparent" BorderThickness="0" ItemContainerStyle="{DynamicResource SubTabItemStyle}">
                         <!-- File I/O Latency sub-tab -->
                         <TabItem Header="File I/O Latency">
                             <Grid>
@@ -1239,7 +1239,7 @@
             <!-- Blocking Tab -->
             <TabItem Header="Blocking">
                 <Grid Margin="8">
-                    <TabControl x:Name="BlockingSubTabControl" Background="Transparent" BorderThickness="0">
+                    <TabControl x:Name="BlockingSubTabControl" Background="Transparent" BorderThickness="0" ItemContainerStyle="{DynamicResource SubTabItemStyle}">
                         <TabItem Header="Trends">
                             <Grid>
                                 <Grid.RowDefinitions>
@@ -1578,7 +1578,7 @@
             <!-- Configuration Tab -->
             <TabItem Header="Configuration">
                 <Grid Margin="8">
-                    <TabControl Background="Transparent" BorderThickness="0">
+                    <TabControl Background="Transparent" BorderThickness="0" ItemContainerStyle="{DynamicResource SubTabItemStyle}">
                         <TabItem Header="Server Configuration">
                             <DataGrid x:Name="ServerConfigGrid"
                                       AutoGenerateColumns="False" IsReadOnly="True"
@@ -1802,7 +1802,7 @@
             <!-- Collection Health Tab -->
             <TabItem Header="Collection Health">
                 <Grid Margin="8">
-                    <TabControl Background="Transparent" BorderThickness="0">
+                    <TabControl Background="Transparent" BorderThickness="0" ItemContainerStyle="{DynamicResource SubTabItemStyle}">
                         <TabItem Header="Health Summary">
                             <DataGrid x:Name="CollectionHealthGrid"
                                       AutoGenerateColumns="False" IsReadOnly="True"
diff --git a/Lite/Controls/ServerTab.xaml.cs b/Lite/Controls/ServerTab.xaml.cs
index caeabfed..24ed8f90 100644
--- a/Lite/Controls/ServerTab.xaml.cs
+++ b/Lite/Controls/ServerTab.xaml.cs
@@ -135,7 +135,7 @@ public ServerTab(ServerConnection server, DuckDbInitializer duckDb, CredentialSe
         ServerTimeHelper.UtcOffsetMinutes = utcOffsetMinutes;
 
         ServerNameText.Text = server.ReadOnlyIntent ? $"{server.DisplayName} (Read-Only)" : server.DisplayName;
-        ConnectionStatusText.Text = server.ServerNameDisplay;
+        ConnectionStatusText.Text = "Connecting...";
 
         /* Apply default time range from settings */
         TimeRangeCombo.SelectedIndex = App.DefaultTimeRangeHours switch
@@ -841,7 +841,7 @@ private async System.Threading.Tasks.Task RefreshAllDataAsync(bool fullRefresh =
             }
 
             var tz = ServerTimeHelper.GetTimezoneLabel(ServerTimeHelper.CurrentDisplayMode);
-            ConnectionStatusText.Text = $"{_server.ServerNameDisplay} - Last refresh: {DateTime.Now:HH:mm:ss} ({tz})";
+            ConnectionStatusText.Text = $"Last refresh: {DateTime.Now:HH:mm:ss} ({tz})";
         }
         catch (Exception ex)
         {
@@ -1876,7 +1876,7 @@ private void UpdateCpuChart(List<CpuUtilizationRow> data)
         otherPlot.Color = ScottPlot.Color.FromHex("#E57373");
         _cpuHover?.Add(otherPlot, "Other");
 
-        CpuChart.Plot.Axes.DateTimeTicksBottom();
+        CpuChart.Plot.Axes.DateTimeTicksBottomDateChange();
         ReapplyAxisColors(CpuChart);
         CpuChart.Plot.YLabel("CPU %");
         CpuChart.Plot.Axes.SetLimitsY(0, 105);
@@ -1932,7 +1932,7 @@ private void UpdateMemoryChart(List<MemoryTrendPoint> data, List<MemoryTrendPoin
         grantPlot.Color = ScottPlot.Color.FromHex("#FFB74D");
         _memoryHover?.Add(grantPlot, "Memory Grants");
 
-        MemoryChart.Plot.Axes.DateTimeTicksBottom();
+        MemoryChart.Plot.Axes.DateTimeTicksBottomDateChange();
         ReapplyAxisColors(MemoryChart);
         MemoryChart.Plot.YLabel("Memory (GB)");
 
@@ -1989,7 +1989,7 @@ private void UpdateMemoryGrantCharts(List<MemoryGrantChartPoint> data)
             }
         }
 
-        MemoryGrantSizingChart.Plot.Axes.DateTimeTicksBottom();
+        MemoryGrantSizingChart.Plot.Axes.DateTimeTicksBottomDateChange();
         ReapplyAxisColors(MemoryGrantSizingChart);
         MemoryGrantSizingChart.Plot.YLabel("Memory (MB)");
         SetChartYLimitsWithLegendPadding(MemoryGrantSizingChart, 0, sizingMax > 0 ? sizingMax : 100);
@@ -2025,7 +2025,7 @@ private void UpdateMemoryGrantCharts(List<MemoryGrantChartPoint> data)
             }
         }
 
-        MemoryGrantActivityChart.Plot.Axes.DateTimeTicksBottom();
+        MemoryGrantActivityChart.Plot.Axes.DateTimeTicksBottomDateChange();
         ReapplyAxisColors(MemoryGrantActivityChart);
         MemoryGrantActivityChart.Plot.YLabel("Count");
         SetChartYLimitsWithLegendPadding(MemoryGrantActivityChart, 0, activityMax > 0 ? activityMax : 10);
@@ -2061,7 +2061,7 @@ private void UpdateTempDbChart(List<TempDbRow> data)
         vsPlot.Color = ScottPlot.Color.FromHex("#81C784");
         _tempDbHover?.Add(vsPlot, "Version Store");
 
-        TempDbChart.Plot.Axes.DateTimeTicksBottom();
+        TempDbChart.Plot.Axes.DateTimeTicksBottomDateChange();
         ReapplyAxisColors(TempDbChart);
         TempDbChart.Plot.YLabel("MB");
 
@@ -2107,7 +2107,7 @@ private void UpdateTempDbFileIoChart(List<FileIoTrendPoint> data)
             }
         }
 
-        TempDbFileIoChart.Plot.Axes.DateTimeTicksBottom();
+        TempDbFileIoChart.Plot.Axes.DateTimeTicksBottomDateChange();
         ReapplyAxisColors(TempDbFileIoChart);
         TempDbFileIoChart.Plot.YLabel("TempDB File I/O Latency (ms)");
         SetChartYLimitsWithLegendPadding(TempDbFileIoChart, 0, maxLatency > 0 ? maxLatency : 10);
@@ -2191,14 +2191,14 @@ private void UpdateFileIoCharts(List<FileIoTrendPoint> data)
             }
         }
 
-        FileIoReadChart.Plot.Axes.DateTimeTicksBottom();
+        FileIoReadChart.Plot.Axes.DateTimeTicksBottomDateChange();
         ReapplyAxisColors(FileIoReadChart);
         FileIoReadChart.Plot.YLabel("Read Latency (ms)");
         SetChartYLimitsWithLegendPadding(FileIoReadChart, 0, readMax > 0 ? readMax : 10);
         ShowChartLegend(FileIoReadChart);
         FileIoReadChart.Refresh();
 
-        FileIoWriteChart.Plot.Axes.DateTimeTicksBottom();
+        FileIoWriteChart.Plot.Axes.DateTimeTicksBottomDateChange();
         ReapplyAxisColors(FileIoWriteChart);
         FileIoWriteChart.Plot.YLabel("Write Latency (ms)");
         SetChartYLimitsWithLegendPadding(FileIoWriteChart, 0, writeMax > 0 ? writeMax : 10);
@@ -2255,14 +2255,14 @@ private void UpdateFileIoThroughputCharts(List<FileIoThroughputPoint> data)
             }
         }
 
-        FileIoReadThroughputChart.Plot.Axes.DateTimeTicksBottom();
+        FileIoReadThroughputChart.Plot.Axes.DateTimeTicksBottomDateChange();
         ReapplyAxisColors(FileIoReadThroughputChart);
         FileIoReadThroughputChart.Plot.YLabel("Read Throughput (MB/s)");
         SetChartYLimitsWithLegendPadding(FileIoReadThroughputChart, 0, readMax > 0 ? readMax : 1);
         ShowChartLegend(FileIoReadThroughputChart);
         FileIoReadThroughputChart.Refresh();
 
-        FileIoWriteThroughputChart.Plot.Axes.DateTimeTicksBottom();
+        FileIoWriteThroughputChart.Plot.Axes.DateTimeTicksBottomDateChange();
         ReapplyAxisColors(FileIoWriteThroughputChart);
         FileIoWriteThroughputChart.Plot.YLabel("Write Throughput (MB/s)");
         SetChartYLimitsWithLegendPadding(FileIoWriteThroughputChart, 0, writeMax > 0 ? writeMax : 1);
@@ -2298,7 +2298,7 @@ private void UpdateLockWaitTrendChart(List<LockWaitTrendPoint> data, int hoursBa
             zeroLine.LegendText = "Lock Waits";
             zeroLine.Color = ScottPlot.Color.FromHex("#4FC3F7");
             zeroLine.MarkerSize = 0;
-            LockWaitTrendChart.Plot.Axes.DateTimeTicksBottom();
+            LockWaitTrendChart.Plot.Axes.DateTimeTicksBottomDateChange();
             LockWaitTrendChart.Plot.Axes.SetLimitsX(rangeStart.ToOADate(), rangeEnd.ToOADate());
             ReapplyAxisColors(LockWaitTrendChart);
             LockWaitTrendChart.Plot.YLabel("Lock Wait Time (ms/sec)");
@@ -2325,7 +2325,7 @@ private void UpdateLockWaitTrendChart(List<LockWaitTrendPoint> data, int hoursBa
             if (values.Length > 0) globalMax = Math.Max(globalMax, values.Max());
         }
 
-        LockWaitTrendChart.Plot.Axes.DateTimeTicksBottom();
+        LockWaitTrendChart.Plot.Axes.DateTimeTicksBottomDateChange();
         LockWaitTrendChart.Plot.Axes.SetLimitsX(rangeStart.ToOADate(), rangeEnd.ToOADate());
         ReapplyAxisColors(LockWaitTrendChart);
         LockWaitTrendChart.Plot.YLabel("Lock Wait Time (ms/sec)");
@@ -2362,7 +2362,7 @@ private void UpdateBlockingTrendChart(List<TrendPoint> data, int hoursBack, Date
             zeroLine.LegendText = "Blocking Incidents";
             zeroLine.Color = ScottPlot.Color.FromHex("#E57373");
             zeroLine.MarkerSize = 0;
-            BlockingTrendChart.Plot.Axes.DateTimeTicksBottom();
+            BlockingTrendChart.Plot.Axes.DateTimeTicksBottomDateChange();
             BlockingTrendChart.Plot.Axes.SetLimitsX(rangeStart.ToOADate(), rangeEnd.ToOADate());
             ReapplyAxisColors(BlockingTrendChart);
             BlockingTrendChart.Plot.YLabel("Blocking Incidents");
@@ -2404,7 +2404,7 @@ private void UpdateBlockingTrendChart(List<TrendPoint> data, int hoursBack, Date
         plot.MarkerSize = 0; /* No markers, just lines */
         _blockingTrendHover?.Add(plot, "Blocking Incidents");
 
-        BlockingTrendChart.Plot.Axes.DateTimeTicksBottom();
+        BlockingTrendChart.Plot.Axes.DateTimeTicksBottomDateChange();
         BlockingTrendChart.Plot.Axes.SetLimitsX(rangeStart.ToOADate(), rangeEnd.ToOADate());
         ReapplyAxisColors(BlockingTrendChart);
         BlockingTrendChart.Plot.YLabel("Blocking Incidents");
@@ -2441,7 +2441,7 @@ private void UpdateDeadlockTrendChart(List<TrendPoint> data, int hoursBack, Date
             zeroLine.LegendText = "Deadlocks";
             zeroLine.Color = ScottPlot.Color.FromHex("#FFB74D");
             zeroLine.MarkerSize = 0;
-            DeadlockTrendChart.Plot.Axes.DateTimeTicksBottom();
+            DeadlockTrendChart.Plot.Axes.DateTimeTicksBottomDateChange();
             DeadlockTrendChart.Plot.Axes.SetLimitsX(rangeStart.ToOADate(), rangeEnd.ToOADate());
             ReapplyAxisColors(DeadlockTrendChart);
             DeadlockTrendChart.Plot.YLabel("Deadlocks");
@@ -2483,7 +2483,7 @@ private void UpdateDeadlockTrendChart(List<TrendPoint> data, int hoursBack, Date
         plot.MarkerSize = 0; /* No markers, just lines */
         _deadlockTrendHover?.Add(plot, "Deadlocks");
 
-        DeadlockTrendChart.Plot.Axes.DateTimeTicksBottom();
+        DeadlockTrendChart.Plot.Axes.DateTimeTicksBottomDateChange();
         DeadlockTrendChart.Plot.Axes.SetLimitsX(rangeStart.ToOADate(), rangeEnd.ToOADate());
         ReapplyAxisColors(DeadlockTrendChart);
         DeadlockTrendChart.Plot.YLabel("Deadlocks");
@@ -2520,7 +2520,7 @@ private void UpdateCurrentWaitsDurationChart(List<WaitingTaskTrendPoint> data, i
             zeroLine.LegendText = "Current Waits";
             zeroLine.Color = ScottPlot.Color.FromHex("#4FC3F7");
             zeroLine.MarkerSize = 0;
-            CurrentWaitsDurationChart.Plot.Axes.DateTimeTicksBottom();
+            CurrentWaitsDurationChart.Plot.Axes.DateTimeTicksBottomDateChange();
             CurrentWaitsDurationChart.Plot.Axes.SetLimitsX(rangeStart.ToOADate(), rangeEnd.ToOADate());
             ReapplyAxisColors(CurrentWaitsDurationChart);
             CurrentWaitsDurationChart.Plot.YLabel("Total Wait Duration (ms)");
@@ -2550,7 +2550,7 @@ private void UpdateCurrentWaitsDurationChart(List<WaitingTaskTrendPoint> data, i
             if (values.Length > 0) globalMax = Math.Max(globalMax, values.Max());
         }
 
-        CurrentWaitsDurationChart.Plot.Axes.DateTimeTicksBottom();
+        CurrentWaitsDurationChart.Plot.Axes.DateTimeTicksBottomDateChange();
         CurrentWaitsDurationChart.Plot.Axes.SetLimitsX(rangeStart.ToOADate(), rangeEnd.ToOADate());
         ReapplyAxisColors(CurrentWaitsDurationChart);
         CurrentWaitsDurationChart.Plot.YLabel("Total Wait Duration (ms)");
@@ -2585,7 +2585,7 @@ private void UpdateCurrentWaitsBlockedChart(List<BlockedSessionTrendPoint> data,
             zeroLine.LegendText = "Blocked Sessions";
             zeroLine.Color = ScottPlot.Color.FromHex("#E57373");
             zeroLine.MarkerSize = 0;
-            CurrentWaitsBlockedChart.Plot.Axes.DateTimeTicksBottom();
+            CurrentWaitsBlockedChart.Plot.Axes.DateTimeTicksBottomDateChange();
             CurrentWaitsBlockedChart.Plot.Axes.SetLimitsX(rangeStart.ToOADate(), rangeEnd.ToOADate());
             ReapplyAxisColors(CurrentWaitsBlockedChart);
             CurrentWaitsBlockedChart.Plot.YLabel("Blocked Sessions");
@@ -2615,7 +2615,7 @@ private void UpdateCurrentWaitsBlockedChart(List<BlockedSessionTrendPoint> data,
             if (values.Length > 0) globalMax = Math.Max(globalMax, values.Max());
         }
 
-        CurrentWaitsBlockedChart.Plot.Axes.DateTimeTicksBottom();
+        CurrentWaitsBlockedChart.Plot.Axes.DateTimeTicksBottomDateChange();
         CurrentWaitsBlockedChart.Plot.Axes.SetLimitsX(rangeStart.ToOADate(), rangeEnd.ToOADate());
         ReapplyAxisColors(CurrentWaitsBlockedChart);
         CurrentWaitsBlockedChart.Plot.YLabel("Blocked Sessions");
@@ -2642,7 +2642,7 @@ private void UpdateQueryDurationTrendChart(List<QueryTrendPoint> data)
         plot.Color = ScottPlot.Color.FromHex("#4FC3F7");
         _queryDurationTrendHover?.Add(plot, "Query Duration");
 
-        QueryDurationTrendChart.Plot.Axes.DateTimeTicksBottom();
+        QueryDurationTrendChart.Plot.Axes.DateTimeTicksBottomDateChange();
         ReapplyAxisColors(QueryDurationTrendChart);
         QueryDurationTrendChart.Plot.YLabel("Duration (ms/sec)");
         SetChartYLimitsWithLegendPadding(QueryDurationTrendChart, 0, values.Max());
@@ -2666,7 +2666,7 @@ private void UpdateProcDurationTrendChart(List<QueryTrendPoint> data)
         plot.Color = ScottPlot.Color.FromHex("#81C784");
         _procDurationTrendHover?.Add(plot, "Procedure Duration");
 
-        ProcDurationTrendChart.Plot.Axes.DateTimeTicksBottom();
+        ProcDurationTrendChart.Plot.Axes.DateTimeTicksBottomDateChange();
         ReapplyAxisColors(ProcDurationTrendChart);
         ProcDurationTrendChart.Plot.YLabel("Duration (ms/sec)");
         SetChartYLimitsWithLegendPadding(ProcDurationTrendChart, 0, values.Max());
@@ -2690,7 +2690,7 @@ private void UpdateQueryStoreDurationTrendChart(List<QueryTrendPoint> data)
         plot.Color = ScottPlot.Color.FromHex("#FFB74D");
         _queryStoreDurationTrendHover?.Add(plot, "Query Store Duration");
 
-        QueryStoreDurationTrendChart.Plot.Axes.DateTimeTicksBottom();
+        QueryStoreDurationTrendChart.Plot.Axes.DateTimeTicksBottomDateChange();
         ReapplyAxisColors(QueryStoreDurationTrendChart);
         QueryStoreDurationTrendChart.Plot.YLabel("Duration (ms/sec)");
         SetChartYLimitsWithLegendPadding(QueryStoreDurationTrendChart, 0, values.Max());
@@ -2855,7 +2855,7 @@ private void UpdateExecutionCountTrendChart(List<QueryTrendPoint> data)
         plot.Color = ScottPlot.Color.FromHex("#BA68C8");
         _executionCountTrendHover?.Add(plot, "Executions");
 
-        ExecutionCountTrendChart.Plot.Axes.DateTimeTicksBottom();
+        ExecutionCountTrendChart.Plot.Axes.DateTimeTicksBottomDateChange();
         ReapplyAxisColors(ExecutionCountTrendChart);
         ExecutionCountTrendChart.Plot.YLabel("Executions/sec");
         SetChartYLimitsWithLegendPadding(ExecutionCountTrendChart, 0, values.Max());
@@ -3415,7 +3415,7 @@ private async System.Threading.Tasks.Task UpdateWaitStatsChartFromPickerAsync()
                 if (values.Length > 0) globalMax = Math.Max(globalMax, values.Max());
             }
 
-            WaitStatsChart.Plot.Axes.DateTimeTicksBottom();
+            WaitStatsChart.Plot.Axes.DateTimeTicksBottomDateChange();
             DateTime rangeStart, rangeEnd;
             if (IsCustomRange && fromDate.HasValue && toDate.HasValue)
             {
@@ -3579,7 +3579,7 @@ private async System.Threading.Tasks.Task UpdateMemoryClerksChartFromPickerAsync
                 }
             }
 
-            MemoryClerksChart.Plot.Axes.DateTimeTicksBottom();
+            MemoryClerksChart.Plot.Axes.DateTimeTicksBottomDateChange();
             ReapplyAxisColors(MemoryClerksChart);
             MemoryClerksChart.Plot.YLabel("Memory (MB)");
             SetChartYLimitsWithLegendPadding(MemoryClerksChart, 0, globalMax > 0 ? globalMax : 100);
@@ -3773,7 +3773,7 @@ private async System.Threading.Tasks.Task UpdatePerfmonChartFromPickerAsync()
                 if (values.Length > 0) globalMax = Math.Max(globalMax, values.Max());
             }
 
-            PerfmonChart.Plot.Axes.DateTimeTicksBottom();
+            PerfmonChart.Plot.Axes.DateTimeTicksBottomDateChange();
             DateTime rangeStart, rangeEnd;
             if (IsCustomRange && fromDate.HasValue && toDate.HasValue)
             {
@@ -3913,6 +3913,8 @@ private static void ApplyTheme(ScottPlot.WPF.WpfPlot chart)
         chart.Plot.Axes.Left.TickLabelStyle.ForeColor = textColor;
         chart.Plot.Axes.Bottom.Label.ForeColor = textColor;
         chart.Plot.Axes.Left.Label.ForeColor = textColor;
+        chart.Plot.Axes.Bottom.TickLabelStyle.FontSize = 13;
+        chart.Plot.Axes.Left.TickLabelStyle.FontSize = 13;
 
         // Set the WPF control Background to match so no white flash appears before ScottPlot's render loop fires
         chart.Background = new System.Windows.Media.SolidColorBrush(System.Windows.Media.Color.FromRgb(figureBackground.R, figureBackground.G, figureBackground.B));
@@ -3970,6 +3972,8 @@ private static void ReapplyAxisColors(ScottPlot.WPF.WpfPlot chart)
         chart.Plot.Axes.Left.TickLabelStyle.ForeColor = textColor;
         chart.Plot.Axes.Bottom.Label.ForeColor = textColor;
         chart.Plot.Axes.Left.Label.ForeColor = textColor;
+        chart.Plot.Axes.Bottom.TickLabelStyle.FontSize = 13;
+        chart.Plot.Axes.Left.TickLabelStyle.FontSize = 13;
     }
 
     /// <summary>
@@ -5309,7 +5313,7 @@ private void UpdateCollectorDurationChart(List<CollectionLogRow> data)
             colorIdx++;
         }
 
-        CollectorDurationChart.Plot.Axes.DateTimeTicksBottom();
+        CollectorDurationChart.Plot.Axes.DateTimeTicksBottomDateChange();
         ReapplyAxisColors(CollectorDurationChart);
         CollectorDurationChart.Plot.YLabel("Duration (ms)");
         CollectorDurationChart.Plot.Axes.AutoScale();
diff --git a/Lite/Helpers/AxesExtensions.cs b/Lite/Helpers/AxesExtensions.cs
new file mode 100644
index 00000000..fb19a60b
--- /dev/null
+++ b/Lite/Helpers/AxesExtensions.cs
@@ -0,0 +1,45 @@
+using System;
+using System.Globalization;
+using System.Text.RegularExpressions;
+
+namespace PerformanceMonitorLite.Helpers;
+
+internal static class AxesExtensions
+{
+    /// <summary>Culture's short-date pattern with the year component removed (e.g. "M/d" en-US, "dd/MM" en-GB, "dd.MM" de-DE).</summary>
+    private static readonly string MonthDayPattern = BuildMonthDayPattern();
+
+    private static string BuildMonthDayPattern()
+    {
+        var p = CultureInfo.CurrentCulture.DateTimeFormat.ShortDatePattern;
+        p = Regex.Replace(p, @"y+", "");
+        p = Regex.Replace(p, @"^[\s/.\-]+|[\s/.\-]+$", "");
+        p = Regex.Replace(p, @"([/.\-\s])\1+", "$1");
+        return string.IsNullOrWhiteSpace(p) ? "M/d" : p;
+    }
+
+    /// <summary>
+    /// Like <c>DateTimeTicksBottom()</c>, but prints the date line on only the first tick
+    /// and on ticks where the date component changes. All other ticks show time-only.
+    /// Date and time formats follow the current culture.
+    /// </summary>
+    public static void DateTimeTicksBottomDateChange(this ScottPlot.AxisManager axes)
+    {
+        axes.DateTimeTicksBottom();
+        if (axes.Bottom.TickGenerator is ScottPlot.TickGenerators.DateTimeAutomatic gen)
+        {
+            DateTime? lastDate = null;
+            var culture = CultureInfo.CurrentCulture;
+            gen.LabelFormatter = dt =>
+            {
+                var time = dt.ToString("t", culture);
+                if (lastDate is null || dt.Date != lastDate.Value)
+                {
+                    lastDate = dt.Date;
+                    return $"{dt.ToString(MonthDayPattern, culture)}\n{time}";
+                }
+                return time;
+            };
+        }
+    }
+}
diff --git a/Lite/Themes/CoolBreezeTheme.xaml b/Lite/Themes/CoolBreezeTheme.xaml
index d22edec4..010d8a8c 100644
--- a/Lite/Themes/CoolBreezeTheme.xaml
+++ b/Lite/Themes/CoolBreezeTheme.xaml
@@ -595,6 +595,40 @@
         </Setter>
     </Style>
 
+    <!-- Sub-tab style: thin accent underline instead of filled background, so the hierarchy
+         reads at a glance when a main tab's sub-tabs are shown alongside the main tab bar. -->
+    <Style x:Key="SubTabItemStyle" TargetType="TabItem">
+        <Setter Property="Background" Value="Transparent"/>
+        <Setter Property="Foreground" Value="{StaticResource ForegroundDimBrush}"/>
+        <Setter Property="BorderThickness" Value="0"/>
+        <Setter Property="Padding" Value="10,6"/>
+        <Setter Property="Margin" Value="0,0,4,0"/>
+        <Setter Property="Template">
+            <Setter.Value>
+                <ControlTemplate TargetType="TabItem">
+                    <Border x:Name="border"
+                            Background="{TemplateBinding Background}"
+                            BorderBrush="{StaticResource AccentBrush}"
+                            BorderThickness="0"
+                            Padding="{TemplateBinding Padding}">
+                        <ContentPresenter ContentSource="Header"
+                                          HorizontalAlignment="Center"
+                                          VerticalAlignment="Center"/>
+                    </Border>
+                    <ControlTemplate.Triggers>
+                        <Trigger Property="IsSelected" Value="True">
+                            <Setter TargetName="border" Property="BorderThickness" Value="0,0,0,2"/>
+                            <Setter Property="Foreground" Value="{StaticResource ForegroundBrush}"/>
+                        </Trigger>
+                        <Trigger Property="IsMouseOver" Value="True">
+                            <Setter TargetName="border" Property="Background" Value="{StaticResource BackgroundLighterBrush}"/>
+                        </Trigger>
+                    </ControlTemplate.Triggers>
+                </ControlTemplate>
+            </Setter.Value>
+        </Setter>
+    </Style>
+
     <!-- ============================================ -->
     <!-- DataGrid Style                               -->
     <!-- ============================================ -->
diff --git a/Lite/Themes/DarkTheme.xaml b/Lite/Themes/DarkTheme.xaml
index 3d64f59d..869af3de 100644
--- a/Lite/Themes/DarkTheme.xaml
+++ b/Lite/Themes/DarkTheme.xaml
@@ -595,6 +595,40 @@
         </Setter>
     </Style>
 
+    <!-- Sub-tab style: thin accent underline instead of filled background, so the hierarchy
+         reads at a glance when a main tab's sub-tabs are shown alongside the main tab bar. -->
+    <Style x:Key="SubTabItemStyle" TargetType="TabItem">
+        <Setter Property="Background" Value="Transparent"/>
+        <Setter Property="Foreground" Value="{StaticResource ForegroundDimBrush}"/>
+        <Setter Property="BorderThickness" Value="0"/>
+        <Setter Property="Padding" Value="10,6"/>
+        <Setter Property="Margin" Value="0,0,4,0"/>
+        <Setter Property="Template">
+            <Setter.Value>
+                <ControlTemplate TargetType="TabItem">
+                    <Border x:Name="border"
+                            Background="{TemplateBinding Background}"
+                            BorderBrush="{StaticResource AccentBrush}"
+                            BorderThickness="0"
+                            Padding="{TemplateBinding Padding}">
+                        <ContentPresenter ContentSource="Header"
+                                          HorizontalAlignment="Center"
+                                          VerticalAlignment="Center"/>
+                    </Border>
+                    <ControlTemplate.Triggers>
+                        <Trigger Property="IsSelected" Value="True">
+                            <Setter TargetName="border" Property="BorderThickness" Value="0,0,0,2"/>
+                            <Setter Property="Foreground" Value="{StaticResource ForegroundBrush}"/>
+                        </Trigger>
+                        <Trigger Property="IsMouseOver" Value="True">
+                            <Setter TargetName="border" Property="Background" Value="{StaticResource BackgroundLighterBrush}"/>
+                        </Trigger>
+                    </ControlTemplate.Triggers>
+                </ControlTemplate>
+            </Setter.Value>
+        </Setter>
+    </Style>
+
     <!-- ============================================ -->
     <!-- DataGrid Style                               -->
     <!-- ============================================ -->
diff --git a/Lite/Themes/LightTheme.xaml b/Lite/Themes/LightTheme.xaml
index e47e2411..e9908300 100644
--- a/Lite/Themes/LightTheme.xaml
+++ b/Lite/Themes/LightTheme.xaml
@@ -595,6 +595,40 @@
         </Setter>
     </Style>
 
+    <!-- Sub-tab style: thin accent underline instead of filled background, so the hierarchy
+         reads at a glance when a main tab's sub-tabs are shown alongside the main tab bar. -->
+    <Style x:Key="SubTabItemStyle" TargetType="TabItem">
+        <Setter Property="Background" Value="Transparent"/>
+        <Setter Property="Foreground" Value="{StaticResource ForegroundDimBrush}"/>
+        <Setter Property="BorderThickness" Value="0"/>
+        <Setter Property="Padding" Value="10,6"/>
+        <Setter Property="Margin" Value="0,0,4,0"/>
+        <Setter Property="Template">
+            <Setter.Value>
+                <ControlTemplate TargetType="TabItem">
+                    <Border x:Name="border"
+                            Background="{TemplateBinding Background}"
+                            BorderBrush="{StaticResource AccentBrush}"
+                            BorderThickness="0"
+                            Padding="{TemplateBinding Padding}">
+                        <ContentPresenter ContentSource="Header"
+                                          HorizontalAlignment="Center"
+                                          VerticalAlignment="Center"/>
+                    </Border>
+                    <ControlTemplate.Triggers>
+                        <Trigger Property="IsSelected" Value="True">
+                            <Setter TargetName="border" Property="BorderThickness" Value="0,0,0,2"/>
+                            <Setter Property="Foreground" Value="{StaticResource ForegroundBrush}"/>
+                        </Trigger>
+                        <Trigger Property="IsMouseOver" Value="True">
+                            <Setter TargetName="border" Property="Background" Value="{StaticResource BackgroundLighterBrush}"/>
+                        </Trigger>
+                    </ControlTemplate.Triggers>
+                </ControlTemplate>
+            </Setter.Value>
+        </Setter>
+    </Style>
+
     <!-- ============================================ -->
     <!-- DataGrid Style                               -->
     <!-- ============================================ -->

From 64ddd017c23e62158d3759af7dc65bf7d0349066 Mon Sep 17 00:00:00 2001
From: Erik Darling <2136037+erikdarlingdata@users.noreply.github.com>
Date: Sat, 18 Apr 2026 20:06:12 -0400
Subject: [PATCH 16/49] Port Lite chart/tab polish to Dashboard + LSP
 diagnostics cleanup
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Dashboard polish (ports the same items merged to Lite in #862):
- New Dashboard/Helpers/AxesExtensions.cs with DateTimeTicksBottomDateChange(),
  culture-aware (dd/MM for en-GB, dd.MM for de-DE, 24h clocks, etc.). All 52
  call sites of DateTimeTicksBottom() across 10 files swapped to use it.
- TabHelpers.ApplyTheme + ReapplyAxisColors bump chart tick label font from
  12 to 13 so numbers read cleaner on wide charts.
- SubTabItemStyle added to Dark / Light / CoolBreeze themes: thin accent
  underline + transparent background instead of filled cyan, so sub-tabs
  don't look identical to main tabs when selected. Wired via
  ItemContainerStyle on 11 sub-TabControls (Overview's inner tabs,
  Collection Health's inner tabs, Locking, ConfigChanges, CurrentConfig,
  FinOps, Memory, ResourceMetrics ×2, SystemEvents, QueryPerformance).

LSP diagnostics cleanup (tracked work from chore/lsp-diagnostics-cleanup):
- Small nullability/warning fixes across Dashboard and Lite services,
  analysis helpers, and BenefitScorer / PlanAnalyzer.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
---
 .../Analysis/SqlServerBaselineProvider.cs     |  2 +-
 Dashboard/Controls/ConfigChangesContent.xaml  |  2 +-
 .../CorrelatedTimelineLanesControl.xaml.cs    |  4 +-
 Dashboard/Controls/CurrentConfigContent.xaml  |  2 +-
 Dashboard/Controls/FinOpsContent.xaml         |  2 +-
 Dashboard/Controls/MemoryContent.xaml         |  2 +-
 Dashboard/Controls/MemoryContent.xaml.cs      | 12 ++---
 .../Controls/QueryPerformanceContent.xaml     |  2 +-
 .../Controls/QueryPerformanceContent.xaml.cs  |  4 +-
 .../Controls/ResourceMetricsContent.xaml      |  4 +-
 .../Controls/ResourceMetricsContent.xaml.cs   | 16 +++----
 Dashboard/Controls/SystemEventsContent.xaml   |  2 +-
 .../Controls/SystemEventsContent.xaml.cs      | 36 +++++++--------
 Dashboard/Helpers/AxesExtensions.cs           | 45 +++++++++++++++++++
 .../Helpers/CorrelatedCrosshairManager.cs     |  4 +-
 Dashboard/Helpers/TabHelpers.cs               |  4 ++
 Dashboard/ProcedureHistoryWindow.xaml.cs      |  2 +-
 Dashboard/QueryExecutionHistoryWindow.xaml.cs |  2 +-
 Dashboard/QueryStatsHistoryWindow.xaml.cs     |  2 +-
 Dashboard/ServerTab.xaml                      |  6 +--
 Dashboard/ServerTab.xaml.cs                   | 24 +++++-----
 Dashboard/Services/BenefitScorer.cs           | 20 ++++-----
 Dashboard/Services/PlanAnalyzer.cs            |  8 ++--
 Dashboard/Themes/CoolBreezeTheme.xaml         | 34 ++++++++++++++
 Dashboard/Themes/DarkTheme.xaml               | 34 ++++++++++++++
 Dashboard/Themes/LightTheme.xaml              | 34 ++++++++++++++
 Dashboard/TracePatternHistoryWindow.xaml.cs   |  2 +-
 Lite/Services/BenefitScorer.cs                | 20 ++++-----
 Lite/Services/PlanAnalyzer.cs                 |  9 ++--
 .../RemoteCollectorService.QueryStore.cs      |  2 +-
 30 files changed, 245 insertions(+), 97 deletions(-)
 create mode 100644 Dashboard/Helpers/AxesExtensions.cs

diff --git a/Dashboard/Analysis/SqlServerBaselineProvider.cs b/Dashboard/Analysis/SqlServerBaselineProvider.cs
index 1746028c..3d65ee20 100644
--- a/Dashboard/Analysis/SqlServerBaselineProvider.cs
+++ b/Dashboard/Analysis/SqlServerBaselineProvider.cs
@@ -463,7 +463,7 @@ private static double PoolVariance(List<BaselineBucket> buckets, double grandMea
         return totalSumSq / (totalSamples - 1);
     }
 
-    private class CachedBaseline
+    private sealed class CachedBaseline
     {
         public DateTime ComputedAt { get; init; }
         public DateTime RealTime { get; init; }
diff --git a/Dashboard/Controls/ConfigChangesContent.xaml b/Dashboard/Controls/ConfigChangesContent.xaml
index a8e1f2d4..4f5d5e7d 100644
--- a/Dashboard/Controls/ConfigChangesContent.xaml
+++ b/Dashboard/Controls/ConfigChangesContent.xaml
@@ -15,7 +15,7 @@
             <MenuItem Header="Export to CSV..." Click="ExportToCsv_Click"/>
         </ContextMenu>
     </UserControl.Resources>
-    <TabControl>
+    <TabControl ItemContainerStyle="{DynamicResource SubTabItemStyle}">
         <!-- Server Configuration Changes Sub-Tab -->
         <TabItem Header="Server Config Changes">
             <Grid>
diff --git a/Dashboard/Controls/CorrelatedTimelineLanesControl.xaml.cs b/Dashboard/Controls/CorrelatedTimelineLanesControl.xaml.cs
index 8fe1e734..7d8f878f 100644
--- a/Dashboard/Controls/CorrelatedTimelineLanesControl.xaml.cs
+++ b/Dashboard/Controls/CorrelatedTimelineLanesControl.xaml.cs
@@ -320,7 +320,7 @@ private void UpdateBlockingLane(List<(double Time, double Value)> blockingData,
             }
         }
 
-        BlockingChart.Plot.Axes.DateTimeTicksBottom();
+        BlockingChart.Plot.Axes.DateTimeTicksBottomDateChange();
         BlockingChart.Plot.Axes.Bottom.TickLabelStyle.IsVisible = false;
         TabHelpers.ReapplyAxisColors(BlockingChart);
 
@@ -394,7 +394,7 @@ private void UpdateLane(ScottPlot.WPF.WpfPlot chart, string title,
 
         _crosshairManager?.SetLaneData(chart, times, values);
 
-        chart.Plot.Axes.DateTimeTicksBottom();
+        chart.Plot.Axes.DateTimeTicksBottomDateChange();
         if (chart != FileIoChart)
             chart.Plot.Axes.Bottom.TickLabelStyle.IsVisible = false;
 
diff --git a/Dashboard/Controls/CurrentConfigContent.xaml b/Dashboard/Controls/CurrentConfigContent.xaml
index ab36dbdf..2cb4fa54 100644
--- a/Dashboard/Controls/CurrentConfigContent.xaml
+++ b/Dashboard/Controls/CurrentConfigContent.xaml
@@ -15,7 +15,7 @@
             <MenuItem Header="Export to CSV..." Click="ExportToCsv_Click"/>
         </ContextMenu>
     </UserControl.Resources>
-    <TabControl>
+    <TabControl ItemContainerStyle="{DynamicResource SubTabItemStyle}">
         <!-- Current Server Configuration Sub-Tab -->
         <TabItem Header="Server Configuration">
             <Grid>
diff --git a/Dashboard/Controls/FinOpsContent.xaml b/Dashboard/Controls/FinOpsContent.xaml
index bfea5d36..e635803b 100644
--- a/Dashboard/Controls/FinOpsContent.xaml
+++ b/Dashboard/Controls/FinOpsContent.xaml
@@ -44,7 +44,7 @@
                       SelectionChanged="ServerSelector_SelectionChanged"/>
         </StackPanel>
 
-        <TabControl Grid.Row="1" Background="Transparent" BorderThickness="0">
+        <TabControl Grid.Row="1" Background="Transparent" BorderThickness="0" ItemContainerStyle="{DynamicResource SubTabItemStyle}">
 
         <!-- Recommendations Sub-Tab -->
         <TabItem Header="Recommendations">
diff --git a/Dashboard/Controls/MemoryContent.xaml b/Dashboard/Controls/MemoryContent.xaml
index 36db005e..45a0140e 100644
--- a/Dashboard/Controls/MemoryContent.xaml
+++ b/Dashboard/Controls/MemoryContent.xaml
@@ -32,7 +32,7 @@
         </ResourceDictionary>
     </UserControl.Resources>
 
-    <TabControl x:Name="SubTabControl" TabStripPlacement="Top" Margin="0,5,0,0">
+    <TabControl x:Name="SubTabControl" TabStripPlacement="Top" Margin="0,5,0,0" ItemContainerStyle="{DynamicResource SubTabItemStyle}">
         <!-- Memory Overview Sub-Tab -->
         <TabItem Header="Memory Overview">
             <!-- Chart + Summary Panel (grid removed) -->
diff --git a/Dashboard/Controls/MemoryContent.xaml.cs b/Dashboard/Controls/MemoryContent.xaml.cs
index 522a6005..bc07e18d 100644
--- a/Dashboard/Controls/MemoryContent.xaml.cs
+++ b/Dashboard/Controls/MemoryContent.xaml.cs
@@ -353,7 +353,7 @@ private void LoadMemoryStatsOverviewChart(List<MemoryStatsItem> memoryData, int
                 noDataText.LabelAlignment = ScottPlot.Alignment.MiddleCenter;
             }
 
-            MemoryStatsOverviewChart.Plot.Axes.DateTimeTicksBottom();
+            MemoryStatsOverviewChart.Plot.Axes.DateTimeTicksBottomDateChange();
             MemoryStatsOverviewChart.Plot.Axes.SetLimitsX(xMin, xMax);
             MemoryStatsOverviewChart.Plot.YLabel("MB");
             // Fixed negative space for legend
@@ -605,7 +605,7 @@ private void LoadMemoryGrantSizingChart(List<PoolGrantPoint> aggregated, int hou
                 MemoryGrantSizingChart.Plot.Legend.FontSize = 12;
             }
 
-            MemoryGrantSizingChart.Plot.Axes.DateTimeTicksBottom();
+            MemoryGrantSizingChart.Plot.Axes.DateTimeTicksBottomDateChange();
             MemoryGrantSizingChart.Plot.Axes.SetLimitsX(xMin, xMax);
             MemoryGrantSizingChart.Plot.YLabel("MB");
             MemoryGrantSizingChart.Plot.Axes.AutoScaleY();
@@ -675,7 +675,7 @@ private void LoadMemoryGrantActivityChart(List<PoolGrantPoint> aggregated, int h
                 MemoryGrantActivityChart.Plot.Legend.FontSize = 12;
             }
 
-            MemoryGrantActivityChart.Plot.Axes.DateTimeTicksBottom();
+            MemoryGrantActivityChart.Plot.Axes.DateTimeTicksBottomDateChange();
             MemoryGrantActivityChart.Plot.Axes.SetLimitsX(xMin, xMax);
             MemoryGrantActivityChart.Plot.YLabel("Count");
             MemoryGrantActivityChart.Plot.Axes.AutoScaleY();
@@ -856,7 +856,7 @@ private async System.Threading.Tasks.Task UpdateMemoryClerksChartFromPickerAsync
                     MemoryClerksTopText.Text = "N/A";
                 }
 
-                MemoryClerksChart.Plot.Axes.DateTimeTicksBottom();
+                MemoryClerksChart.Plot.Axes.DateTimeTicksBottomDateChange();
                 MemoryClerksChart.Plot.Axes.SetLimitsX(xMin, xMax);
                 MemoryClerksChart.Plot.YLabel("MB");
                 MemoryClerksChart.Plot.Axes.AutoScaleY();
@@ -1001,7 +1001,7 @@ private void LoadPlanCacheChart(IEnumerable<PlanCacheStatsItem> data, int hoursB
                 noDataText.LabelAlignment = ScottPlot.Alignment.MiddleCenter;
             }
 
-            PlanCacheChart.Plot.Axes.DateTimeTicksBottom();
+            PlanCacheChart.Plot.Axes.DateTimeTicksBottomDateChange();
             PlanCacheChart.Plot.Axes.SetLimitsX(xMin, xMax);
             PlanCacheChart.Plot.YLabel("MB");
             // Fixed negative space for legend
@@ -1120,7 +1120,7 @@ private void LoadMemoryPressureEventsChart(IEnumerable<MemoryPressureEventItem>
                 noDataText.LabelAlignment = ScottPlot.Alignment.MiddleCenter;
             }
 
-            MemoryPressureEventsChart.Plot.Axes.DateTimeTicksBottom();
+            MemoryPressureEventsChart.Plot.Axes.DateTimeTicksBottomDateChange();
             MemoryPressureEventsChart.Plot.Axes.SetLimitsX(xMin, xMax);
             MemoryPressureEventsChart.Plot.YLabel("Event Count");
             // Fixed negative space for legend
diff --git a/Dashboard/Controls/QueryPerformanceContent.xaml b/Dashboard/Controls/QueryPerformanceContent.xaml
index 0c1694ec..235f8efd 100644
--- a/Dashboard/Controls/QueryPerformanceContent.xaml
+++ b/Dashboard/Controls/QueryPerformanceContent.xaml
@@ -46,7 +46,7 @@
         </ResourceDictionary>
     </UserControl.Resources>
 
-    <TabControl x:Name="SubTabControl" TabStripPlacement="Top" Margin="0,5,0,0">
+    <TabControl x:Name="SubTabControl" TabStripPlacement="Top" Margin="0,5,0,0" ItemContainerStyle="{DynamicResource SubTabItemStyle}">
         <!-- Performance Trends Sub-Tab -->
         <TabItem Header="Performance Trends">
             <Grid>
diff --git a/Dashboard/Controls/QueryPerformanceContent.xaml.cs b/Dashboard/Controls/QueryPerformanceContent.xaml.cs
index 8417afa8..0099aba5 100644
--- a/Dashboard/Controls/QueryPerformanceContent.xaml.cs
+++ b/Dashboard/Controls/QueryPerformanceContent.xaml.cs
@@ -2437,7 +2437,7 @@ private void LoadDurationChart(WpfPlot chart, IEnumerable<DurationTrendItem> tre
                 _legendPanels[chart] = chart.Plot.ShowLegend(ScottPlot.Edge.Bottom);
                 chart.Plot.Legend.FontSize = 12;
 
-                chart.Plot.Axes.DateTimeTicksBottom();
+                chart.Plot.Axes.DateTimeTicksBottomDateChange();
                 chart.Plot.Axes.SetLimitsX(xMin, xMax);
                 chart.Plot.YLabel("Duration (ms/sec)");
                 TabHelpers.LockChartVerticalAxis(chart);
@@ -2492,7 +2492,7 @@ private void LoadExecChart(IEnumerable<ExecutionTrendItem> execTrends, int hours
             _legendPanels[QueryPerfTrendsExecChart] = QueryPerfTrendsExecChart.Plot.ShowLegend(ScottPlot.Edge.Bottom);
             QueryPerfTrendsExecChart.Plot.Legend.FontSize = 12;
 
-            QueryPerfTrendsExecChart.Plot.Axes.DateTimeTicksBottom();
+            QueryPerfTrendsExecChart.Plot.Axes.DateTimeTicksBottomDateChange();
             QueryPerfTrendsExecChart.Plot.Axes.SetLimitsX(xMin, xMax);
             QueryPerfTrendsExecChart.Plot.YLabel("Executions/sec");
             TabHelpers.LockChartVerticalAxis(QueryPerfTrendsExecChart);
diff --git a/Dashboard/Controls/ResourceMetricsContent.xaml b/Dashboard/Controls/ResourceMetricsContent.xaml
index 9bcdac6e..471c8b3e 100644
--- a/Dashboard/Controls/ResourceMetricsContent.xaml
+++ b/Dashboard/Controls/ResourceMetricsContent.xaml
@@ -25,7 +25,7 @@
         </ContextMenu>
     </UserControl.Resources>
 
-    <TabControl x:Name="SubTabControl" TabStripPlacement="Top" Margin="0,5,0,0">
+    <TabControl x:Name="SubTabControl" TabStripPlacement="Top" Margin="0,5,0,0" ItemContainerStyle="{DynamicResource SubTabItemStyle}">
         <!-- Server Trends Sub-Tab — Correlated Timeline Lanes -->
         <TabItem Header="Server Trends">
             <DockPanel>
@@ -148,7 +148,7 @@
 
         <!-- File I/O Sub-Tab -->
         <TabItem Header="File I/O">
-            <TabControl Background="Transparent" BorderThickness="0">
+            <TabControl Background="Transparent" BorderThickness="0" ItemContainerStyle="{DynamicResource SubTabItemStyle}">
                 <!-- File I/O Latency sub-tab -->
                 <TabItem Header="File I/O Latency">
                     <Grid Margin="5">
diff --git a/Dashboard/Controls/ResourceMetricsContent.xaml.cs b/Dashboard/Controls/ResourceMetricsContent.xaml.cs
index 74329671..bcc2d7c3 100644
--- a/Dashboard/Controls/ResourceMetricsContent.xaml.cs
+++ b/Dashboard/Controls/ResourceMetricsContent.xaml.cs
@@ -404,7 +404,7 @@ private void LoadLatchStatsChart(IEnumerable<LatchStatsItem> data, int hoursBack
                 noDataText.LabelAlignment = ScottPlot.Alignment.MiddleCenter;
             }
 
-            LatchStatsChart.Plot.Axes.DateTimeTicksBottom();
+            LatchStatsChart.Plot.Axes.DateTimeTicksBottomDateChange();
             LatchStatsChart.Plot.Axes.SetLimitsX(xMin, xMax);
             TabHelpers.SetChartYLimitsWithLegendPadding(LatchStatsChart);
             LatchStatsChart.Plot.YLabel("Wait Time (ms/sec)");
@@ -495,7 +495,7 @@ private void LoadSpinlockStatsChart(IEnumerable<SpinlockStatsItem> data, int hou
                 noDataText.LabelAlignment = ScottPlot.Alignment.MiddleCenter;
             }
 
-            SpinlockStatsChart.Plot.Axes.DateTimeTicksBottom();
+            SpinlockStatsChart.Plot.Axes.DateTimeTicksBottomDateChange();
             SpinlockStatsChart.Plot.Axes.SetLimitsX(xMin, xMax);
             TabHelpers.SetChartYLimitsWithLegendPadding(SpinlockStatsChart);
             SpinlockStatsChart.Plot.YLabel("Collisions/sec");
@@ -603,7 +603,7 @@ private void LoadCombinedTempDbLatencyChart(List<FileIoLatencyTimeSeriesItem> da
                 noDataText.LabelAlignment = ScottPlot.Alignment.MiddleCenter;
             }
 
-            TempDbLatencyChart.Plot.Axes.DateTimeTicksBottom();
+            TempDbLatencyChart.Plot.Axes.DateTimeTicksBottomDateChange();
             TempDbLatencyChart.Plot.Axes.SetLimitsX(xMin, xMax);
             TabHelpers.SetChartYLimitsWithLegendPadding(TempDbLatencyChart);
             TempDbLatencyChart.Plot.YLabel("Latency (ms)");
@@ -708,7 +708,7 @@ private void LoadTempdbStatsChart(IEnumerable<TempdbStatsItem> data, int hoursBa
                 noDataText.LabelAlignment = ScottPlot.Alignment.MiddleCenter;
             }
 
-            TempdbStatsChart.Plot.Axes.DateTimeTicksBottom();
+            TempdbStatsChart.Plot.Axes.DateTimeTicksBottomDateChange();
             TempdbStatsChart.Plot.Axes.SetLimitsX(xMin, xMax);
             TempdbStatsChart.Plot.Axes.AutoScaleY();
             TempdbStatsChart.Plot.YLabel("MB");
@@ -879,7 +879,7 @@ private void LoadSessionStatsChart(IEnumerable<SessionStatsItem> data, int hours
                 noDataText.LabelAlignment = ScottPlot.Alignment.MiddleCenter;
             }
 
-            SessionStatsChart.Plot.Axes.DateTimeTicksBottom();
+            SessionStatsChart.Plot.Axes.DateTimeTicksBottomDateChange();
             SessionStatsChart.Plot.Axes.SetLimitsX(xMin, xMax);
             TabHelpers.SetChartYLimitsWithLegendPadding(SessionStatsChart);
             SessionStatsChart.Plot.YLabel("Session Count");
@@ -1014,7 +1014,7 @@ private void LoadFileIoChart(ScottPlot.WPF.WpfPlot chart, List<FileIoLatencyTime
                 noDataText.LabelAlignment = ScottPlot.Alignment.MiddleCenter;
             }
 
-            chart.Plot.Axes.DateTimeTicksBottom();
+            chart.Plot.Axes.DateTimeTicksBottomDateChange();
             chart.Plot.Axes.SetLimitsX(xMin, xMax);
             chart.Plot.YLabel(yLabel);
             TabHelpers.LockChartVerticalAxis(chart);
@@ -1485,7 +1485,7 @@ private void LoadPerfmonCountersChart(List<PerfmonStatsItem>? data, int hoursBac
                 noDataText.LabelAlignment = ScottPlot.Alignment.MiddleCenter;
             }
 
-            PerfmonCountersChart.Plot.Axes.DateTimeTicksBottom();
+            PerfmonCountersChart.Plot.Axes.DateTimeTicksBottomDateChange();
             PerfmonCountersChart.Plot.Axes.SetLimitsX(xMin, xMax);
             TabHelpers.SetChartYLimitsWithLegendPadding(PerfmonCountersChart);
             PerfmonCountersChart.Plot.YLabel("Value/sec");
@@ -1816,7 +1816,7 @@ private void LoadWaitStatsDetailChart(List<WaitStatsDataPoint>? data, int hoursB
                 noDataText.LabelAlignment = ScottPlot.Alignment.MiddleCenter;
             }
 
-            WaitStatsDetailChart.Plot.Axes.DateTimeTicksBottom();
+            WaitStatsDetailChart.Plot.Axes.DateTimeTicksBottomDateChange();
             WaitStatsDetailChart.Plot.Axes.SetLimitsX(xMin, xMax);
             TabHelpers.SetChartYLimitsWithLegendPadding(WaitStatsDetailChart);
             WaitStatsDetailChart.Plot.YLabel(useAvgPerWait ? "Avg Wait Time (ms/wait)" : "Wait Time (ms/sec)");
diff --git a/Dashboard/Controls/SystemEventsContent.xaml b/Dashboard/Controls/SystemEventsContent.xaml
index 3434838c..6bbfb75a 100644
--- a/Dashboard/Controls/SystemEventsContent.xaml
+++ b/Dashboard/Controls/SystemEventsContent.xaml
@@ -31,7 +31,7 @@
         </ResourceDictionary>
     </UserControl.Resources>
 
-    <TabControl x:Name="SubTabControl" TabStripPlacement="Top" Margin="0,5,0,0">
+    <TabControl x:Name="SubTabControl" TabStripPlacement="Top" Margin="0,5,0,0" ItemContainerStyle="{DynamicResource SubTabItemStyle}">
         <!-- Overview Tab -->
         <TabItem Header="Corruption Events">
             <Grid Margin="10,5,10,10">
diff --git a/Dashboard/Controls/SystemEventsContent.xaml.cs b/Dashboard/Controls/SystemEventsContent.xaml.cs
index aa3e1c20..d24a2f56 100644
--- a/Dashboard/Controls/SystemEventsContent.xaml.cs
+++ b/Dashboard/Controls/SystemEventsContent.xaml.cs
@@ -528,7 +528,7 @@ private void LoadCorruptionEventsCharts(List<HealthParserSystemHealthItem> data,
                 noDataText.LabelFontColor = ScottPlot.Colors.Gray;
                 noDataText.LabelAlignment = ScottPlot.Alignment.MiddleCenter;
             }
-            BadPagesChart.Plot.Axes.DateTimeTicksBottom();
+            BadPagesChart.Plot.Axes.DateTimeTicksBottomDateChange();
             BadPagesChart.Plot.Axes.SetLimitsX(xMin, xMax);
             BadPagesChart.Plot.YLabel("Count");
             TabHelpers.LockChartVerticalAxis(BadPagesChart);
@@ -557,7 +557,7 @@ private void LoadCorruptionEventsCharts(List<HealthParserSystemHealthItem> data,
                 noDataText.LabelFontColor = ScottPlot.Colors.Gray;
                 noDataText.LabelAlignment = ScottPlot.Alignment.MiddleCenter;
             }
-            DumpRequestsChart.Plot.Axes.DateTimeTicksBottom();
+            DumpRequestsChart.Plot.Axes.DateTimeTicksBottomDateChange();
             DumpRequestsChart.Plot.Axes.SetLimitsX(xMin, xMax);
             DumpRequestsChart.Plot.YLabel("Count");
             TabHelpers.LockChartVerticalAxis(DumpRequestsChart);
@@ -586,7 +586,7 @@ private void LoadCorruptionEventsCharts(List<HealthParserSystemHealthItem> data,
                 noDataText.LabelFontColor = ScottPlot.Colors.Gray;
                 noDataText.LabelAlignment = ScottPlot.Alignment.MiddleCenter;
             }
-            AccessViolationsChart.Plot.Axes.DateTimeTicksBottom();
+            AccessViolationsChart.Plot.Axes.DateTimeTicksBottomDateChange();
             AccessViolationsChart.Plot.Axes.SetLimitsX(xMin, xMax);
             AccessViolationsChart.Plot.YLabel("Count");
             TabHelpers.LockChartVerticalAxis(AccessViolationsChart);
@@ -615,7 +615,7 @@ private void LoadCorruptionEventsCharts(List<HealthParserSystemHealthItem> data,
                 noDataText.LabelFontColor = ScottPlot.Colors.Gray;
                 noDataText.LabelAlignment = ScottPlot.Alignment.MiddleCenter;
             }
-            WriteAccessViolationsChart.Plot.Axes.DateTimeTicksBottom();
+            WriteAccessViolationsChart.Plot.Axes.DateTimeTicksBottomDateChange();
             WriteAccessViolationsChart.Plot.Axes.SetLimitsX(xMin, xMax);
             WriteAccessViolationsChart.Plot.YLabel("Count");
             TabHelpers.LockChartVerticalAxis(WriteAccessViolationsChart);
@@ -656,7 +656,7 @@ private void LoadContentionEventsCharts(List<HealthParserSystemHealthItem> data,
                 noDataText.LabelFontColor = ScottPlot.Colors.Gray;
                 noDataText.LabelAlignment = ScottPlot.Alignment.MiddleCenter;
             }
-            NonYieldingTasksChart.Plot.Axes.DateTimeTicksBottom();
+            NonYieldingTasksChart.Plot.Axes.DateTimeTicksBottomDateChange();
             NonYieldingTasksChart.Plot.Axes.SetLimitsX(xMin, xMax);
             NonYieldingTasksChart.Plot.YLabel("Count");
             TabHelpers.LockChartVerticalAxis(NonYieldingTasksChart);
@@ -685,7 +685,7 @@ private void LoadContentionEventsCharts(List<HealthParserSystemHealthItem> data,
                 noDataText.LabelFontColor = ScottPlot.Colors.Gray;
                 noDataText.LabelAlignment = ScottPlot.Alignment.MiddleCenter;
             }
-            LatchWarningsChart.Plot.Axes.DateTimeTicksBottom();
+            LatchWarningsChart.Plot.Axes.DateTimeTicksBottomDateChange();
             LatchWarningsChart.Plot.Axes.SetLimitsX(xMin, xMax);
             LatchWarningsChart.Plot.YLabel("Count");
             TabHelpers.LockChartVerticalAxis(LatchWarningsChart);
@@ -748,7 +748,7 @@ private void LoadContentionEventsCharts(List<HealthParserSystemHealthItem> data,
                 noDataText.LabelFontColor = ScottPlot.Colors.Gray;
                 noDataText.LabelAlignment = ScottPlot.Alignment.MiddleCenter;
             }
-            SickSpinlocksChart.Plot.Axes.DateTimeTicksBottom();
+            SickSpinlocksChart.Plot.Axes.DateTimeTicksBottomDateChange();
             SickSpinlocksChart.Plot.Axes.SetLimitsX(xMin, xMax);
             SickSpinlocksChart.Plot.YLabel("Backoffs");
             TabHelpers.LockChartVerticalAxis(SickSpinlocksChart);
@@ -798,7 +798,7 @@ private void LoadContentionEventsCharts(List<HealthParserSystemHealthItem> data,
                 noDataText.LabelFontColor = ScottPlot.Colors.Gray;
                 noDataText.LabelAlignment = ScottPlot.Alignment.MiddleCenter;
             }
-            CpuComparisonChart.Plot.Axes.DateTimeTicksBottom();
+            CpuComparisonChart.Plot.Axes.DateTimeTicksBottomDateChange();
             CpuComparisonChart.Plot.Axes.SetLimitsX(xMin, xMax);
             CpuComparisonChart.Plot.Axes.SetLimitsY(0, 100); // Fixed Y-axis for CPU percentage
             CpuComparisonChart.Plot.YLabel("CPU %");
@@ -899,7 +899,7 @@ private void LoadSevereErrorsChart(IEnumerable<HealthParserSevereErrorItem> data
                 noDataText.LabelAlignment = ScottPlot.Alignment.MiddleCenter;
             }
 
-            SevereErrorsChart.Plot.Axes.DateTimeTicksBottom();
+            SevereErrorsChart.Plot.Axes.DateTimeTicksBottomDateChange();
             SevereErrorsChart.Plot.Axes.SetLimitsX(xMin, xMax);
             SevereErrorsChart.Plot.YLabel("Event Count");
             TabHelpers.LockChartVerticalAxis(SevereErrorsChart);
@@ -1058,7 +1058,7 @@ private void LoadIOIssuesChart(IEnumerable<HealthParserIOIssueItem> data, int ho
                 noDataText.LabelAlignment = ScottPlot.Alignment.MiddleCenter;
             }
 
-            IOIssuesChart.Plot.Axes.DateTimeTicksBottom();
+            IOIssuesChart.Plot.Axes.DateTimeTicksBottomDateChange();
             IOIssuesChart.Plot.Axes.SetLimitsX(xMin, xMax);
             IOIssuesChart.Plot.YLabel("Count");
             TabHelpers.LockChartVerticalAxis(IOIssuesChart);
@@ -1152,7 +1152,7 @@ private void LoadLongestPendingIOChart(IEnumerable<HealthParserIOIssueItem> data
                 noDataText.LabelAlignment = ScottPlot.Alignment.MiddleCenter;
             }
 
-            LongestPendingIOChart.Plot.Axes.DateTimeTicksBottom();
+            LongestPendingIOChart.Plot.Axes.DateTimeTicksBottomDateChange();
             LongestPendingIOChart.Plot.Axes.SetLimitsX(xMin, xMax);
             LongestPendingIOChart.Plot.YLabel("Duration (ms)");
             TabHelpers.LockChartVerticalAxis(LongestPendingIOChart);
@@ -1251,7 +1251,7 @@ long ParseNonYield(string? value)
                 noDataText.LabelAlignment = ScottPlot.Alignment.MiddleCenter;
             }
 
-            SchedulerIssuesChart.Plot.Axes.DateTimeTicksBottom();
+            SchedulerIssuesChart.Plot.Axes.DateTimeTicksBottomDateChange();
             SchedulerIssuesChart.Plot.Axes.SetLimitsX(xMin, xMax);
             SchedulerIssuesChart.Plot.YLabel("Total Non-Yield Time (ms)");
             TabHelpers.LockChartVerticalAxis(SchedulerIssuesChart);
@@ -1401,7 +1401,7 @@ private void LoadMemoryConditionsChart(IEnumerable<HealthParserMemoryConditionIt
                 noDataText.LabelAlignment = ScottPlot.Alignment.MiddleCenter;
             }
 
-            MemoryConditionsChart.Plot.Axes.DateTimeTicksBottom();
+            MemoryConditionsChart.Plot.Axes.DateTimeTicksBottomDateChange();
             MemoryConditionsChart.Plot.Axes.SetLimitsX(xMin, xMax);
             MemoryConditionsChart.Plot.YLabel("Count");
             TabHelpers.LockChartVerticalAxis(MemoryConditionsChart);
@@ -1573,7 +1573,7 @@ private void LoadCPUTasksChart(IEnumerable<HealthParserCPUTasksItem> data, int h
                 noDataText.LabelAlignment = ScottPlot.Alignment.MiddleCenter;
             }
 
-            CPUTasksChart.Plot.Axes.DateTimeTicksBottom();
+            CPUTasksChart.Plot.Axes.DateTimeTicksBottomDateChange();
             CPUTasksChart.Plot.Axes.SetLimitsX(xMin, xMax);
             CPUTasksChart.Plot.YLabel("Workers");
             TabHelpers.LockChartVerticalAxis(CPUTasksChart);
@@ -1780,7 +1780,7 @@ private void LoadMemoryBrokerChart(IEnumerable<HealthParserMemoryBrokerItem> dat
             /* Finalize both charts */
             foreach (var chart in new[] { MemoryBrokerChart, MemoryBrokerRatioChart })
             {
-                chart.Plot.Axes.DateTimeTicksBottom();
+                chart.Plot.Axes.DateTimeTicksBottomDateChange();
                 chart.Plot.Axes.SetLimitsX(xMin, xMax);
                 TabHelpers.LockChartVerticalAxis(chart);
                 chart.Refresh();
@@ -1933,7 +1933,7 @@ private void LoadMemoryNodeOOMChart(IEnumerable<HealthParserMemoryNodeOOMItem> d
                 noDataText.LabelAlignment = ScottPlot.Alignment.MiddleCenter;
             }
 
-            MemoryNodeOOMChart.Plot.Axes.DateTimeTicksBottom();
+            MemoryNodeOOMChart.Plot.Axes.DateTimeTicksBottomDateChange();
             MemoryNodeOOMChart.Plot.Axes.SetLimitsX(xMin, xMax);
             MemoryNodeOOMChart.Plot.YLabel("Event Count");
             TabHelpers.LockChartVerticalAxis(MemoryNodeOOMChart);
@@ -1983,7 +1983,7 @@ private void LoadMemoryNodeOOMUtilChart(IEnumerable<HealthParserMemoryNodeOOMIte
                 noDataText.LabelAlignment = ScottPlot.Alignment.MiddleCenter;
             }
 
-            MemoryNodeOOMUtilChart.Plot.Axes.DateTimeTicksBottom();
+            MemoryNodeOOMUtilChart.Plot.Axes.DateTimeTicksBottomDateChange();
             MemoryNodeOOMUtilChart.Plot.Axes.SetLimitsX(xMin, xMax);
             TabHelpers.LockChartVerticalAxis(MemoryNodeOOMUtilChart);
             MemoryNodeOOMUtilChart.Refresh();
@@ -2086,7 +2086,7 @@ private void LoadMemoryNodeOOMMemoryChart(IEnumerable<HealthParserMemoryNodeOOMI
                 noDataText.LabelAlignment = ScottPlot.Alignment.MiddleCenter;
             }
 
-            MemoryNodeOOMMemoryChart.Plot.Axes.DateTimeTicksBottom();
+            MemoryNodeOOMMemoryChart.Plot.Axes.DateTimeTicksBottomDateChange();
             MemoryNodeOOMMemoryChart.Plot.Axes.SetLimitsX(xMin, xMax);
             TabHelpers.LockChartVerticalAxis(MemoryNodeOOMMemoryChart);
             MemoryNodeOOMMemoryChart.Refresh();
diff --git a/Dashboard/Helpers/AxesExtensions.cs b/Dashboard/Helpers/AxesExtensions.cs
new file mode 100644
index 00000000..a1d1b7db
--- /dev/null
+++ b/Dashboard/Helpers/AxesExtensions.cs
@@ -0,0 +1,45 @@
+using System;
+using System.Globalization;
+using System.Text.RegularExpressions;
+
+namespace PerformanceMonitorDashboard.Helpers;
+
+internal static class AxesExtensions
+{
+    /// <summary>Culture's short-date pattern with the year component removed (e.g. "M/d" en-US, "dd/MM" en-GB, "dd.MM" de-DE).</summary>
+    private static readonly string MonthDayPattern = BuildMonthDayPattern();
+
+    private static string BuildMonthDayPattern()
+    {
+        var p = CultureInfo.CurrentCulture.DateTimeFormat.ShortDatePattern;
+        p = Regex.Replace(p, @"y+", "");
+        p = Regex.Replace(p, @"^[\s/.\-]+|[\s/.\-]+$", "");
+        p = Regex.Replace(p, @"([/.\-\s])\1+", "$1");
+        return string.IsNullOrWhiteSpace(p) ? "M/d" : p;
+    }
+
+    /// <summary>
+    /// Like <c>DateTimeTicksBottom()</c>, but prints the date line on only the first tick
+    /// and on ticks where the date component changes. All other ticks show time-only.
+    /// Date and time formats follow the current culture.
+    /// </summary>
+    public static void DateTimeTicksBottomDateChange(this ScottPlot.AxisManager axes)
+    {
+        axes.DateTimeTicksBottom();
+        if (axes.Bottom.TickGenerator is ScottPlot.TickGenerators.DateTimeAutomatic gen)
+        {
+            DateTime? lastDate = null;
+            var culture = CultureInfo.CurrentCulture;
+            gen.LabelFormatter = dt =>
+            {
+                var time = dt.ToString("t", culture);
+                if (lastDate is null || dt.Date != lastDate.Value)
+                {
+                    lastDate = dt.Date;
+                    return $"{dt.ToString(MonthDayPattern, culture)}\n{time}";
+                }
+                return time;
+            };
+        }
+    }
+}
diff --git a/Dashboard/Helpers/CorrelatedCrosshairManager.cs b/Dashboard/Helpers/CorrelatedCrosshairManager.cs
index c49b0a7b..80e2ec7d 100644
--- a/Dashboard/Helpers/CorrelatedCrosshairManager.cs
+++ b/Dashboard/Helpers/CorrelatedCrosshairManager.cs
@@ -350,7 +350,7 @@ public void Dispose()
         _lanes.Clear();
     }
 
-    private class DataSeries
+    private sealed class DataSeries
     {
         public string Name { get; set; } = "";
         public string? Unit { get; set; }
@@ -359,7 +359,7 @@ private class DataSeries
         public bool IsEventBased { get; set; }
     }
 
-    private class LaneInfo
+    private sealed class LaneInfo
     {
         public ScottPlot.WPF.WpfPlot Chart { get; set; } = null!;
         public string Label { get; set; } = "";
diff --git a/Dashboard/Helpers/TabHelpers.cs b/Dashboard/Helpers/TabHelpers.cs
index 70f6533d..61319272 100644
--- a/Dashboard/Helpers/TabHelpers.cs
+++ b/Dashboard/Helpers/TabHelpers.cs
@@ -200,6 +200,8 @@ public static void ApplyThemeToChart(WpfPlot chart)
             chart.Plot.Axes.Left.TickLabelStyle.ForeColor = textColor;
             chart.Plot.Axes.Bottom.Label.ForeColor = textColor;
             chart.Plot.Axes.Left.Label.ForeColor = textColor;
+            chart.Plot.Axes.Bottom.TickLabelStyle.FontSize = 13;
+            chart.Plot.Axes.Left.TickLabelStyle.FontSize = 13;
 
             // Set the WPF control Background to match so no white flash appears before ScottPlot's render loop fires
             chart.Background = new SolidColorBrush(Color.FromRgb(figureBackground.R, figureBackground.G, figureBackground.B));
@@ -234,6 +236,8 @@ public static void ReapplyAxisColors(WpfPlot chart)
             chart.Plot.Axes.Left.TickLabelStyle.ForeColor = textColor;
             chart.Plot.Axes.Bottom.Label.ForeColor = textColor;
             chart.Plot.Axes.Left.Label.ForeColor = textColor;
+            chart.Plot.Axes.Bottom.TickLabelStyle.FontSize = 13;
+            chart.Plot.Axes.Left.TickLabelStyle.FontSize = 13;
         }
 
         /// <summary>
diff --git a/Dashboard/ProcedureHistoryWindow.xaml.cs b/Dashboard/ProcedureHistoryWindow.xaml.cs
index 0875f951..057e07d6 100644
--- a/Dashboard/ProcedureHistoryWindow.xaml.cs
+++ b/Dashboard/ProcedureHistoryWindow.xaml.cs
@@ -210,7 +210,7 @@ private void UpdateChart()
                 scatter.MarkerSize = 4;
             }
 
-            HistoryChart.Plot.Axes.DateTimeTicksBottom();
+            HistoryChart.Plot.Axes.DateTimeTicksBottomDateChange();
             Helpers.TabHelpers.ReapplyAxisColors(HistoryChart);
             HistoryChart.Plot.YLabel(metricLabel);
             HistoryChart.Plot.XLabel("Collection Time");
diff --git a/Dashboard/QueryExecutionHistoryWindow.xaml.cs b/Dashboard/QueryExecutionHistoryWindow.xaml.cs
index 33f70367..dcdc277d 100644
--- a/Dashboard/QueryExecutionHistoryWindow.xaml.cs
+++ b/Dashboard/QueryExecutionHistoryWindow.xaml.cs
@@ -226,7 +226,7 @@ private void UpdateChart()
                 colorIndex++;
             }
 
-            HistoryChart.Plot.Axes.DateTimeTicksBottom();
+            HistoryChart.Plot.Axes.DateTimeTicksBottomDateChange();
             Helpers.TabHelpers.ReapplyAxisColors(HistoryChart);
             HistoryChart.Plot.YLabel(metricLabel);
             HistoryChart.Plot.XLabel("Collection Time");
diff --git a/Dashboard/QueryStatsHistoryWindow.xaml.cs b/Dashboard/QueryStatsHistoryWindow.xaml.cs
index 755c823d..7f428289 100644
--- a/Dashboard/QueryStatsHistoryWindow.xaml.cs
+++ b/Dashboard/QueryStatsHistoryWindow.xaml.cs
@@ -202,7 +202,7 @@ private void UpdateChart()
                 scatter.MarkerSize = 4;
             }
 
-            HistoryChart.Plot.Axes.DateTimeTicksBottom();
+            HistoryChart.Plot.Axes.DateTimeTicksBottomDateChange();
             Helpers.TabHelpers.ReapplyAxisColors(HistoryChart);
             HistoryChart.Plot.YLabel(metricLabel);
             HistoryChart.Plot.XLabel("Collection Time");
diff --git a/Dashboard/ServerTab.xaml b/Dashboard/ServerTab.xaml
index e6927176..5c3f601a 100644
--- a/Dashboard/ServerTab.xaml
+++ b/Dashboard/ServerTab.xaml
@@ -163,7 +163,7 @@
         <TabControl Grid.Row="1" x:Name="DataTabControl" Margin="10,0,10,0" SelectionChanged="DataTabControl_SelectionChanged">
             <!-- Overview Tab - At-a-glance health and status -->
             <TabItem Header="Overview">
-                <TabControl>
+                <TabControl ItemContainerStyle="{DynamicResource SubTabItemStyle}">
                     <!-- Resource Overview Sub-Tab - Consolidated view of CPU, Memory, I/O, Waits -->
                     <TabItem Header="Resource Overview">
                         <!-- 2x2 Chart Grid -->
@@ -255,7 +255,7 @@
 
                     <!-- Collection Health Sub-Tab -->
                     <TabItem Header="Collection Health">
-                        <TabControl>
+                        <TabControl ItemContainerStyle="{DynamicResource SubTabItemStyle}">
                             <TabItem Header="Health Summary">
                                 <Grid>
                                     <DataGrid x:Name="HealthDataGrid"
@@ -498,7 +498,7 @@
                         </Border>
                     </StackPanel>
                 </TabItem.Header>
-                <TabControl x:Name="LockingSubTabControl">
+                <TabControl x:Name="LockingSubTabControl" ItemContainerStyle="{DynamicResource SubTabItemStyle}">
                     <!-- Blocking/Deadlock Stats Sub-Tab (default tab) -->
                     <TabItem Header="Blocking/Deadlock Trends">
                         <Grid>
diff --git a/Dashboard/ServerTab.xaml.cs b/Dashboard/ServerTab.xaml.cs
index 6c9f7b1f..e793be13 100644
--- a/Dashboard/ServerTab.xaml.cs
+++ b/Dashboard/ServerTab.xaml.cs
@@ -2253,7 +2253,7 @@ private void LoadBlockingStatsCharts(List<BlockingDeadlockStatsItem> data, int h
                 noDataText.LabelFontColor = ScottPlot.Colors.Gray;
                 noDataText.LabelAlignment = ScottPlot.Alignment.MiddleCenter;
             }
-            BlockingStatsBlockingEventsChart.Plot.Axes.DateTimeTicksBottom();
+            BlockingStatsBlockingEventsChart.Plot.Axes.DateTimeTicksBottomDateChange();
             BlockingStatsBlockingEventsChart.Plot.Axes.SetLimitsX(xMin, xMax);
             BlockingStatsBlockingEventsChart.Plot.YLabel("Count");
             LockChartVerticalAxis(BlockingStatsBlockingEventsChart);
@@ -2282,7 +2282,7 @@ private void LoadBlockingStatsCharts(List<BlockingDeadlockStatsItem> data, int h
                 noDataText.LabelFontColor = ScottPlot.Colors.Gray;
                 noDataText.LabelAlignment = ScottPlot.Alignment.MiddleCenter;
             }
-            BlockingStatsDurationChart.Plot.Axes.DateTimeTicksBottom();
+            BlockingStatsDurationChart.Plot.Axes.DateTimeTicksBottomDateChange();
             BlockingStatsDurationChart.Plot.Axes.SetLimitsX(xMin, xMax);
             BlockingStatsDurationChart.Plot.YLabel("Duration (ms)");
             LockChartVerticalAxis(BlockingStatsDurationChart);
@@ -2311,7 +2311,7 @@ private void LoadBlockingStatsCharts(List<BlockingDeadlockStatsItem> data, int h
                 noDataText.LabelFontColor = ScottPlot.Colors.Gray;
                 noDataText.LabelAlignment = ScottPlot.Alignment.MiddleCenter;
             }
-            BlockingStatsDeadlocksChart.Plot.Axes.DateTimeTicksBottom();
+            BlockingStatsDeadlocksChart.Plot.Axes.DateTimeTicksBottomDateChange();
             BlockingStatsDeadlocksChart.Plot.Axes.SetLimitsX(xMin, xMax);
             BlockingStatsDeadlocksChart.Plot.YLabel("Count");
             LockChartVerticalAxis(BlockingStatsDeadlocksChart);
@@ -2340,7 +2340,7 @@ private void LoadBlockingStatsCharts(List<BlockingDeadlockStatsItem> data, int h
                 noDataText.LabelFontColor = ScottPlot.Colors.Gray;
                 noDataText.LabelAlignment = ScottPlot.Alignment.MiddleCenter;
             }
-            BlockingStatsDeadlockWaitTimeChart.Plot.Axes.DateTimeTicksBottom();
+            BlockingStatsDeadlockWaitTimeChart.Plot.Axes.DateTimeTicksBottomDateChange();
             BlockingStatsDeadlockWaitTimeChart.Plot.Axes.SetLimitsX(xMin, xMax);
             BlockingStatsDeadlockWaitTimeChart.Plot.YLabel("Duration (ms)");
             LockChartVerticalAxis(BlockingStatsDeadlockWaitTimeChart);
@@ -2386,7 +2386,7 @@ private void UpdateCollectorDurationChart(List<CollectionLogEntry> data)
                 colorIndex++;
             }
 
-            CollectorDurationChart.Plot.Axes.DateTimeTicksBottom();
+            CollectorDurationChart.Plot.Axes.DateTimeTicksBottomDateChange();
             TabHelpers.ReapplyAxisColors(CollectorDurationChart);
             CollectorDurationChart.Plot.YLabel("Duration (ms)");
             CollectorDurationChart.Plot.Axes.AutoScale();
@@ -2449,7 +2449,7 @@ private void LoadLockWaitStatsChart(List<LockWaitStatsItem> data, int hoursBack,
                 noDataText.LabelAlignment = ScottPlot.Alignment.MiddleCenter;
             }
 
-            LockWaitStatsChart.Plot.Axes.DateTimeTicksBottom();
+            LockWaitStatsChart.Plot.Axes.DateTimeTicksBottomDateChange();
             LockWaitStatsChart.Plot.Axes.SetLimitsX(xMin, xMax);
             LockWaitStatsChart.Plot.YLabel("Wait Time (ms/sec)");
             _legendPanels[LockWaitStatsChart] = LockWaitStatsChart.Plot.ShowLegend(ScottPlot.Edge.Bottom);
@@ -2506,7 +2506,7 @@ private void LoadCurrentWaitsDurationChart(List<WaitingTaskTrendItem> data, int
                 noDataText.LabelAlignment = ScottPlot.Alignment.MiddleCenter;
             }
 
-            CurrentWaitsDurationChart.Plot.Axes.DateTimeTicksBottom();
+            CurrentWaitsDurationChart.Plot.Axes.DateTimeTicksBottomDateChange();
             CurrentWaitsDurationChart.Plot.Axes.SetLimitsX(xMin, xMax);
             CurrentWaitsDurationChart.Plot.YLabel("Total Wait Duration (ms)");
             _legendPanels[CurrentWaitsDurationChart] = CurrentWaitsDurationChart.Plot.ShowLegend(ScottPlot.Edge.Bottom);
@@ -2563,7 +2563,7 @@ private void LoadCurrentWaitsBlockedChart(List<BlockedSessionTrendItem> data, in
                 noDataText.LabelAlignment = ScottPlot.Alignment.MiddleCenter;
             }
 
-            CurrentWaitsBlockedChart.Plot.Axes.DateTimeTicksBottom();
+            CurrentWaitsBlockedChart.Plot.Axes.DateTimeTicksBottomDateChange();
             CurrentWaitsBlockedChart.Plot.Axes.SetLimitsX(xMin, xMax);
             CurrentWaitsBlockedChart.Plot.YLabel("Blocked Sessions");
             _legendPanels[CurrentWaitsBlockedChart] = CurrentWaitsBlockedChart.Plot.ShowLegend(ScottPlot.Edge.Bottom);
@@ -2903,7 +2903,7 @@ private void LoadResourceOverviewCpuChart(IEnumerable<CpuDataPoint> cpuData, int
                 noDataText.LabelAlignment = ScottPlot.Alignment.MiddleCenter;
             }
 
-            ResourceOverviewCpuChart.Plot.Axes.DateTimeTicksBottom();
+            ResourceOverviewCpuChart.Plot.Axes.DateTimeTicksBottomDateChange();
             ResourceOverviewCpuChart.Plot.Axes.SetLimitsX(xMin, xMax);
             ResourceOverviewCpuChart.Plot.Axes.SetLimitsY(0, 100);
             ResourceOverviewCpuChart.Plot.YLabel("CPU %");
@@ -2966,7 +2966,7 @@ private void LoadResourceOverviewMemoryChart(IEnumerable<MemoryDataPoint> memory
                 noDataText.LabelAlignment = ScottPlot.Alignment.MiddleCenter;
             }
 
-            ResourceOverviewMemoryChart.Plot.Axes.DateTimeTicksBottom();
+            ResourceOverviewMemoryChart.Plot.Axes.DateTimeTicksBottomDateChange();
             ResourceOverviewMemoryChart.Plot.Axes.SetLimitsX(xMin, xMax);
             ResourceOverviewMemoryChart.Plot.YLabel("MB");
             LockChartVerticalAxis(ResourceOverviewMemoryChart);
@@ -3043,7 +3043,7 @@ private void LoadResourceOverviewIoChart(IEnumerable<FileIoDataPoint> ioData, in
                 noDataText.LabelAlignment = ScottPlot.Alignment.MiddleCenter;
             }
 
-            ResourceOverviewIoChart.Plot.Axes.DateTimeTicksBottom();
+            ResourceOverviewIoChart.Plot.Axes.DateTimeTicksBottomDateChange();
             ResourceOverviewIoChart.Plot.Axes.SetLimitsX(xMin, xMax);
             ResourceOverviewIoChart.Plot.Axes.AutoScaleY();
             ResourceOverviewIoChart.Plot.YLabel("Latency (ms)");
@@ -3115,7 +3115,7 @@ private void LoadResourceOverviewWaitChart(IEnumerable<WaitStatsDataPoint> waitD
                 noDataText.LabelAlignment = ScottPlot.Alignment.MiddleCenter;
             }
 
-            ResourceOverviewWaitChart.Plot.Axes.DateTimeTicksBottom();
+            ResourceOverviewWaitChart.Plot.Axes.DateTimeTicksBottomDateChange();
             ResourceOverviewWaitChart.Plot.Axes.SetLimitsX(xMin, xMax);
             ResourceOverviewWaitChart.Plot.Axes.AutoScaleY();
             ResourceOverviewWaitChart.Plot.YLabel("Wait Time (ms/sec)");
diff --git a/Dashboard/Services/BenefitScorer.cs b/Dashboard/Services/BenefitScorer.cs
index 1acf26cf..94606aba 100644
--- a/Dashboard/Services/BenefitScorer.cs
+++ b/Dashboard/Services/BenefitScorer.cs
@@ -616,20 +616,20 @@ internal static string ClassifyWaitType(string waitType)
         var wt = waitType.ToUpperInvariant();
         return wt switch
         {
-            _ when wt.StartsWith("PAGEIOLATCH") => "I/O",
-            _ when wt.Contains("IO_COMPLETION") => "I/O",
-            _ when wt.StartsWith("WRITELOG") => "I/O",
+            _ when wt.StartsWith("PAGEIOLATCH", StringComparison.Ordinal) => "I/O",
+            _ when wt.Contains("IO_COMPLETION", StringComparison.Ordinal) => "I/O",
+            _ when wt.StartsWith("WRITELOG", StringComparison.Ordinal) => "I/O",
             _ when wt == "SOS_SCHEDULER_YIELD" => "CPU",
-            _ when wt.StartsWith("CXPACKET") || wt.StartsWith("CXCONSUMER") => "Parallelism",
-            _ when wt.StartsWith("CXSYNC") => "Parallelism",
-            _ when wt.StartsWith("HT") => "Hash",
+            _ when wt.StartsWith("CXPACKET", StringComparison.Ordinal) || wt.StartsWith("CXCONSUMER", StringComparison.Ordinal) => "Parallelism",
+            _ when wt.StartsWith("CXSYNC", StringComparison.Ordinal) => "Parallelism",
+            _ when wt.StartsWith("HT", StringComparison.Ordinal) => "Hash",
             _ when wt == "BPSORT" => "Sort",
             _ when wt == "BMPBUILD" => "Hash",
-            _ when wt.StartsWith("PAGELATCH") => "Latch",
-            _ when wt.StartsWith("LATCH_") => "Latch",
-            _ when wt.StartsWith("LCK_") => "Lock",
+            _ when wt.StartsWith("PAGELATCH", StringComparison.Ordinal) => "Latch",
+            _ when wt.StartsWith("LATCH_", StringComparison.Ordinal) => "Latch",
+            _ when wt.StartsWith("LCK_", StringComparison.Ordinal) => "Lock",
             _ when wt == "ASYNC_NETWORK_IO" => "Network",
-            _ when wt.Contains("MEMORY_ALLOCATION") => "Memory",
+            _ when wt.Contains("MEMORY_ALLOCATION", StringComparison.Ordinal) => "Memory",
             _ when wt == "SOS_PHYS_PAGE_CACHE" => "Memory",
             _ => "Other"
         };
diff --git a/Dashboard/Services/PlanAnalyzer.cs b/Dashboard/Services/PlanAnalyzer.cs
index 254246d5..1f153ee5 100644
--- a/Dashboard/Services/PlanAnalyzer.cs
+++ b/Dashboard/Services/PlanAnalyzer.cs
@@ -253,7 +253,7 @@ private static void AnalyzeStatement(PlanStatement stmt)
 
             if (unsnifffedParams.Count > 0)
             {
-                var hasRecompile = stmt.StatementText.Contains("RECOMPILE", StringComparison.OrdinalIgnoreCase);
+                var hasRecompile = (stmt.StatementText ?? "").Contains("RECOMPILE", StringComparison.OrdinalIgnoreCase);
                 if (!hasRecompile)
                 {
                     var names = string.Join(", ", unsnifffedParams.Select(p => p.Name));
@@ -1099,7 +1099,7 @@ _ when nonSargableReason.StartsWith("Function call", StringComparison.OrdinalIgn
         // Rule 28: Row Count Spool — NOT IN with nullable column
         // Pattern: Row Count Spool with high rewinds, child scan has IS NULL predicate,
         // and statement text contains NOT IN
-        if (node.PhysicalOp.Contains("Row Count Spool"))
+        if ((node.PhysicalOp ?? "").Contains("Row Count Spool", StringComparison.Ordinal))
         {
             var rewinds = node.HasActualStats ? (double)node.ActualRewinds : node.EstimateRewinds;
             if (rewinds > 10000 && HasNotInPattern(node, stmt))
@@ -1118,7 +1118,7 @@ _ when nonSargableReason.StartsWith("Function call", StringComparison.OrdinalIgn
         if (!(node.HasActualStats && node.ActualExecutions == 0))
         foreach (var w in node.Warnings.ToList())
         {
-            if (w.WarningType == "Implicit Conversion" && w.Message.StartsWith("Seek Plan"))
+            if (w.WarningType == "Implicit Conversion" && w.Message.StartsWith("Seek Plan", StringComparison.Ordinal))
             {
                 w.Severity = PlanWarningSeverity.Critical;
                 w.Message = $"Implicit conversion prevented an index seek, forcing a scan instead. Fix the data type mismatch: ensure the parameter or variable type matches the column type exactly. {w.Message}";
@@ -1828,7 +1828,7 @@ private static bool AllocatesResources(PlanNode node)
             || op.EndsWith("Spool", StringComparison.OrdinalIgnoreCase);
     }
 
-    private record ScanImpact(double CostPct, double ElapsedPct, string? Summary);
+    private sealed record ScanImpact(double CostPct, double ElapsedPct, string? Summary);
 
     /// <summary>
     /// Builds impact details for a scan node: what % of plan time/cost it represents,
diff --git a/Dashboard/Themes/CoolBreezeTheme.xaml b/Dashboard/Themes/CoolBreezeTheme.xaml
index 933d65e4..36437cbc 100644
--- a/Dashboard/Themes/CoolBreezeTheme.xaml
+++ b/Dashboard/Themes/CoolBreezeTheme.xaml
@@ -644,6 +644,40 @@
         </Setter>
     </Style>
 
+    <!-- Sub-tab style: thin accent underline instead of filled background, so the hierarchy
+         reads at a glance when a main tab's sub-tabs are shown alongside the main tab bar. -->
+    <Style x:Key="SubTabItemStyle" TargetType="TabItem">
+        <Setter Property="Background" Value="Transparent"/>
+        <Setter Property="Foreground" Value="{StaticResource ForegroundDimBrush}"/>
+        <Setter Property="BorderThickness" Value="0"/>
+        <Setter Property="Padding" Value="10,6"/>
+        <Setter Property="Margin" Value="0,0,4,0"/>
+        <Setter Property="Template">
+            <Setter.Value>
+                <ControlTemplate TargetType="TabItem">
+                    <Border x:Name="border"
+                            Background="{TemplateBinding Background}"
+                            BorderBrush="{StaticResource AccentBrush}"
+                            BorderThickness="0"
+                            Padding="{TemplateBinding Padding}">
+                        <ContentPresenter ContentSource="Header"
+                                          HorizontalAlignment="Center"
+                                          VerticalAlignment="Center"/>
+                    </Border>
+                    <ControlTemplate.Triggers>
+                        <Trigger Property="IsSelected" Value="True">
+                            <Setter TargetName="border" Property="BorderThickness" Value="0,0,0,2"/>
+                            <Setter Property="Foreground" Value="{StaticResource ForegroundBrush}"/>
+                        </Trigger>
+                        <Trigger Property="IsMouseOver" Value="True">
+                            <Setter TargetName="border" Property="Background" Value="{StaticResource BackgroundLighterBrush}"/>
+                        </Trigger>
+                    </ControlTemplate.Triggers>
+                </ControlTemplate>
+            </Setter.Value>
+        </Setter>
+    </Style>
+
     <!-- ============================================ -->
     <!-- DataGrid Style                               -->
     <!-- ============================================ -->
diff --git a/Dashboard/Themes/DarkTheme.xaml b/Dashboard/Themes/DarkTheme.xaml
index 5e0b8324..20abf9bb 100644
--- a/Dashboard/Themes/DarkTheme.xaml
+++ b/Dashboard/Themes/DarkTheme.xaml
@@ -643,6 +643,40 @@
         </Setter>
     </Style>
 
+    <!-- Sub-tab style: thin accent underline instead of filled background, so the hierarchy
+         reads at a glance when a main tab's sub-tabs are shown alongside the main tab bar. -->
+    <Style x:Key="SubTabItemStyle" TargetType="TabItem">
+        <Setter Property="Background" Value="Transparent"/>
+        <Setter Property="Foreground" Value="{StaticResource ForegroundDimBrush}"/>
+        <Setter Property="BorderThickness" Value="0"/>
+        <Setter Property="Padding" Value="10,6"/>
+        <Setter Property="Margin" Value="0,0,4,0"/>
+        <Setter Property="Template">
+            <Setter.Value>
+                <ControlTemplate TargetType="TabItem">
+                    <Border x:Name="border"
+                            Background="{TemplateBinding Background}"
+                            BorderBrush="{StaticResource AccentBrush}"
+                            BorderThickness="0"
+                            Padding="{TemplateBinding Padding}">
+                        <ContentPresenter ContentSource="Header"
+                                          HorizontalAlignment="Center"
+                                          VerticalAlignment="Center"/>
+                    </Border>
+                    <ControlTemplate.Triggers>
+                        <Trigger Property="IsSelected" Value="True">
+                            <Setter TargetName="border" Property="BorderThickness" Value="0,0,0,2"/>
+                            <Setter Property="Foreground" Value="{StaticResource ForegroundBrush}"/>
+                        </Trigger>
+                        <Trigger Property="IsMouseOver" Value="True">
+                            <Setter TargetName="border" Property="Background" Value="{StaticResource BackgroundLighterBrush}"/>
+                        </Trigger>
+                    </ControlTemplate.Triggers>
+                </ControlTemplate>
+            </Setter.Value>
+        </Setter>
+    </Style>
+
     <!-- ============================================ -->
     <!-- DataGrid Style                               -->
     <!-- ============================================ -->
diff --git a/Dashboard/Themes/LightTheme.xaml b/Dashboard/Themes/LightTheme.xaml
index 903203f3..4e22f4f3 100644
--- a/Dashboard/Themes/LightTheme.xaml
+++ b/Dashboard/Themes/LightTheme.xaml
@@ -644,6 +644,40 @@
         </Setter>
     </Style>
 
+    <!-- Sub-tab style: thin accent underline instead of filled background, so the hierarchy
+         reads at a glance when a main tab's sub-tabs are shown alongside the main tab bar. -->
+    <Style x:Key="SubTabItemStyle" TargetType="TabItem">
+        <Setter Property="Background" Value="Transparent"/>
+        <Setter Property="Foreground" Value="{StaticResource ForegroundDimBrush}"/>
+        <Setter Property="BorderThickness" Value="0"/>
+        <Setter Property="Padding" Value="10,6"/>
+        <Setter Property="Margin" Value="0,0,4,0"/>
+        <Setter Property="Template">
+            <Setter.Value>
+                <ControlTemplate TargetType="TabItem">
+                    <Border x:Name="border"
+                            Background="{TemplateBinding Background}"
+                            BorderBrush="{StaticResource AccentBrush}"
+                            BorderThickness="0"
+                            Padding="{TemplateBinding Padding}">
+                        <ContentPresenter ContentSource="Header"
+                                          HorizontalAlignment="Center"
+                                          VerticalAlignment="Center"/>
+                    </Border>
+                    <ControlTemplate.Triggers>
+                        <Trigger Property="IsSelected" Value="True">
+                            <Setter TargetName="border" Property="BorderThickness" Value="0,0,0,2"/>
+                            <Setter Property="Foreground" Value="{StaticResource ForegroundBrush}"/>
+                        </Trigger>
+                        <Trigger Property="IsMouseOver" Value="True">
+                            <Setter TargetName="border" Property="Background" Value="{StaticResource BackgroundLighterBrush}"/>
+                        </Trigger>
+                    </ControlTemplate.Triggers>
+                </ControlTemplate>
+            </Setter.Value>
+        </Setter>
+    </Style>
+
     <!-- ============================================ -->
     <!-- DataGrid Style                               -->
     <!-- ============================================ -->
diff --git a/Dashboard/TracePatternHistoryWindow.xaml.cs b/Dashboard/TracePatternHistoryWindow.xaml.cs
index fd1de4e8..80439328 100644
--- a/Dashboard/TracePatternHistoryWindow.xaml.cs
+++ b/Dashboard/TracePatternHistoryWindow.xaml.cs
@@ -183,7 +183,7 @@ private void UpdateChart()
                 scatter.MarkerSize = 4;
             }
 
-            HistoryChart.Plot.Axes.DateTimeTicksBottom();
+            HistoryChart.Plot.Axes.DateTimeTicksBottomDateChange();
             Helpers.TabHelpers.ReapplyAxisColors(HistoryChart);
             HistoryChart.Plot.YLabel(metricLabel);
             HistoryChart.Plot.XLabel("End Time");
diff --git a/Lite/Services/BenefitScorer.cs b/Lite/Services/BenefitScorer.cs
index a922c9b7..7d03ae91 100644
--- a/Lite/Services/BenefitScorer.cs
+++ b/Lite/Services/BenefitScorer.cs
@@ -616,20 +616,20 @@ internal static string ClassifyWaitType(string waitType)
         var wt = waitType.ToUpperInvariant();
         return wt switch
         {
-            _ when wt.StartsWith("PAGEIOLATCH") => "I/O",
-            _ when wt.Contains("IO_COMPLETION") => "I/O",
-            _ when wt.StartsWith("WRITELOG") => "I/O",
+            _ when wt.StartsWith("PAGEIOLATCH", StringComparison.Ordinal) => "I/O",
+            _ when wt.Contains("IO_COMPLETION", StringComparison.Ordinal) => "I/O",
+            _ when wt.StartsWith("WRITELOG", StringComparison.Ordinal) => "I/O",
             _ when wt == "SOS_SCHEDULER_YIELD" => "CPU",
-            _ when wt.StartsWith("CXPACKET") || wt.StartsWith("CXCONSUMER") => "Parallelism",
-            _ when wt.StartsWith("CXSYNC") => "Parallelism",
-            _ when wt.StartsWith("HT") => "Hash",
+            _ when wt.StartsWith("CXPACKET", StringComparison.Ordinal) || wt.StartsWith("CXCONSUMER", StringComparison.Ordinal) => "Parallelism",
+            _ when wt.StartsWith("CXSYNC", StringComparison.Ordinal) => "Parallelism",
+            _ when wt.StartsWith("HT", StringComparison.Ordinal) => "Hash",
             _ when wt == "BPSORT" => "Sort",
             _ when wt == "BMPBUILD" => "Hash",
-            _ when wt.StartsWith("PAGELATCH") => "Latch",
-            _ when wt.StartsWith("LATCH_") => "Latch",
-            _ when wt.StartsWith("LCK_") => "Lock",
+            _ when wt.StartsWith("PAGELATCH", StringComparison.Ordinal) => "Latch",
+            _ when wt.StartsWith("LATCH_", StringComparison.Ordinal) => "Latch",
+            _ when wt.StartsWith("LCK_", StringComparison.Ordinal) => "Lock",
             _ when wt == "ASYNC_NETWORK_IO" => "Network",
-            _ when wt.Contains("MEMORY_ALLOCATION") => "Memory",
+            _ when wt.Contains("MEMORY_ALLOCATION", StringComparison.Ordinal) => "Memory",
             _ when wt == "SOS_PHYS_PAGE_CACHE" => "Memory",
             _ => "Other"
         };
diff --git a/Lite/Services/PlanAnalyzer.cs b/Lite/Services/PlanAnalyzer.cs
index 29d0a3d6..5f7284c1 100644
--- a/Lite/Services/PlanAnalyzer.cs
+++ b/Lite/Services/PlanAnalyzer.cs
@@ -1,6 +1,3 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
 using System.Text.RegularExpressions;
 using PerformanceMonitorLite.Models;
 
@@ -253,7 +250,7 @@ private static void AnalyzeStatement(PlanStatement stmt)
 
             if (unsnifffedParams.Count > 0)
             {
-                var hasRecompile = stmt.StatementText.Contains("RECOMPILE", StringComparison.OrdinalIgnoreCase);
+                var hasRecompile = (stmt.StatementText ?? "").Contains("RECOMPILE", StringComparison.OrdinalIgnoreCase);
                 if (!hasRecompile)
                 {
                     var names = string.Join(", ", unsnifffedParams.Select(p => p.Name));
@@ -1099,7 +1096,7 @@ _ when nonSargableReason.StartsWith("Function call", StringComparison.OrdinalIgn
         // Rule 28: Row Count Spool — NOT IN with nullable column
         // Pattern: Row Count Spool with high rewinds, child scan has IS NULL predicate,
         // and statement text contains NOT IN
-        if (node.PhysicalOp.Contains("Row Count Spool"))
+        if ((node.PhysicalOp ?? "").Contains("Row Count Spool", StringComparison.Ordinal))
         {
             var rewinds = node.HasActualStats ? (double)node.ActualRewinds : node.EstimateRewinds;
             if (rewinds > 10000 && HasNotInPattern(node, stmt))
@@ -1118,7 +1115,7 @@ _ when nonSargableReason.StartsWith("Function call", StringComparison.OrdinalIgn
         if (!(node.HasActualStats && node.ActualExecutions == 0))
         foreach (var w in node.Warnings.ToList())
         {
-            if (w.WarningType == "Implicit Conversion" && w.Message.StartsWith("Seek Plan"))
+            if (w.WarningType == "Implicit Conversion" && w.Message.StartsWith("Seek Plan", StringComparison.Ordinal))
             {
                 w.Severity = PlanWarningSeverity.Critical;
                 w.Message = $"Implicit conversion prevented an index seek, forcing a scan instead. Fix the data type mismatch: ensure the parameter or variable type matches the column type exactly. {w.Message}";
diff --git a/Lite/Services/RemoteCollectorService.QueryStore.cs b/Lite/Services/RemoteCollectorService.QueryStore.cs
index 612653c3..9265c32e 100644
--- a/Lite/Services/RemoteCollectorService.QueryStore.cs
+++ b/Lite/Services/RemoteCollectorService.QueryStore.cs
@@ -222,7 +222,7 @@ ORDER BY
             /* Fall back to 13 (SQL 2016) if version detection fails */
         }
 
-        bool isNew = productVersion > 13 || serverStatus.SqlEngineEdition == 5 || serverStatus.SqlEngineEdition == 8;
+        bool isNew = productVersion > 13 || serverStatus?.SqlEngineEdition == 5 || serverStatus?.SqlEngineEdition == 8;
         bool hasPlanType = productVersion >= 16;
 
         /* Build version-conditional column fragments for the Query Store query.

From f1c8160d78ddbd8178ee09ff4040bd722c6c56c0 Mon Sep 17 00:00:00 2001
From: Erik Darling <2136037+erikdarlingdata@users.noreply.github.com>
Date: Sat, 18 Apr 2026 20:20:09 -0400
Subject: [PATCH 17/49] Fix Overview crosshair disappearing after tab switches
 / layout passes
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Root cause: the control wired `Unloaded += ...Dispose()` on the crosshair
manager, and WPF fires Unloaded for transient reasons (tab virtualization,
layout rebuilds, etc.), not just when the control is actually going away.
Dispose() clears the manager's lane list, after which ReattachVLines runs
over an empty list and the crosshair is gone permanently.

Changes:
- Remove the Unloaded → Dispose() handler in both Lite and Dashboard copies.
  The manager holds only managed state (a Popup + lane references) — GC
  will clean it up with the control.
- Remove the now-redundant `_isRefreshing` flag from CorrelatedCrosshairManager.
  The `lane.VLine == null` check in OnMouseMove is a sufficient "not ready"
  guard and is self-healing once VLines are recreated.
- Wrap ReattachVLines in a try/finally on the control side, with a new
  idempotent EnsureVLinesAttached() safety net that only creates VLines
  for lanes where they're still null.
- Make CreateVLine catch per-lane exceptions so one failing chart can't
  prevent the others from recovering.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
---
 .../CorrelatedTimelineLanesControl.xaml.cs    | 20 ++++++++-
 .../Helpers/CorrelatedCrosshairManager.cs     | 43 ++++++++++++++++---
 .../CorrelatedTimelineLanesControl.xaml.cs    | 13 +++++-
 Lite/Helpers/CorrelatedCrosshairManager.cs    | 43 ++++++++++++++++---
 4 files changed, 103 insertions(+), 16 deletions(-)

diff --git a/Dashboard/Controls/CorrelatedTimelineLanesControl.xaml.cs b/Dashboard/Controls/CorrelatedTimelineLanesControl.xaml.cs
index 7d8f878f..7beb4696 100644
--- a/Dashboard/Controls/CorrelatedTimelineLanesControl.xaml.cs
+++ b/Dashboard/Controls/CorrelatedTimelineLanesControl.xaml.cs
@@ -31,7 +31,12 @@ public partial class CorrelatedTimelineLanesControl : UserControl
     public CorrelatedTimelineLanesControl()
     {
         InitializeComponent();
-        Unloaded += (_, _) => _crosshairManager?.Dispose();
+        /* No Unloaded → Dispose() handler: WPF fires Unloaded for transient
+           reasons (tab virtualization, layout rebuilds) and Dispose() clears
+           the crosshair manager's lane list, permanently breaking the crosshair
+           until the ServerTab is rebuilt. The manager holds only managed state
+           (a Popup + lane references) — letting GC clean it up with the control
+           is fine. */
     }
 
     /// <summary>
@@ -69,6 +74,9 @@ public async Task RefreshAsync(int hoursBack, DateTime? fromDate, DateTime? toDa
 
         _crosshairManager?.PrepareForRefresh();
 
+        try
+        {
+
         var cpuTask = _dataService.GetCpuUtilizationAsync(hoursBack, fromDate, toDate);
         var waitTask = _dataService.GetTotalWaitStatsTrendAsync(hoursBack, fromDate, toDate);
         var blockingTask = _dataService.GetBlockedSessionTrendAsync(hoursBack, fromDate, toDate);
@@ -225,8 +233,18 @@ public async Task RefreshAsync(int hoursBack, DateTime? fromDate, DateTime? toDa
             _crosshairManager?.SetComparisonLabel(ComparisonLabel(comparisonRange.Value, fromDate, hoursBack));
         }
 
+        /* VLines must be re-attached before SyncXAxes so they're part of
+           the render set when the chart refreshes. */
         _crosshairManager?.ReattachVLines();
         SyncXAxes(hoursBack, fromDate, toDate);
+        }
+        finally
+        {
+            /* Safety net: if something threw between PrepareForRefresh() and the
+               ReattachVLines() call above, VLines are still null. EnsureVLinesAttached
+               creates them only for lanes where VLine is null, so it's idempotent. */
+            _crosshairManager?.EnsureVLinesAttached();
+        }
     }
 
     /// <summary>
diff --git a/Dashboard/Helpers/CorrelatedCrosshairManager.cs b/Dashboard/Helpers/CorrelatedCrosshairManager.cs
index 80e2ec7d..a13efb2d 100644
--- a/Dashboard/Helpers/CorrelatedCrosshairManager.cs
+++ b/Dashboard/Helpers/CorrelatedCrosshairManager.cs
@@ -33,7 +33,6 @@ internal sealed class CorrelatedCrosshairManager : IDisposable
     private readonly Popup _tooltip;
     private readonly TextBlock _tooltipText;
     private DateTime _lastUpdate;
-    private bool _isRefreshing;
 
     public CorrelatedCrosshairManager()
     {
@@ -144,10 +143,11 @@ public void SetComparisonLabel(string label)
 
     /// <summary>
     /// Clears data and VLines. Call before re-populating charts.
+    /// The OnMouseMove guard relies on lane.VLine == null to detect "not ready",
+    /// so this is self-healing: once ReattachVLines runs, crosshairs resume.
     /// </summary>
     public void PrepareForRefresh()
     {
-        _isRefreshing = true;
         _tooltip.IsOpen = false;
         _comparisonLabel = null;
         foreach (var lane in _lanes)
@@ -162,25 +162,54 @@ public void PrepareForRefresh()
 
     /// <summary>
     /// Creates fresh VLine plottables on each lane's chart.
-    /// Must be called AFTER chart data is populated.
+    /// Must be called AFTER chart data is populated. Safe to call in a finally
+    /// block — if chart state is invalid, a failure on one lane won't prevent
+    /// the others from recovering.
     /// </summary>
     public void ReattachVLines()
     {
         foreach (var lane in _lanes)
         {
-            var vline = lane.Chart.Plot.Add.VerticalLine(0);
+            lane.VLine = CreateVLine(lane.Chart);
+        }
+    }
+
+    /// <summary>
+    /// Creates VLines only for lanes that don't already have one. Idempotent —
+    /// safe to call from a finally block as a recovery path after an exception
+    /// in the main refresh flow.
+    /// </summary>
+    public void EnsureVLinesAttached()
+    {
+        foreach (var lane in _lanes)
+        {
+            if (lane.VLine != null) continue;
+            lane.VLine = CreateVLine(lane.Chart);
+        }
+    }
+
+    private static ScottPlot.Plottables.VerticalLine? CreateVLine(ScottPlot.WPF.WpfPlot chart)
+    {
+        try
+        {
+            var vline = chart.Plot.Add.VerticalLine(0);
             vline.Color = ScottPlot.Color.FromHex("#FFFFFF").WithAlpha(100);
             vline.LineWidth = 1;
             vline.LinePattern = ScottPlot.LinePattern.Dashed;
             vline.IsVisible = false;
-            lane.VLine = vline;
+            return vline;
+        }
+        catch
+        {
+            /* If attach fails, return null so OnMouseMove skips this lane.
+               Next refresh will try again. */
+            return null;
         }
-        _isRefreshing = false;
     }
 
     private void OnMouseMove(LaneInfo sourceLane, MouseEventArgs e)
     {
-        if (_isRefreshing || sourceLane.VLine == null) return;
+        if (sourceLane.VLine == null) return;
 
         var now = DateTime.UtcNow;
         if ((now - _lastUpdate).TotalMilliseconds < 16) return;
diff --git a/Lite/Controls/CorrelatedTimelineLanesControl.xaml.cs b/Lite/Controls/CorrelatedTimelineLanesControl.xaml.cs
index beb4c572..2b73b71a 100644
--- a/Lite/Controls/CorrelatedTimelineLanesControl.xaml.cs
+++ b/Lite/Controls/CorrelatedTimelineLanesControl.xaml.cs
@@ -31,7 +31,12 @@ public partial class CorrelatedTimelineLanesControl : UserControl
     public CorrelatedTimelineLanesControl()
     {
         InitializeComponent();
-        Unloaded += (_, _) => _crosshairManager?.Dispose();
+        /* No Unloaded → Dispose() handler: WPF fires Unloaded for transient
+           reasons (tab virtualization, layout rebuilds) and Dispose() clears
+           the crosshair manager's lane list, permanently breaking the crosshair
+           until the ServerTab is rebuilt. The manager holds only managed state
+           (a Popup + lane references) — letting GC clean it up with the control
+           is fine. */
     }
 
     /// <summary>
@@ -203,11 +208,17 @@ await Task.WhenAll(cpuTask, waitTask, blockingTask, deadlockTask, memoryTask, fi
                 _crosshairManager?.SetComparisonLabel(ComparisonLabel(comparisonRange.Value, fromDate, hoursBack));
             }
 
+            /* VLines must be re-attached before SyncXAxes so they're part of
+               the render set when the chart refreshes. */
             _crosshairManager?.ReattachVLines();
             SyncXAxes(hoursBack, fromDate, toDate, utcOffset);
         }
         finally
         {
+            /* Safety net: if something threw between PrepareForRefresh() and the
+               ReattachVLines() call above, VLines are still null. EnsureVLinesAttached
+               creates them only for lanes where VLine is null, so it's idempotent. */
+            _crosshairManager?.EnsureVLinesAttached();
             _isRefreshing = false;
         }
     }
diff --git a/Lite/Helpers/CorrelatedCrosshairManager.cs b/Lite/Helpers/CorrelatedCrosshairManager.cs
index 75bce9bb..00098b4f 100644
--- a/Lite/Helpers/CorrelatedCrosshairManager.cs
+++ b/Lite/Helpers/CorrelatedCrosshairManager.cs
@@ -33,7 +33,6 @@ internal sealed class CorrelatedCrosshairManager : IDisposable
     private readonly Popup _tooltip;
     private readonly TextBlock _tooltipText;
     private DateTime _lastUpdate;
-    private bool _isRefreshing;
 
     public CorrelatedCrosshairManager()
     {
@@ -144,10 +143,11 @@ public void SetComparisonLabel(string label)
 
     /// <summary>
     /// Clears data and VLines. Call before re-populating charts.
+    /// The OnMouseMove guard relies on lane.VLine == null to detect "not ready",
+    /// so this is self-healing: once ReattachVLines runs, crosshairs resume.
     /// </summary>
     public void PrepareForRefresh()
     {
-        _isRefreshing = true;
         _tooltip.IsOpen = false;
         _comparisonLabel = null;
         foreach (var lane in _lanes)
@@ -162,25 +162,54 @@ public void PrepareForRefresh()
 
     /// <summary>
     /// Creates fresh VLine plottables on each lane's chart.
-    /// Must be called AFTER chart data is populated.
+    /// Must be called AFTER chart data is populated. Safe to call in a finally
+    /// block — if chart state is invalid, a failure on one lane won't prevent
+    /// the others from recovering.
     /// </summary>
     public void ReattachVLines()
     {
         foreach (var lane in _lanes)
         {
-            var vline = lane.Chart.Plot.Add.VerticalLine(0);
+            lane.VLine = CreateVLine(lane.Chart);
+        }
+    }
+
+    /// <summary>
+    /// Creates VLines only for lanes that don't already have one. Idempotent —
+    /// safe to call from a finally block as a recovery path after an exception
+    /// in the main refresh flow.
+    /// </summary>
+    public void EnsureVLinesAttached()
+    {
+        foreach (var lane in _lanes)
+        {
+            if (lane.VLine != null) continue;
+            lane.VLine = CreateVLine(lane.Chart);
+        }
+    }
+
+    private static ScottPlot.Plottables.VerticalLine? CreateVLine(ScottPlot.WPF.WpfPlot chart)
+    {
+        try
+        {
+            var vline = chart.Plot.Add.VerticalLine(0);
             vline.Color = ScottPlot.Color.FromHex("#FFFFFF").WithAlpha(100);
             vline.LineWidth = 1;
             vline.LinePattern = ScottPlot.LinePattern.Dashed;
             vline.IsVisible = false;
-            lane.VLine = vline;
+            return vline;
+        }
+        catch
+        {
+            /* If attach fails, return null so OnMouseMove skips this lane.
+               Next refresh will try again. */
+            return null;
         }
-        _isRefreshing = false;
     }
 
     private void OnMouseMove(LaneInfo sourceLane, MouseEventArgs e)
     {
-        if (_isRefreshing || sourceLane.VLine == null) return;
+        if (sourceLane.VLine == null) return;
 
         var now = DateTime.UtcNow;
         if ((now - _lastUpdate).TotalMilliseconds < 16) return;

From f014bf880567e4a8174d2532b4da2247fb76d5aa Mon Sep 17 00:00:00 2001
From: Erik Darling <2136037+erikdarlingdata@users.noreply.github.com>
Date: Sun, 19 Apr 2026 15:15:02 -0400
Subject: [PATCH 18/49] Fix Memory Pressure Events chart filter; add MCP
 interpretation (#865)

Chart previously filtered to HIGH severity only (indicator>=3), which on most
servers never fires, producing an empty chart even when sp_pressuredetector-
level medium pressure (indicator=2) was occurring constantly. Switch to stacked
bars per hour, split by SQL Server (process) vs Operating System (system), with
severe events capped on top of medium in a darker shade. Extend ChartHoverHelper
to support BarPlot tooltips. Add MCP guidance for interpreting indicator values
and routing to the right follow-up tool.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
---
 Dashboard/Controls/MemoryContent.xaml.cs | 138 +++++++++++++++++++----
 Dashboard/Helpers/ChartHoverHelper.cs    |  51 ++++++++-
 Dashboard/Mcp/McpInstructions.cs         |  44 ++++++++
 Dashboard/Mcp/McpSystemEventTools.cs     |  12 +-
 4 files changed, 220 insertions(+), 25 deletions(-)

diff --git a/Dashboard/Controls/MemoryContent.xaml.cs b/Dashboard/Controls/MemoryContent.xaml.cs
index bc07e18d..dbe405ea 100644
--- a/Dashboard/Controls/MemoryContent.xaml.cs
+++ b/Dashboard/Controls/MemoryContent.xaml.cs
@@ -1080,31 +1080,132 @@ private void LoadMemoryPressureEventsChart(IEnumerable<MemoryPressureEventItem>
             _memoryPressureEventsHover?.Clear();
             TabHelpers.ApplyThemeToChart(MemoryPressureEventsChart);
 
-            // Only chart HIGH severity events
-            var dataList = data?.Where(d => d.Severity.Equals("HIGH", StringComparison.OrdinalIgnoreCase))
-                .OrderBy(d => d.SampleTime).ToList() ?? new List<MemoryPressureEventItem>();
+            // Count rows where SQL Server reported actual pressure (indicator >= 2 matches sp_pressuredetector).
+            var dataList = data?
+                .Where(d => d.MemoryIndicatorsProcess >= 2 || d.MemoryIndicatorsSystem >= 2)
+                .OrderBy(d => d.SampleTime)
+                .ToList() ?? new List<MemoryPressureEventItem>();
+
             bool hasData = false;
+            int maxBarCount = 0;
+
             if (dataList.Count > 0)
             {
-                // Group by hour and count HIGH events
                 var grouped = dataList
                     .GroupBy(d => new DateTime(d.SampleTime.Year, d.SampleTime.Month, d.SampleTime.Day, d.SampleTime.Hour, 0, 0))
                     .OrderBy(g => g.Key)
                     .ToList();
 
-                if (grouped.Count > 0)
+                double hourWidth = 1.0 / 24.0;
+                double barSize = hourWidth * 0.4;
+                double barOffset = hourWidth * 0.22;
+
+                // Four series: SQL Server medium, SQL Server severe (stacked on top of medium),
+                // OS medium, OS severe. Stacking uses ValueBase so severe bars sit on top of medium.
+                var sqlMediumBars = new List<ScottPlot.Bar>();
+                var sqlSevereBars = new List<ScottPlot.Bar>();
+                var osMediumBars = new List<ScottPlot.Bar>();
+                var osSevereBars = new List<ScottPlot.Bar>();
+
+                var sqlMediumColor = ScottPlot.Color.FromHex("#FFB74D");  // orange 300
+                var sqlSevereColor = ScottPlot.Color.FromHex("#E65100");  // orange 900
+                var osMediumColor = ScottPlot.Color.FromHex("#E57373");   // red 300
+                var osSevereColor = ScottPlot.Color.FromHex("#B71C1C");   // red 900
+
+                foreach (var g in grouped)
+                {
+                    int sqlMedium = g.Count(d => d.MemoryIndicatorsProcess == 2);
+                    int sqlSevere = g.Count(d => d.MemoryIndicatorsProcess >= 3);
+                    int osMedium = g.Count(d => d.MemoryIndicatorsSystem == 2);
+                    int osSevere = g.Count(d => d.MemoryIndicatorsSystem >= 3);
+                    double x = g.Key.ToOADate();
+
+                    if (sqlMedium > 0)
+                    {
+                        sqlMediumBars.Add(new ScottPlot.Bar
+                        {
+                            Position = x - barOffset,
+                            ValueBase = 0,
+                            Value = sqlMedium,
+                            Size = barSize,
+                            FillColor = sqlMediumColor,
+                            LineWidth = 0
+                        });
+                    }
+                    if (sqlSevere > 0)
+                    {
+                        sqlSevereBars.Add(new ScottPlot.Bar
+                        {
+                            Position = x - barOffset,
+                            ValueBase = sqlMedium,
+                            Value = sqlMedium + sqlSevere,
+                            Size = barSize,
+                            FillColor = sqlSevereColor,
+                            LineWidth = 0
+                        });
+                    }
+                    if (osMedium > 0)
+                    {
+                        osMediumBars.Add(new ScottPlot.Bar
+                        {
+                            Position = x + barOffset,
+                            ValueBase = 0,
+                            Value = osMedium,
+                            Size = barSize,
+                            FillColor = osMediumColor,
+                            LineWidth = 0
+                        });
+                    }
+                    if (osSevere > 0)
+                    {
+                        osSevereBars.Add(new ScottPlot.Bar
+                        {
+                            Position = x + barOffset,
+                            ValueBase = osMedium,
+                            Value = osMedium + osSevere,
+                            Size = barSize,
+                            FillColor = osSevereColor,
+                            LineWidth = 0
+                        });
+                    }
+
+                    int sqlTotal = sqlMedium + sqlSevere;
+                    int osTotal = osMedium + osSevere;
+                    if (sqlTotal > maxBarCount) maxBarCount = sqlTotal;
+                    if (osTotal > maxBarCount) maxBarCount = osTotal;
+                }
+
+                bool anyBars = sqlMediumBars.Count > 0 || sqlSevereBars.Count > 0
+                    || osMediumBars.Count > 0 || osSevereBars.Count > 0;
+
+                if (anyBars)
                 {
                     hasData = true;
-                    var timePoints = grouped.Select(g => g.Key);
-                    double[] highCounts = grouped.Select(g => (double)g.Count()).ToArray();
 
-                    var (xs, ys) = TabHelpers.FillTimeSeriesGaps(timePoints, highCounts.Select(c => c));
-                    var highScatter = MemoryPressureEventsChart.Plot.Add.Scatter(xs, ys);
-                    highScatter.LineWidth = 2;
-                    highScatter.MarkerSize = 5;
-                    highScatter.Color = TabHelpers.ChartColors[3];
-                    highScatter.LegendText = "High Pressure Events";
-                    _memoryPressureEventsHover?.Add(highScatter, "High Pressure Events");
+                    if (sqlMediumBars.Count > 0)
+                    {
+                        var bp = MemoryPressureEventsChart.Plot.Add.Bars(sqlMediumBars);
+                        bp.LegendText = "SQL Server (medium)";
+                        _memoryPressureEventsHover?.Add(bp, "SQL Server (medium)");
+                    }
+                    if (sqlSevereBars.Count > 0)
+                    {
+                        var bp = MemoryPressureEventsChart.Plot.Add.Bars(sqlSevereBars);
+                        bp.LegendText = "SQL Server (severe)";
+                        _memoryPressureEventsHover?.Add(bp, "SQL Server (severe)");
+                    }
+                    if (osMediumBars.Count > 0)
+                    {
+                        var bp = MemoryPressureEventsChart.Plot.Add.Bars(osMediumBars);
+                        bp.LegendText = "Operating System (medium)";
+                        _memoryPressureEventsHover?.Add(bp, "Operating System (medium)");
+                    }
+                    if (osSevereBars.Count > 0)
+                    {
+                        var bp = MemoryPressureEventsChart.Plot.Add.Bars(osSevereBars);
+                        bp.LegendText = "Operating System (severe)";
+                        _memoryPressureEventsHover?.Add(bp, "Operating System (severe)");
+                    }
 
                     _legendPanels[MemoryPressureEventsChart] = MemoryPressureEventsChart.Plot.ShowLegend(ScottPlot.Edge.Bottom);
                     MemoryPressureEventsChart.Plot.Legend.FontSize = 12;
@@ -1114,7 +1215,7 @@ private void LoadMemoryPressureEventsChart(IEnumerable<MemoryPressureEventItem>
             if (!hasData)
             {
                 double xCenter = xMin + (xMax - xMin) / 2;
-                var noDataText = MemoryPressureEventsChart.Plot.Add.Text("No data for selected time range", xCenter, 0.5);
+                var noDataText = MemoryPressureEventsChart.Plot.Add.Text("No memory pressure events in selected time range", xCenter, 0.5);
                 noDataText.LabelFontSize = 14;
                 noDataText.LabelFontColor = ScottPlot.Colors.Gray;
                 noDataText.LabelAlignment = ScottPlot.Alignment.MiddleCenter;
@@ -1122,11 +1223,8 @@ private void LoadMemoryPressureEventsChart(IEnumerable<MemoryPressureEventItem>
 
             MemoryPressureEventsChart.Plot.Axes.DateTimeTicksBottomDateChange();
             MemoryPressureEventsChart.Plot.Axes.SetLimitsX(xMin, xMax);
-            MemoryPressureEventsChart.Plot.YLabel("Event Count");
-            // Fixed negative space for legend
-            MemoryPressureEventsChart.Plot.Axes.AutoScaleY();
-            var pressureLimits = MemoryPressureEventsChart.Plot.Axes.GetLimits();
-            MemoryPressureEventsChart.Plot.Axes.SetLimitsY(0, pressureLimits.Top * 1.05);
+            MemoryPressureEventsChart.Plot.YLabel("Pressure Events per Hour");
+            MemoryPressureEventsChart.Plot.Axes.SetLimitsY(0, Math.Max(maxBarCount * 1.1, 5.0));
 
             TabHelpers.LockChartVerticalAxis(MemoryPressureEventsChart);
             MemoryPressureEventsChart.Refresh();
diff --git a/Dashboard/Helpers/ChartHoverHelper.cs b/Dashboard/Helpers/ChartHoverHelper.cs
index b1ec6f11..2ff0ab1a 100644
--- a/Dashboard/Helpers/ChartHoverHelper.cs
+++ b/Dashboard/Helpers/ChartHoverHelper.cs
@@ -17,6 +17,7 @@ internal sealed class ChartHoverHelper
 {
     private readonly ScottPlot.WPF.WpfPlot _chart;
     private readonly List<(ScottPlot.Plottables.Scatter Scatter, string Label)> _scatters = new();
+    private readonly List<(ScottPlot.Plottables.BarPlot BarPlot, string Label)> _barPlots = new();
     private readonly Popup _popup;
     private readonly TextBlock _text;
     private string _unit;
@@ -62,20 +63,28 @@ public void Dispose()
         _chart.MouseLeave -= OnMouseLeave;
         _popup.IsOpen = false;
         _scatters.Clear();
+        _barPlots.Clear();
     }
 
-    public void Clear() => _scatters.Clear();
+    public void Clear()
+    {
+        _scatters.Clear();
+        _barPlots.Clear();
+    }
 
     public void Add(ScottPlot.Plottables.Scatter scatter, string label) =>
         _scatters.Add((scatter, label));
 
+    public void Add(ScottPlot.Plottables.BarPlot barPlot, string label) =>
+        _barPlots.Add((barPlot, label));
+
     /// <summary>
     /// Returns the nearest series label and data-point time for the given mouse position,
     /// or null if no series is close enough.
     /// </summary>
     public (string Label, DateTime Time)? GetNearestSeries(Point mousePos)
     {
-        if (_scatters.Count == 0) return null;
+        if (_scatters.Count == 0 && _barPlots.Count == 0) return null;
         try
         {
             var dpi = VisualTreeHelper.GetDpi(_chart);
@@ -106,6 +115,8 @@ public void Add(ScottPlot.Plottables.Scatter scatter, string label) =>
                 }
             }
 
+            FindNearestBar(pixel, ref bestYDistance, ref bestPoint, ref bestLabel, ref found);
+
             if (found)
                 return (bestLabel, DateTime.FromOADate(bestPoint.X));
         }
@@ -113,9 +124,36 @@ public void Add(ScottPlot.Plottables.Scatter scatter, string label) =>
         return null;
     }
 
+    private void FindNearestBar(ScottPlot.Pixel pixel, ref double bestYDistance,
+        ref ScottPlot.DataPoint bestPoint, ref string bestLabel, ref bool found)
+    {
+        foreach (var (barPlot, label) in _barPlots)
+        {
+            foreach (var bar in barPlot.Bars)
+            {
+                var topPixel = _chart.Plot.GetPixel(new ScottPlot.Coordinates(bar.Position, bar.Value));
+                double halfWidthPx = Math.Abs(
+                    _chart.Plot.GetPixel(new ScottPlot.Coordinates(bar.Position + bar.Size / 2, bar.Value)).X
+                    - topPixel.X);
+                double dx = Math.Abs(topPixel.X - pixel.X);
+                if (dx > halfWidthPx + 4) continue;
+                double dy = Math.Abs(topPixel.Y - pixel.Y);
+                if (dy < bestYDistance)
+                {
+                    bestYDistance = dy;
+                    // For stacked bars, report the segment height (Value - ValueBase), not the top coordinate
+                    double segmentHeight = bar.Value - bar.ValueBase;
+                    bestPoint = new ScottPlot.DataPoint(new ScottPlot.Coordinates(bar.Position, segmentHeight), 0);
+                    bestLabel = label;
+                    found = true;
+                }
+            }
+        }
+    }
+
     private void OnMouseMove(object sender, MouseEventArgs e)
     {
-        if (_scatters.Count == 0) return;
+        if (_scatters.Count == 0 && _barPlots.Count == 0) return;
         var now = DateTime.UtcNow;
         if ((now - _lastUpdate).TotalMilliseconds < 30) return;
         _lastUpdate = now;
@@ -158,10 +196,15 @@ pick the series closest in Y (nearest line to cursor). */
                 }
             }
 
+            FindNearestBar(pixel, ref bestYDistance, ref bestPoint, ref bestLabel, ref found);
+
             if (found)
             {
                 var time = ServerTimeHelper.ConvertForDisplay(DateTime.FromOADate(bestPoint.X), ServerTimeHelper.CurrentDisplayMode);
-                _text.Text = $"{bestLabel}\n{bestPoint.Y:N1} {_unit}\n{time:HH:mm:ss}";
+                string valueFormatted = (bestPoint.Y == Math.Floor(bestPoint.Y))
+                    ? bestPoint.Y.ToString("N0")
+                    : bestPoint.Y.ToString("N1");
+                _text.Text = $"{bestLabel}\n{valueFormatted} {_unit}\n{time:HH:mm:ss}";
                 _popup.HorizontalOffset = pos.X + 15;
                 _popup.VerticalOffset = pos.Y + 15;
                 _popup.IsOpen = true;
diff --git a/Dashboard/Mcp/McpInstructions.cs b/Dashboard/Mcp/McpInstructions.cs
index 65ba0f92..6b628b65 100644
--- a/Dashboard/Mcp/McpInstructions.cs
+++ b/Dashboard/Mcp/McpInstructions.cs
@@ -217,6 +217,50 @@ You are connected to a SQL Server performance monitoring tool via Performance Mo
         | `RESOURCE_SEMAPHORE` | Memory grant pressure | `get_resource_semaphore` |
         | `LATCH_*` | Internal contention | `get_tempdb_trend` |
 
+        ## Interpreting Memory Pressure Events
+
+        `get_memory_pressure_events` returns notifications from the `RING_BUFFER_RESOURCE_MONITOR` ring buffer. The `memory_indicators_process` and `memory_indicators_system` values are SQL Server's Resource Monitor signals. Indicator scale:
+
+        - **0-1**: normal operating state, not actionable
+        - **2 (medium)**: Resource Monitor has crossed a threshold and is starting to respond — trimming caches, reducing memory grants. Worth investigating if sustained or frequent.
+        - **3+ (severe)**: aggressive response — buffer pool pages are being evicted, plan cache entries thrown out, workspace memory starved. Always worth investigating.
+
+        The two indicators report different things:
+
+        - `memory_indicators_process` — the SQL Server *process itself* is under memory pressure. Usually workload-induced (large memory grants, plan cache bloat, buffer pool churn).
+        - `memory_indicators_system` — Windows is signaling low memory *system-wide*. Something on the whole box is consuming memory; SQL Server may or may not be the culprit.
+
+        ### What to check when process pressure (indicator >= 2) fires
+
+        The workload is squeezing SQL Server itself. Follow-up tools:
+        | Signal to check | Tool |
+        |-----------------|------|
+        | Memory grant contention, workspace memory exhaustion | `get_resource_semaphore` |
+        | Buffer pool composition, memory clerk distribution | `get_memory_clerks` |
+        | Plan cache bloat (lots of single-use plans) | `get_plan_cache_bloat` |
+        | Page Life Expectancy, target vs total server memory | `get_memory_stats`, `get_memory_trend` |
+        | Queries that requested large grants during the window | `get_top_queries_by_cpu`, `get_expensive_queries` |
+        | `RESOURCE_SEMAPHORE` waits in the same window | `get_wait_stats`, `get_wait_trend` |
+
+        ### What to check when system pressure (indicator >= 2) fires but process does not
+
+        The box is tight on memory, but SQL Server's own process is not the cause. SQL Server feels Windows' low-memory notification but isn't driving it. Typical root causes: other services on the machine (anti-virus, backup agents, monitoring agents, additional SQL instances, SSIS/SSRS, RDP sessions), oversized file system cache, or VM-host memory oversubscription. Follow-up:
+
+        | Signal to check | Tool |
+        |-----------------|------|
+        | SQL Server's memory configuration (`max server memory` vs total RAM) | `get_server_properties` |
+        | Is SQL Server itself actually fine? | `get_memory_stats`, `get_memory_clerks` |
+
+        Most of the diagnosis in this case is *outside* the monitored SQL instance — tell the user to check what else is running on the host.
+
+        ### Patterns
+
+        - **Both process and system firing together** → real capacity problem. Add RAM, tune the workload, or reduce concurrency.
+        - **Process only** → workload/schema issue, not a hardware problem. Tune queries and indexes.
+        - **System only** → non-SQL workload on the host; SQL itself is healthy but the tenant mix is tight.
+        - **Bursty spikes** → correlate the pressure window with `get_running_jobs` (scheduled maintenance, index rebuilds, big reports) and `get_top_queries_by_cpu` for that period.
+        - **Flat-line sustained** → chronic under-provisioning; memory needs to grow or workload needs to shrink.
+
         ## Tool Relationships
 
         - `get_wait_stats` identifies the symptom category (CPU, I/O, locks, parallelism). Other tools find the root cause.
diff --git a/Dashboard/Mcp/McpSystemEventTools.cs b/Dashboard/Mcp/McpSystemEventTools.cs
index 3aa2c1b5..d4ba0224 100644
--- a/Dashboard/Mcp/McpSystemEventTools.cs
+++ b/Dashboard/Mcp/McpSystemEventTools.cs
@@ -117,7 +117,17 @@ public static async Task<string> GetTraceAnalysis(
         }
     }
 
-    [McpServerTool(Name = "get_memory_pressure_events"), Description("Gets memory pressure notifications from the ring buffer. Shows RESOURCE_MEMPHYSICAL_LOW, RESOURCE_MEMVIRTUAL_LOW, and other memory broker notifications with process/system indicators.")]
+    [McpServerTool(Name = "get_memory_pressure_events"), Description(@"Gets memory pressure notifications from the RING_BUFFER_RESOURCE_MONITOR ring buffer (same source as sp_pressuredetector). Returns RESOURCE_MEMPHYSICAL_LOW, RESOURCE_MEMVIRTUAL_LOW, RESOURCE_MEMPHYSICAL_HIGH, and RESOURCE_MEM_STEADY notifications with indicator values.
+
+Indicator scale (applies to both memory_indicators_process and memory_indicators_system):
+  0-1 = normal, no pressure
+  2   = medium pressure (SQL Server's Resource Monitor starts trimming caches and reducing grants)
+  3+  = severe pressure (aggressive buffer pool / plan cache eviction)
+
+memory_indicators_process = SQL Server process itself is under memory pressure (workload-induced).
+memory_indicators_system  = Windows is signaling low memory system-wide (could be other tenants on the box).
+
+For actionable interpretation and suggested follow-up tools, see the 'Interpreting Memory Pressure Events' section of the server instructions.")]
     public static async Task<string> GetMemoryPressureEvents(
         ServerManager serverManager,
         DatabaseServiceRegistry registry,

From b86250f0f4b1e9944384bc996557e5432480d351 Mon Sep 17 00:00:00 2001
From: Erik Darling <2136037+erikdarlingdata@users.noreply.github.com>
Date: Sun, 19 Apr 2026 15:52:27 -0400
Subject: [PATCH 19/49] Port Memory Pressure Events feature to Lite (#865)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Lite was missing the RING_BUFFER_RESOURCE_MONITOR collector entirely — no
collector, no table, no chart, no MCP tool. This adds the full feature:

- Schema: new memory_pressure_events table + index, schema v25, added to
  ArchivableTables, server-id-fix list, and ArchiveService.
- Collector: CollectMemoryPressureEventsAsync queries the ring buffer and
  client-side-dedupes against DuckDB's MAX(sample_time). Azure SQL DB returns
  zero rows (ring buffer not exposed there). Scheduled every 5 min (Aggressive
  and Balanced presets) or 15 min (Low-Impact).
- UI: new 'Memory Pressure Events' sub-tab on the Memory tab with the same
  stacked-bar chart as Dashboard (SQL Server medium/severe, Operating System
  medium/severe). Wired into full-load and sub-tab-switch refresh paths.
- Hover: ported the BarPlot support from Dashboard's ChartHoverHelper so bar
  tooltips work and report the correct segment height for stacked bars.
- MCP: new get_memory_pressure_events tool + the 'Interpreting Memory
  Pressure Events' guidance section in McpInstructions.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
---
 Lite/Controls/ServerTab.xaml                  |   7 +
 Lite/Controls/ServerTab.xaml.cs               | 129 +++++++++++++++++-
 Lite/Database/DuckDbInitializer.cs            |  19 ++-
 Lite/Database/Schema.cs                       |  17 +++
 Lite/Helpers/ChartHoverHelper.cs              |  50 ++++++-
 Lite/Mcp/McpInstructions.cs                   |  44 ++++++
 Lite/Mcp/McpMemoryTools.cs                    |  53 +++++++
 Lite/Services/ArchiveService.cs               |   1 +
 Lite/Services/LocalDataService.Memory.cs      |  50 +++++++
 .../Services/RemoteCollectorService.Memory.cs | 104 ++++++++++++++
 Lite/Services/RemoteCollectorService.cs       |   1 +
 Lite/Services/ScheduleManager.cs              |   4 +
 12 files changed, 467 insertions(+), 12 deletions(-)

diff --git a/Lite/Controls/ServerTab.xaml b/Lite/Controls/ServerTab.xaml
index e85bc382..749a3b3e 100644
--- a/Lite/Controls/ServerTab.xaml
+++ b/Lite/Controls/ServerTab.xaml
@@ -1176,6 +1176,13 @@
                         </Grid>
                     </TabItem>
 
+                    <!-- Memory Pressure Events Sub-Tab -->
+                    <TabItem Header="Memory Pressure Events">
+                        <Grid>
+                            <ScottPlot:WpfPlot x:Name="MemoryPressureEventsChart" Margin="5"/>
+                        </Grid>
+                    </TabItem>
+
                 </TabControl>
             </TabItem>
 
diff --git a/Lite/Controls/ServerTab.xaml.cs b/Lite/Controls/ServerTab.xaml.cs
index 24ed8f90..b15e362b 100644
--- a/Lite/Controls/ServerTab.xaml.cs
+++ b/Lite/Controls/ServerTab.xaml.cs
@@ -65,6 +65,7 @@ public partial class ServerTab : UserControl
     private Helpers.ChartHoverHelper? _memoryClerksHover;
     private Helpers.ChartHoverHelper? _memoryGrantSizingHover;
     private Helpers.ChartHoverHelper? _memoryGrantActivityHover;
+    private Helpers.ChartHoverHelper? _memoryPressureEventsHover;
     private Helpers.ChartHoverHelper? _currentWaitsDurationHover;
     private Helpers.ChartHoverHelper? _currentWaitsBlockedHover;
 
@@ -202,6 +203,7 @@ public ServerTab(ServerConnection server, DuckDbInitializer duckDb, CredentialSe
         ApplyTheme(MemoryClerksChart);
         ApplyTheme(MemoryGrantSizingChart);
         ApplyTheme(MemoryGrantActivityChart);
+        ApplyTheme(MemoryPressureEventsChart);
         ApplyTheme(FileIoReadChart);
         ApplyTheme(FileIoWriteChart);
         ApplyTheme(FileIoReadThroughputChart);
@@ -240,6 +242,7 @@ public ServerTab(ServerConnection server, DuckDbInitializer duckDb, CredentialSe
         _memoryClerksHover = new Helpers.ChartHoverHelper(MemoryClerksChart, "MB");
         _memoryGrantSizingHover = new Helpers.ChartHoverHelper(MemoryGrantSizingChart, "MB");
         _memoryGrantActivityHover = new Helpers.ChartHoverHelper(MemoryGrantActivityChart, "");
+        _memoryPressureEventsHover = new Helpers.ChartHoverHelper(MemoryPressureEventsChart, "events");
         _currentWaitsDurationHover = new Helpers.ChartHoverHelper(CurrentWaitsDurationChart, "ms");
         _currentWaitsBlockedHover = new Helpers.ChartHoverHelper(CurrentWaitsBlockedChart, "sessions");
 
@@ -918,6 +921,7 @@ private async System.Threading.Tasks.Task RefreshAllTabsAsync(int hoursBack, Dat
         var queryStoreTask = _dataService.GetQueryStoreTopQueriesAsync(_serverId, hoursBack, 50, fromDate, toDate);
         var memoryGrantTrendTask = _dataService.GetMemoryGrantTrendAsync(_serverId, hoursBack, fromDate, toDate);
         var memoryGrantChartTask = _dataService.GetMemoryGrantChartDataAsync(_serverId, hoursBack, fromDate, toDate);
+        var memoryPressureEventsTask = _dataService.GetMemoryPressureEventsAsync(_serverId, hoursBack, fromDate, toDate);
         var serverConfigTask = SafeQueryAsync(() => _dataService.GetLatestServerConfigAsync(_serverId));
         var databaseConfigTask = SafeQueryAsync(() => _dataService.GetLatestDatabaseConfigAsync(_serverId));
         var databaseScopedConfigTask = SafeQueryAsync(() => _dataService.GetLatestDatabaseScopedConfigAsync(_serverId));
@@ -931,7 +935,7 @@ await System.Threading.Tasks.Task.WhenAll(
             snapshotsTask, cpuTask, memoryTask, memoryTrendTask,
             queryStatsTask, procStatsTask, fileIoTrendTask, fileIoThroughputTask, tempDbTask, tempDbFileIoTask,
             deadlockTask, blockedProcessTask, waitTypesTask, memoryClerkTypesTask, perfmonCountersTask,
-            queryStoreTask, memoryGrantTrendTask, memoryGrantChartTask,
+            queryStoreTask, memoryGrantTrendTask, memoryGrantChartTask, memoryPressureEventsTask,
             serverConfigTask, databaseConfigTask, databaseScopedConfigTask, traceFlagsTask,
             runningJobsTask, collectionHealthTask, collectionLogTask, dailySummaryTask);
 
@@ -1022,6 +1026,7 @@ await System.Threading.Tasks.Task.WhenAll(
         UpdateQueryStoreDurationTrendChart(queryStoreDurationTrendTask.Result);
         UpdateExecutionCountTrendChart(executionCountTrendTask.Result);
         UpdateMemoryGrantCharts(memoryGrantChartTask.Result);
+        UpdateMemoryPressureEventsChart(memoryPressureEventsTask.Result, hoursBack, fromDate, toDate);
 
         /* Populate pickers (preserve selections) */
         PopulateWaitTypePicker(waitTypesTask.Result);
@@ -1367,6 +1372,10 @@ private async System.Threading.Tasks.Task RefreshMemoryAsync(int hoursBack, Date
                         var grantChart = await _dataService.GetMemoryGrantChartDataAsync(_serverId, hoursBack, fromDate, toDate);
                         UpdateMemoryGrantCharts(grantChart);
                         break;
+                    case 3: // Memory Pressure Events
+                        var pressureEvents = await _dataService.GetMemoryPressureEventsAsync(_serverId, hoursBack, fromDate, toDate);
+                        UpdateMemoryPressureEventsChart(pressureEvents, hoursBack, fromDate, toDate);
+                        break;
                 }
                 return;
             }
@@ -1377,12 +1386,14 @@ private async System.Threading.Tasks.Task RefreshMemoryAsync(int hoursBack, Date
             var memoryClerkTypesTask = _dataService.GetDistinctMemoryClerkTypesAsync(_serverId, hoursBack, fromDate, toDate);
             var memoryGrantTrendTask = _dataService.GetMemoryGrantTrendAsync(_serverId, hoursBack, fromDate, toDate);
             var memoryGrantChartTask = _dataService.GetMemoryGrantChartDataAsync(_serverId, hoursBack, fromDate, toDate);
+            var memoryPressureEventsTask = _dataService.GetMemoryPressureEventsAsync(_serverId, hoursBack, fromDate, toDate);
 
-            await System.Threading.Tasks.Task.WhenAll(memoryTask, memoryTrendTask, memoryClerkTypesTask, memoryGrantTrendTask, memoryGrantChartTask);
+            await System.Threading.Tasks.Task.WhenAll(memoryTask, memoryTrendTask, memoryClerkTypesTask, memoryGrantTrendTask, memoryGrantChartTask, memoryPressureEventsTask);
 
             UpdateMemorySummary(memoryTask.Result);
             UpdateMemoryChart(memoryTrendTask.Result, memoryGrantTrendTask.Result);
             UpdateMemoryGrantCharts(memoryGrantChartTask.Result);
+            UpdateMemoryPressureEventsChart(memoryPressureEventsTask.Result, hoursBack, fromDate, toDate);
             PopulateMemoryClerkPicker(memoryClerkTypesTask.Result);
             await UpdateMemoryClerksChartFromPickerAsync();
         }
@@ -2033,6 +2044,119 @@ private void UpdateMemoryGrantCharts(List<MemoryGrantChartPoint> data)
         MemoryGrantActivityChart.Refresh();
     }
 
+    /// <summary>
+    /// Stacked bar chart of memory pressure events per hour, split by SQL Server (process) vs
+    /// Operating System (system) and stacked by severity (medium=indicator 2, severe=indicator >= 3).
+    /// </summary>
+    private void UpdateMemoryPressureEventsChart(List<MemoryPressureEventRow> data, int hoursBack, DateTime? fromDate, DateTime? toDate)
+    {
+        ClearChart(MemoryPressureEventsChart);
+        _memoryPressureEventsHover?.Clear();
+        ApplyTheme(MemoryPressureEventsChart);
+
+        DateTime rangeEnd = toDate ?? DateTime.UtcNow.AddMinutes(UtcOffsetMinutes);
+        DateTime rangeStart = fromDate ?? rangeEnd.AddHours(-hoursBack);
+        double xMin = rangeStart.ToOADate();
+        double xMax = rangeEnd.ToOADate();
+
+        /* Only count rows where SQL Server reported actual pressure (indicator >= 2 matches sp_pressuredetector). */
+        var pressureRows = data
+            .Where(d => d.MemoryIndicatorsProcess >= 2 || d.MemoryIndicatorsSystem >= 2)
+            .OrderBy(d => d.SampleTime)
+            .ToList();
+
+        bool hasData = false;
+        int maxBarCount = 0;
+
+        if (pressureRows.Count > 0)
+        {
+            var grouped = pressureRows
+                .GroupBy(d => new DateTime(d.SampleTime.Year, d.SampleTime.Month, d.SampleTime.Day, d.SampleTime.Hour, 0, 0))
+                .OrderBy(g => g.Key)
+                .ToList();
+
+            double hourWidth = 1.0 / 24.0;
+            double barSize = hourWidth * 0.4;
+            double barOffset = hourWidth * 0.22;
+
+            var sqlMediumColor = ScottPlot.Color.FromHex("#FFB74D"); // orange 300
+            var sqlSevereColor = ScottPlot.Color.FromHex("#E65100"); // orange 900
+            var osMediumColor = ScottPlot.Color.FromHex("#E57373");  // red 300
+            var osSevereColor = ScottPlot.Color.FromHex("#B71C1C");  // red 900
+
+            var sqlMediumBars = new List<ScottPlot.Bar>();
+            var sqlSevereBars = new List<ScottPlot.Bar>();
+            var osMediumBars = new List<ScottPlot.Bar>();
+            var osSevereBars = new List<ScottPlot.Bar>();
+
+            foreach (var g in grouped)
+            {
+                int sqlMedium = g.Count(d => d.MemoryIndicatorsProcess == 2);
+                int sqlSevere = g.Count(d => d.MemoryIndicatorsProcess >= 3);
+                int osMedium = g.Count(d => d.MemoryIndicatorsSystem == 2);
+                int osSevere = g.Count(d => d.MemoryIndicatorsSystem >= 3);
+                double x = g.Key.AddMinutes(UtcOffsetMinutes).ToOADate();
+
+                if (sqlMedium > 0)
+                    sqlMediumBars.Add(new ScottPlot.Bar { Position = x - barOffset, ValueBase = 0, Value = sqlMedium, Size = barSize, FillColor = sqlMediumColor, LineWidth = 0 });
+                if (sqlSevere > 0)
+                    sqlSevereBars.Add(new ScottPlot.Bar { Position = x - barOffset, ValueBase = sqlMedium, Value = sqlMedium + sqlSevere, Size = barSize, FillColor = sqlSevereColor, LineWidth = 0 });
+                if (osMedium > 0)
+                    osMediumBars.Add(new ScottPlot.Bar { Position = x + barOffset, ValueBase = 0, Value = osMedium, Size = barSize, FillColor = osMediumColor, LineWidth = 0 });
+                if (osSevere > 0)
+                    osSevereBars.Add(new ScottPlot.Bar { Position = x + barOffset, ValueBase = osMedium, Value = osMedium + osSevere, Size = barSize, FillColor = osSevereColor, LineWidth = 0 });
+
+                int sqlTotal = sqlMedium + sqlSevere;
+                int osTotal = osMedium + osSevere;
+                if (sqlTotal > maxBarCount) maxBarCount = sqlTotal;
+                if (osTotal > maxBarCount) maxBarCount = osTotal;
+            }
+
+            if (sqlMediumBars.Count > 0 || sqlSevereBars.Count > 0 || osMediumBars.Count > 0 || osSevereBars.Count > 0)
+            {
+                hasData = true;
+
+                if (sqlMediumBars.Count > 0)
+                {
+                    var bp = MemoryPressureEventsChart.Plot.Add.Bars(sqlMediumBars);
+                    bp.LegendText = "SQL Server (medium)";
+                    _memoryPressureEventsHover?.Add(bp, "SQL Server (medium)");
+                }
+                if (sqlSevereBars.Count > 0)
+                {
+                    var bp = MemoryPressureEventsChart.Plot.Add.Bars(sqlSevereBars);
+                    bp.LegendText = "SQL Server (severe)";
+                    _memoryPressureEventsHover?.Add(bp, "SQL Server (severe)");
+                }
+                if (osMediumBars.Count > 0)
+                {
+                    var bp = MemoryPressureEventsChart.Plot.Add.Bars(osMediumBars);
+                    bp.LegendText = "Operating System (medium)";
+                    _memoryPressureEventsHover?.Add(bp, "Operating System (medium)");
+                }
+                if (osSevereBars.Count > 0)
+                {
+                    var bp = MemoryPressureEventsChart.Plot.Add.Bars(osSevereBars);
+                    bp.LegendText = "Operating System (severe)";
+                    _memoryPressureEventsHover?.Add(bp, "Operating System (severe)");
+                }
+            }
+        }
+
+        MemoryPressureEventsChart.Plot.Axes.DateTimeTicksBottomDateChange();
+        MemoryPressureEventsChart.Plot.Axes.SetLimitsX(xMin, xMax);
+        ReapplyAxisColors(MemoryPressureEventsChart);
+        MemoryPressureEventsChart.Plot.YLabel("Pressure Events per Hour");
+        SetChartYLimitsWithLegendPadding(MemoryPressureEventsChart, 0, Math.Max(maxBarCount, 5));
+
+        if (hasData)
+        {
+            ShowChartLegend(MemoryPressureEventsChart);
+        }
+
+        MemoryPressureEventsChart.Refresh();
+    }
+
     private void UpdateTempDbChart(List<TempDbRow> data)
     {
         ClearChart(TempDbChart);
@@ -5367,6 +5491,7 @@ public void DisposeChartHelpers()
         _memoryClerksHover?.Dispose();
         _memoryGrantSizingHover?.Dispose();
         _memoryGrantActivityHover?.Dispose();
+        _memoryPressureEventsHover?.Dispose();
         _currentWaitsDurationHover?.Dispose();
         _currentWaitsBlockedHover?.Dispose();
     }
diff --git a/Lite/Database/DuckDbInitializer.cs b/Lite/Database/DuckDbInitializer.cs
index c7295783..e767c6d4 100644
--- a/Lite/Database/DuckDbInitializer.cs
+++ b/Lite/Database/DuckDbInitializer.cs
@@ -97,7 +97,7 @@ public void Dispose()
     /// <summary>
     /// Current schema version. Increment this when schema changes require table rebuilds.
     /// </summary>
-    internal const int CurrentSchemaVersion = 24;
+    internal const int CurrentSchemaVersion = 25;
 
     private readonly string _archivePath;
 
@@ -114,8 +114,8 @@ public DuckDbInitializer(string databasePath, ILogger<DuckDbInitializer>? logger
     [
         "wait_stats", "query_stats", "procedure_stats", "query_store_stats",
         "query_snapshots", "cpu_utilization_stats", "file_io_stats", "memory_stats",
-        "memory_clerks", "tempdb_stats", "perfmon_stats", "deadlocks",
-        "blocked_process_reports", "memory_grant_stats", "waiting_tasks",
+        "memory_clerks", "memory_pressure_events", "tempdb_stats", "perfmon_stats",
+        "deadlocks", "blocked_process_reports", "memory_grant_stats", "waiting_tasks",
         "running_jobs", "database_size_stats", "server_properties",
         "session_stats", "server_config", "database_config",
         "database_scoped_config", "trace_flags", "config_alert_log",
@@ -639,6 +639,13 @@ New tables only — no existing table changes needed. Tables created by
                 throw;
             }
         }
+
+        if (fromVersion < 25)
+        {
+            /* v25: Added memory_pressure_events table for RING_BUFFER_RESOURCE_MONITOR notifications.
+                    New table only — created by GetAllTableStatements(). */
+            _logger?.LogInformation("Running migration to v25: adding memory_pressure_events table");
+        }
     }
 
     /// <summary>
@@ -651,9 +658,9 @@ private async Task FixServerIdsAsync(DuckDBConnection connection)
         var tablesWithServerId = new[]
         {
             "servers", "collection_log", "wait_stats", "query_stats", "cpu_utilization_stats",
-            "file_io_stats", "memory_stats", "memory_clerks", "deadlocks",
-            "procedure_stats", "query_store_stats", "query_snapshots", "tempdb_stats",
-            "perfmon_stats", "server_config", "database_config",
+            "file_io_stats", "memory_stats", "memory_clerks", "memory_pressure_events",
+            "deadlocks", "procedure_stats", "query_store_stats", "query_snapshots",
+            "tempdb_stats", "perfmon_stats", "server_config", "database_config",
             "blocked_process_reports", "memory_grant_stats", "waiting_tasks"
         };
 
diff --git a/Lite/Database/Schema.cs b/Lite/Database/Schema.cs
index be4b3561..e8d8b7b8 100644
--- a/Lite/Database/Schema.cs
+++ b/Lite/Database/Schema.cs
@@ -190,6 +190,18 @@ CREATE TABLE IF NOT EXISTS memory_clerks (
     memory_mb DECIMAL(18,2)
 )";
 
+    public const string CreateMemoryPressureEventsTable = @"
+CREATE TABLE IF NOT EXISTS memory_pressure_events (
+    collection_id BIGINT PRIMARY KEY,
+    collection_time TIMESTAMP NOT NULL,
+    server_id INTEGER NOT NULL,
+    server_name VARCHAR NOT NULL,
+    sample_time TIMESTAMP NOT NULL,
+    memory_notification VARCHAR NOT NULL,
+    memory_indicators_process INTEGER NOT NULL,
+    memory_indicators_system INTEGER NOT NULL
+)";
+
     public const string CreateDeadlocksTable = @"
 CREATE TABLE IF NOT EXISTS deadlocks (
     deadlock_id BIGINT PRIMARY KEY,
@@ -519,6 +531,9 @@ is_optimized_locking_on BOOLEAN
     public const string CreateMemoryIndex = @"
 CREATE INDEX IF NOT EXISTS idx_memory_time ON memory_stats(server_id, collection_time)";
 
+    public const string CreateMemoryPressureEventsIndex = @"
+CREATE INDEX IF NOT EXISTS idx_memory_pressure_events_time ON memory_pressure_events(server_id, sample_time)";
+
     public const string CreateTempdbIndex = @"
 CREATE INDEX IF NOT EXISTS idx_tempdb_time ON tempdb_stats(server_id, collection_time)";
 
@@ -726,6 +741,7 @@ public static IEnumerable<string> GetAllTableStatements()
         yield return CreateFileIoStatsTable;
         yield return CreateMemoryStatsTable;
         yield return CreateMemoryClerksTable;
+        yield return CreateMemoryPressureEventsTable;
         yield return CreateDeadlocksTable;
         yield return CreateProcedureStatsTable;
         yield return CreateQueryStoreStatsTable;
@@ -769,6 +785,7 @@ public static IEnumerable<string> GetAllIndexStatements()
         yield return CreateWaitingTasksIndex;
         yield return CreateBlockedProcessReportsIndex;
         yield return CreateMemoryClerksIndex;
+        yield return CreateMemoryPressureEventsIndex;
         yield return CreateDatabaseScopedConfigIndex;
         yield return CreateTraceFlagsIndex;
         yield return CreateRunningJobsIndex;
diff --git a/Lite/Helpers/ChartHoverHelper.cs b/Lite/Helpers/ChartHoverHelper.cs
index 794b293b..28241eb4 100644
--- a/Lite/Helpers/ChartHoverHelper.cs
+++ b/Lite/Helpers/ChartHoverHelper.cs
@@ -17,6 +17,7 @@ internal sealed class ChartHoverHelper
 {
     private readonly ScottPlot.WPF.WpfPlot _chart;
     private readonly List<(ScottPlot.Plottables.Scatter Scatter, string Label)> _scatters = new();
+    private readonly List<(ScottPlot.Plottables.BarPlot BarPlot, string Label)> _barPlots = new();
     private readonly Popup _popup;
     private readonly TextBlock _text;
     private string _unit;
@@ -62,20 +63,28 @@ public void Dispose()
         _chart.MouseLeave -= OnMouseLeave;
         _popup.IsOpen = false;
         _scatters.Clear();
+        _barPlots.Clear();
     }
 
-    public void Clear() => _scatters.Clear();
+    public void Clear()
+    {
+        _scatters.Clear();
+        _barPlots.Clear();
+    }
 
     public void Add(ScottPlot.Plottables.Scatter scatter, string label) =>
         _scatters.Add((scatter, label));
 
+    public void Add(ScottPlot.Plottables.BarPlot barPlot, string label) =>
+        _barPlots.Add((barPlot, label));
+
     /// <summary>
     /// Returns the nearest series label and data-point time for the given mouse position,
     /// or null if no series is close enough.
     /// </summary>
     public (string Label, DateTime Time)? GetNearestSeries(Point mousePos)
     {
-        if (_scatters.Count == 0) return null;
+        if (_scatters.Count == 0 && _barPlots.Count == 0) return null;
         var dpi = VisualTreeHelper.GetDpi(_chart);
         var pixel = new ScottPlot.Pixel(
             (float)(mousePos.X * dpi.DpiScaleX),
@@ -103,14 +112,42 @@ public void Add(ScottPlot.Plottables.Scatter scatter, string label) =>
             }
         }
 
+        FindNearestBar(pixel, ref bestDistance, ref bestPoint, ref bestLabel);
+
         if (bestPoint.IsReal && bestDistance < 2500) // ~50px radius
             return (bestLabel, DateTime.FromOADate(bestPoint.X));
         return null;
     }
 
+    private void FindNearestBar(ScottPlot.Pixel pixel, ref double bestDistance,
+        ref ScottPlot.DataPoint bestPoint, ref string bestLabel)
+    {
+        foreach (var (barPlot, label) in _barPlots)
+        {
+            foreach (var bar in barPlot.Bars)
+            {
+                var topPixel = _chart.Plot.GetPixel(new ScottPlot.Coordinates(bar.Position, bar.Value));
+                double halfWidthPx = Math.Abs(
+                    _chart.Plot.GetPixel(new ScottPlot.Coordinates(bar.Position + bar.Size / 2, bar.Value)).X
+                    - topPixel.X);
+                double dx = Math.Abs(topPixel.X - pixel.X);
+                if (dx > halfWidthPx + 4) continue;
+                double dy = Math.Abs(topPixel.Y - pixel.Y);
+                double dist = dx * dx + dy * dy;
+                if (dist < bestDistance)
+                {
+                    bestDistance = dist;
+                    double segmentHeight = bar.Value - bar.ValueBase;
+                    bestPoint = new ScottPlot.DataPoint(new ScottPlot.Coordinates(bar.Position, segmentHeight), 0);
+                    bestLabel = label;
+                }
+            }
+        }
+    }
+
     private void OnMouseMove(object sender, MouseEventArgs e)
     {
-        if (_scatters.Count == 0) return;
+        if (_scatters.Count == 0 && _barPlots.Count == 0) return;
         var now = DateTime.UtcNow;
         if ((now - _lastUpdate).TotalMilliseconds < 50) return;
         _lastUpdate = now;
@@ -145,10 +182,15 @@ private void OnMouseMove(object sender, MouseEventArgs e)
             }
         }
 
+        FindNearestBar(pixel, ref bestDistance, ref bestPoint, ref bestLabel);
+
         if (bestPoint.IsReal && bestDistance < 2500) // ~50px radius
         {
             var time = ServerTimeHelper.ConvertForDisplay(DateTime.FromOADate(bestPoint.X), ServerTimeHelper.CurrentDisplayMode);
-            _text.Text = $"{bestLabel}\n{bestPoint.Y:N1} {_unit}\n{time:HH:mm:ss}";
+            string valueFormatted = (bestPoint.Y == Math.Floor(bestPoint.Y))
+                ? bestPoint.Y.ToString("N0")
+                : bestPoint.Y.ToString("N1");
+            _text.Text = $"{bestLabel}\n{valueFormatted} {_unit}\n{time:HH:mm:ss}";
             _popup.HorizontalOffset = pos.X + 15;
             _popup.VerticalOffset = pos.Y + 15;
             _popup.IsOpen = true;
diff --git a/Lite/Mcp/McpInstructions.cs b/Lite/Mcp/McpInstructions.cs
index c063783b..766fcc9c 100644
--- a/Lite/Mcp/McpInstructions.cs
+++ b/Lite/Mcp/McpInstructions.cs
@@ -78,6 +78,7 @@ You are connected to a SQL Server performance monitoring tool via Performance Mo
         | `get_memory_trend` | Memory usage over time | `server_name`, `hours_back` |
         | `get_memory_clerks` | Top memory consumers by clerk type | `server_name` |
         | `get_memory_grants` | Active/recent memory grants (detect grant pressure) | `server_name`, `hours_back` (default 1), `limit` |
+        | `get_memory_pressure_events` | Ring buffer memory pressure notifications (sp_pressuredetector source) | `server_name`, `hours_back` |
 
         ### I/O Tools
         | Tool | Purpose | Key Parameters |
@@ -196,6 +197,49 @@ You are connected to a SQL Server performance monitoring tool via Performance Mo
 
         **Use `get_blocking` first** for a quick overview. **Use `get_blocked_process_reports`** when you need detailed analysis of prolonged blocking events.
 
+        ## Interpreting Memory Pressure Events
+
+        `get_memory_pressure_events` returns notifications from the `RING_BUFFER_RESOURCE_MONITOR` ring buffer. The `memory_indicators_process` and `memory_indicators_system` values are SQL Server's Resource Monitor signals. Indicator scale:
+
+        - **0-1**: normal operating state, not actionable
+        - **2 (medium)**: Resource Monitor has crossed a threshold and is starting to respond — trimming caches, reducing memory grants. Worth investigating if sustained or frequent.
+        - **3+ (severe)**: aggressive response — buffer pool pages are being evicted, plan cache entries thrown out, workspace memory starved. Always worth investigating.
+
+        The two indicators report different things:
+
+        - `memory_indicators_process` — the SQL Server *process itself* is under memory pressure. Usually workload-induced (large memory grants, plan cache bloat, buffer pool churn).
+        - `memory_indicators_system` — Windows is signaling low memory *system-wide*. Something on the whole box is consuming memory; SQL Server may or may not be the culprit.
+
+        ### What to check when process pressure (indicator >= 2) fires
+
+        The workload is squeezing SQL Server itself. Follow-up tools:
+        | Signal to check | Tool |
+        |-----------------|------|
+        | Memory grant contention, workspace memory pressure | `get_memory_grants` |
+        | Buffer pool composition, memory clerk distribution | `get_memory_clerks` |
+        | Page Life Expectancy, target vs total server memory | `get_memory_stats`, `get_memory_trend` |
+        | Queries that requested large grants during the window | `get_top_queries_by_cpu` |
+        | `RESOURCE_SEMAPHORE` waits in the same window | `get_wait_stats`, `get_wait_trend` |
+
+        ### What to check when system pressure (indicator >= 2) fires but process does not
+
+        The box is tight on memory, but SQL Server's own process is not the cause. SQL Server feels Windows' low-memory notification but isn't driving it. Typical root causes: other services on the machine (anti-virus, backup agents, monitoring agents, additional SQL instances, SSIS/SSRS, RDP sessions), oversized file system cache, or VM-host memory oversubscription. Follow-up:
+
+        | Signal to check | Tool |
+        |-----------------|------|
+        | SQL Server's memory configuration (`max server memory` vs total RAM) | `get_server_properties` |
+        | Is SQL Server itself actually fine? | `get_memory_stats`, `get_memory_clerks` |
+
+        Most of the diagnosis in this case is *outside* the monitored SQL instance — tell the user to check what else is running on the host.
+
+        ### Patterns
+
+        - **Both process and system firing together** → real capacity problem. Add RAM, tune the workload, or reduce concurrency.
+        - **Process only** → workload/schema issue, not a hardware problem. Tune queries and indexes.
+        - **System only** → non-SQL workload on the host; SQL itself is healthy but the tenant mix is tight.
+        - **Bursty spikes** → correlate the pressure window with `get_running_jobs` (scheduled maintenance, index rebuilds, big reports) and `get_top_queries_by_cpu` for that period.
+        - **Flat-line sustained** → chronic under-provisioning; memory needs to grow or workload needs to shrink.
+
         ## Tool Relationships
 
         - `get_wait_stats` identifies the symptom category (CPU, I/O, locks, parallelism). Other tools find the root cause.
diff --git a/Lite/Mcp/McpMemoryTools.cs b/Lite/Mcp/McpMemoryTools.cs
index 920797a8..5de9eccd 100644
--- a/Lite/Mcp/McpMemoryTools.cs
+++ b/Lite/Mcp/McpMemoryTools.cs
@@ -124,6 +124,59 @@ public static async Task<string> GetMemoryClerks(
         }
     }
 
+    [McpServerTool(Name = "get_memory_pressure_events"), Description(@"Gets memory pressure notifications from the RING_BUFFER_RESOURCE_MONITOR ring buffer (same source as sp_pressuredetector). Returns RESOURCE_MEMPHYSICAL_LOW, RESOURCE_MEMVIRTUAL_LOW, RESOURCE_MEMPHYSICAL_HIGH, and RESOURCE_MEM_STEADY notifications with indicator values.
+
+Indicator scale (applies to both memory_indicators_process and memory_indicators_system):
+  0-1 = normal, no pressure
+  2   = medium pressure (SQL Server's Resource Monitor starts trimming caches and reducing grants)
+  3+  = severe pressure (aggressive buffer pool / plan cache eviction)
+
+memory_indicators_process = SQL Server process itself is under memory pressure (workload-induced).
+memory_indicators_system  = Windows is signaling low memory system-wide (could be other tenants on the box).
+
+Not available on Azure SQL DB (ring buffer not exposed). For actionable interpretation and suggested follow-up tools, see the 'Interpreting Memory Pressure Events' section of the server instructions.")]
+    public static async Task<string> GetMemoryPressureEvents(
+        LocalDataService dataService,
+        ServerManager serverManager,
+        [Description("Server name or display name.")] string? server_name = null,
+        [Description("Hours of history. Default 24.")] int hours_back = 24)
+    {
+        var resolved = ServerResolver.Resolve(serverManager, server_name);
+        if (resolved == null)
+        {
+            return $"Could not resolve server. Available servers:\n{ServerResolver.ListAvailableServers(serverManager)}";
+        }
+
+        try
+        {
+            var hoursError = McpHelpers.ValidateHoursBack(hours_back);
+            if (hoursError != null) return hoursError;
+
+            var rows = await dataService.GetMemoryPressureEventsAsync(resolved.Value.ServerId, hours_back);
+            if (rows.Count == 0)
+            {
+                return "No memory pressure events found in the requested time range.";
+            }
+
+            return JsonSerializer.Serialize(new
+            {
+                server = resolved.Value.ServerName,
+                hours_back,
+                events = rows.Select(r => new
+                {
+                    sample_time = r.SampleTime.ToString("o"),
+                    memory_notification = r.MemoryNotification,
+                    memory_indicators_process = r.MemoryIndicatorsProcess,
+                    memory_indicators_system = r.MemoryIndicatorsSystem
+                })
+            }, McpHelpers.JsonOptions);
+        }
+        catch (Exception ex)
+        {
+            return McpHelpers.FormatError("get_memory_pressure_events", ex);
+        }
+    }
+
     [McpServerTool(Name = "get_memory_grants"), Description("Gets resource semaphore statistics showing granted vs available workspace memory per resource pool, waiter counts, and timeout/forced grant deltas. High waiter counts or rising timeout deltas indicate memory grant pressure affecting query performance.")]
     public static async Task<string> GetMemoryGrants(
         LocalDataService dataService,
diff --git a/Lite/Services/ArchiveService.cs b/Lite/Services/ArchiveService.cs
index 35d9c7e1..d7789e5d 100644
--- a/Lite/Services/ArchiveService.cs
+++ b/Lite/Services/ArchiveService.cs
@@ -56,6 +56,7 @@ internal static readonly (string Table, string TimeColumn)[] ArchivableTables =
         ("file_io_stats", "collection_time"),
         ("memory_stats", "collection_time"),
         ("memory_clerks", "collection_time"),
+        ("memory_pressure_events", "collection_time"),
         ("tempdb_stats", "collection_time"),
         ("perfmon_stats", "collection_time"),
         ("deadlocks", "collection_time"),
diff --git a/Lite/Services/LocalDataService.Memory.cs b/Lite/Services/LocalDataService.Memory.cs
index 3b581927..38b9e94a 100644
--- a/Lite/Services/LocalDataService.Memory.cs
+++ b/Lite/Services/LocalDataService.Memory.cs
@@ -181,6 +181,48 @@ FROM v_memory_clerks
         return items;
     }
 
+    /// <summary>
+    /// Gets memory pressure events (from RING_BUFFER_RESOURCE_MONITOR) for charting.
+    /// </summary>
+    public async Task<List<MemoryPressureEventRow>> GetMemoryPressureEventsAsync(int serverId, int hoursBack = 24, DateTime? fromDate = null, DateTime? toDate = null)
+    {
+        using var connection = await OpenConnectionAsync();
+        using var command = connection.CreateCommand();
+
+        var (startTime, endTime) = GetTimeRange(hoursBack, fromDate, toDate);
+
+        command.CommandText = @"
+SELECT
+    sample_time,
+    memory_notification,
+    memory_indicators_process,
+    memory_indicators_system
+FROM v_memory_pressure_events
+WHERE server_id = $1
+AND   sample_time >= $2
+AND   sample_time <= $3
+ORDER BY sample_time";
+
+        command.Parameters.Add(new DuckDBParameter { Value = serverId });
+        command.Parameters.Add(new DuckDBParameter { Value = startTime });
+        command.Parameters.Add(new DuckDBParameter { Value = endTime });
+
+        var items = new List<MemoryPressureEventRow>();
+        using var reader = await command.ExecuteReaderAsync();
+        while (await reader.ReadAsync())
+        {
+            items.Add(new MemoryPressureEventRow
+            {
+                SampleTime = reader.GetDateTime(0),
+                MemoryNotification = reader.IsDBNull(1) ? "" : reader.GetString(1),
+                MemoryIndicatorsProcess = reader.IsDBNull(2) ? 0 : reader.GetInt32(2),
+                MemoryIndicatorsSystem = reader.IsDBNull(3) ? 0 : reader.GetInt32(3)
+            });
+        }
+
+        return items;
+    }
+
     /// <summary>
     /// Gets the latest memory clerk breakdown.
     /// </summary>
@@ -252,3 +294,11 @@ public class MemoryClerkTrendPoint
     public string ClerkType { get; set; } = "";
     public double MemoryMb { get; set; }
 }
+
+public class MemoryPressureEventRow
+{
+    public DateTime SampleTime { get; set; }
+    public string MemoryNotification { get; set; } = "";
+    public int MemoryIndicatorsProcess { get; set; }
+    public int MemoryIndicatorsSystem { get; set; }
+}
diff --git a/Lite/Services/RemoteCollectorService.Memory.cs b/Lite/Services/RemoteCollectorService.Memory.cs
index 4af53786..e90339e7 100644
--- a/Lite/Services/RemoteCollectorService.Memory.cs
+++ b/Lite/Services/RemoteCollectorService.Memory.cs
@@ -266,4 +266,108 @@ ORDER BY
         _logger?.LogDebug("Collected {RowCount} memory clerks for server '{Server}'", rowsCollected, server.DisplayName);
         return rowsCollected;
     }
+
+    /// <summary>
+    /// Collects memory pressure notifications from RING_BUFFER_RESOURCE_MONITOR.
+    /// Same source as sp_pressuredetector — reports IndicatorsProcess/IndicatorsSystem
+    /// (0-1 normal, 2 medium pressure, 3+ severe) alongside the notification type.
+    /// Azure SQL DB does not expose sys.dm_os_ring_buffers, so this collector returns 0 there.
+    /// </summary>
+    private async Task<int> CollectMemoryPressureEventsAsync(ServerConnection server, CancellationToken cancellationToken)
+    {
+        var serverStatus = _serverManager.GetConnectionStatus(server.Id);
+        bool isAzureSqlDb = serverStatus.SqlEngineEdition == 5;
+
+        _lastSqlMs = 0;
+        _lastDuckDbMs = 0;
+
+        if (isAzureSqlDb)
+        {
+            /* Ring buffer is not exposed on Azure SQL DB */
+            return 0;
+        }
+
+        const string query = @"
+SET TRANSACTION ISOLATION LEVEL READ UNCOMMITTED;
+
+DECLARE
+    @ms_ticks bigint,
+    @now datetime2(7) = SYSDATETIME();
+
+SELECT @ms_ticks = dosi.ms_ticks FROM sys.dm_os_sys_info AS dosi;
+
+SELECT
+    sample_time = DATEADD(SECOND, -((@ms_ticks - t.timestamp) / 1000), @now),
+    memory_notification = t.record.value('(/Record/ResourceMonitor/Notification)[1]', 'nvarchar(100)'),
+    memory_indicators_process = t.record.value('(/Record/ResourceMonitor/IndicatorsProcess)[1]', 'integer'),
+    memory_indicators_system = t.record.value('(/Record/ResourceMonitor/IndicatorsSystem)[1]', 'integer')
+FROM
+(
+    SELECT
+        dorb.timestamp,
+        record = CONVERT(xml, dorb.record)
+    FROM sys.dm_os_ring_buffers AS dorb
+    WHERE dorb.ring_buffer_type = N'RING_BUFFER_RESOURCE_MONITOR'
+) AS t
+ORDER BY t.timestamp
+OPTION(RECOMPILE);";
+
+        var serverId = GetServerId(server);
+        var collectionTime = DateTime.UtcNow;
+        var rowsCollected = 0;
+
+        /* Client-side dedup: computed sample_time cannot be filtered server-side
+           (it's derived from ms_ticks on each read). Fetch all and skip rows we already have. */
+        var lastSampleTime = await GetLastCollectedTimeAsync(
+            serverId, "memory_pressure_events", "sample_time", cancellationToken);
+
+        var sqlSw = Stopwatch.StartNew();
+        using var sqlConnection = await CreateConnectionAsync(server, cancellationToken);
+        using var command = new SqlCommand(query, sqlConnection);
+        command.CommandTimeout = CommandTimeoutSeconds;
+
+        using var reader = await command.ExecuteReaderAsync(cancellationToken);
+        sqlSw.Stop();
+        _lastSqlMs = sqlSw.ElapsedMilliseconds;
+
+        var duckSw = Stopwatch.StartNew();
+
+        using (var duckConnection = _duckDb.CreateConnection())
+        {
+            await duckConnection.OpenAsync(cancellationToken);
+
+            using (var appender = duckConnection.CreateAppender("memory_pressure_events"))
+            {
+                while (await reader.ReadAsync(cancellationToken))
+                {
+                    var sampleTime = reader.IsDBNull(0) ? DateTime.MinValue : reader.GetDateTime(0);
+                    if (lastSampleTime.HasValue && sampleTime <= lastSampleTime.Value)
+                        continue;
+
+                    var notification = reader.IsDBNull(1) ? "" : reader.GetString(1);
+                    var indicatorsProcess = reader.IsDBNull(2) ? 0 : reader.GetInt32(2);
+                    var indicatorsSystem = reader.IsDBNull(3) ? 0 : reader.GetInt32(3);
+
+                    var row = appender.CreateRow();
+                    row.AppendValue(GenerateCollectionId())
+                       .AppendValue(collectionTime)
+                       .AppendValue(serverId)
+                       .AppendValue(GetServerNameForStorage(server))
+                       .AppendValue(sampleTime)
+                       .AppendValue(notification)
+                       .AppendValue(indicatorsProcess)
+                       .AppendValue(indicatorsSystem)
+                       .EndRow();
+
+                    rowsCollected++;
+                }
+            }
+        }
+
+        duckSw.Stop();
+        _lastDuckDbMs = duckSw.ElapsedMilliseconds;
+
+        _logger?.LogDebug("Collected {RowCount} memory pressure events for server '{Server}'", rowsCollected, server.DisplayName);
+        return rowsCollected;
+    }
 }
diff --git a/Lite/Services/RemoteCollectorService.cs b/Lite/Services/RemoteCollectorService.cs
index c3564a71..541c4e53 100644
--- a/Lite/Services/RemoteCollectorService.cs
+++ b/Lite/Services/RemoteCollectorService.cs
@@ -389,6 +389,7 @@ public async Task RunCollectorAsync(ServerConnection server, string collectorNam
                 "cpu_utilization" => await CollectCpuUtilizationAsync(server, cancellationToken),
                 "memory_stats" => await CollectMemoryStatsAsync(server, cancellationToken),
                 "memory_clerks" => await CollectMemoryClerksAsync(server, cancellationToken),
+                "memory_pressure_events" => await CollectMemoryPressureEventsAsync(server, cancellationToken),
                 "file_io_stats" => await CollectFileIoStatsAsync(server, cancellationToken),
                 "query_stats" => await CollectQueryStatsAsync(server, cancellationToken),
                 "procedure_stats" => await CollectProcedureStatsAsync(server, cancellationToken),
diff --git a/Lite/Services/ScheduleManager.cs b/Lite/Services/ScheduleManager.cs
index d6a2bbd9..223c032c 100644
--- a/Lite/Services/ScheduleManager.cs
+++ b/Lite/Services/ScheduleManager.cs
@@ -38,6 +38,7 @@ public class ScheduleManager
             ["wait_stats"] = 1, ["query_stats"] = 1, ["procedure_stats"] = 1,
             ["query_store"] = 2, ["query_snapshots"] = 1, ["cpu_utilization"] = 1,
             ["file_io_stats"] = 1, ["memory_stats"] = 1, ["memory_clerks"] = 2,
+            ["memory_pressure_events"] = 5,
             ["tempdb_stats"] = 1, ["perfmon_stats"] = 1, ["deadlocks"] = 1,
             ["memory_grant_stats"] = 1, ["waiting_tasks"] = 1,
             ["blocked_process_report"] = 1, ["running_jobs"] = 2
@@ -47,6 +48,7 @@ public class ScheduleManager
             ["wait_stats"] = 1, ["query_stats"] = 1, ["procedure_stats"] = 1,
             ["query_store"] = 5, ["query_snapshots"] = 1, ["cpu_utilization"] = 1,
             ["file_io_stats"] = 1, ["memory_stats"] = 1, ["memory_clerks"] = 5,
+            ["memory_pressure_events"] = 5,
             ["tempdb_stats"] = 1, ["perfmon_stats"] = 1, ["deadlocks"] = 1,
             ["memory_grant_stats"] = 1, ["waiting_tasks"] = 1,
             ["blocked_process_report"] = 1, ["running_jobs"] = 5
@@ -56,6 +58,7 @@ public class ScheduleManager
             ["wait_stats"] = 5, ["query_stats"] = 10, ["procedure_stats"] = 10,
             ["query_store"] = 30, ["query_snapshots"] = 5, ["cpu_utilization"] = 5,
             ["file_io_stats"] = 10, ["memory_stats"] = 10, ["memory_clerks"] = 30,
+            ["memory_pressure_events"] = 15,
             ["tempdb_stats"] = 5, ["perfmon_stats"] = 5, ["deadlocks"] = 5,
             ["memory_grant_stats"] = 5, ["waiting_tasks"] = 5,
             ["blocked_process_report"] = 5, ["running_jobs"] = 30
@@ -739,6 +742,7 @@ private static List<CollectorSchedule> GetDefaultSchedules()
             new() { Name = "file_io_stats", Enabled = true, FrequencyMinutes = 1, RetentionDays = 30, Description = "File I/O statistics from sys.dm_io_virtual_file_stats" },
             new() { Name = "memory_stats", Enabled = true, FrequencyMinutes = 1, RetentionDays = 30, Description = "Memory statistics from sys.dm_os_sys_memory and performance counters" },
             new() { Name = "memory_clerks", Enabled = true, FrequencyMinutes = 5, RetentionDays = 30, Description = "Memory clerk allocations from sys.dm_os_memory_clerks" },
+            new() { Name = "memory_pressure_events", Enabled = true, FrequencyMinutes = 5, RetentionDays = 30, Description = "Memory pressure notifications from RING_BUFFER_RESOURCE_MONITOR" },
             new() { Name = "tempdb_stats", Enabled = true, FrequencyMinutes = 1, RetentionDays = 30, Description = "TempDB space usage from sys.dm_db_file_space_usage" },
             new() { Name = "perfmon_stats", Enabled = true, FrequencyMinutes = 1, RetentionDays = 30, Description = "Key performance counters from sys.dm_os_performance_counters" },
             new() { Name = "deadlocks", Enabled = true, FrequencyMinutes = 1, RetentionDays = 30, Description = "Deadlocks from system_health extended event session" },

From 04d2e24708a7b674db0f9c122c73dea5cad669b7 Mon Sep 17 00:00:00 2001
From: Erik Darling <2136037+erikdarlingdata@users.noreply.github.com>
Date: Sun, 19 Apr 2026 16:05:32 -0400
Subject: [PATCH 20/49] Bump schema table count test to 30 for
 memory_pressure_events

Companion update to the new memory_pressure_events table added in this PR.
SchemaStatements_MatchTableCount asserts the total table count; needs to
move from 29 to 30 to reflect the new table.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
---
 Lite.Tests/DuckDbSchemaTests.cs | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/Lite.Tests/DuckDbSchemaTests.cs b/Lite.Tests/DuckDbSchemaTests.cs
index c0526f64..1377db7a 100644
--- a/Lite.Tests/DuckDbSchemaTests.cs
+++ b/Lite.Tests/DuckDbSchemaTests.cs
@@ -138,8 +138,8 @@ public void SchemaStatements_MatchTableCount()
         foreach (var _ in Schema.GetAllTableStatements())
             tableCount++;
 
-        /* 29 tables from Schema (schema_version is created separately by DuckDbInitializer) */
-        Assert.Equal(29, tableCount);
+        /* 30 tables from Schema (schema_version is created separately by DuckDbInitializer) */
+        Assert.Equal(30, tableCount);
     }
 
     [Fact]

From 985da4a9a562f5ddbd9a10504a2f65630e32a3c1 Mon Sep 17 00:00:00 2001
From: Erik Darling <2136037+erikdarlingdata@users.noreply.github.com>
Date: Mon, 20 Apr 2026 11:31:12 -0400
Subject: [PATCH 21/49] Fix blocked process report plan lookup (#867) (#868)

Right-click > View Plan on a Blocked Process Reports row silently fell
through (no handler case) and Get Actual Plan erred with "no query text."

- Split the grid onto its own BlockedProcessContextMenu with separate
  View Blocked Plan / View Blocking Plan actions; drop Get Actual Plan
  (re-executing a mid-transaction blocked query is a foot-gun).
- Parse all <frame> entries from the BPR XML's executionStack, filter
  the 42-byte all-zero sql_handle placeholder (dynamic SQL / system
  context), default stmtstart=0 / stmtend=-1 per the dm_exec_text_query_plan
  convention. Matches sp_HumanEventsBlockViewer's XPath and join shape.
- Add FetchPlanBySqlHandleAsync keyed on sql_handle + statement offsets
  against sys.dm_exec_query_stats. Caller iterates frames until one
  resolves; falls back to a clear "plan no longer in cache" message.

Co-authored-by: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
---
 Lite/Controls/ServerTab.xaml                 | 28 +++++-
 Lite/Controls/ServerTab.xaml.cs              | 98 ++++++++++++++++++++
 Lite/Services/LocalDataService.QueryStats.cs | 66 +++++++++++++
 3 files changed, 191 insertions(+), 1 deletion(-)

diff --git a/Lite/Controls/ServerTab.xaml b/Lite/Controls/ServerTab.xaml
index 749a3b3e..6ee7b1cb 100644
--- a/Lite/Controls/ServerTab.xaml
+++ b/Lite/Controls/ServerTab.xaml
@@ -32,12 +32,38 @@
                 </MenuItem>
             </ContextMenu>
 
+            <!-- Context menu for Blocked Process Reports: separate Blocked/Blocking plan
+                 actions; no Get Actual Plan because re-executing a blocked query is a foot-gun. -->
+            <ContextMenu x:Key="BlockedProcessContextMenu">
+                <MenuItem Header="Copy Cell" Click="CopyCell_Click">
+                    <MenuItem.Icon><TextBlock Text="&#x1F4CB;"/></MenuItem.Icon>
+                </MenuItem>
+                <MenuItem Header="Copy Row" Click="CopyRow_Click">
+                    <MenuItem.Icon><TextBlock Text="&#x1F4C4;"/></MenuItem.Icon>
+                </MenuItem>
+                <MenuItem Header="Copy All Rows" Click="CopyAllRows_Click">
+                    <MenuItem.Icon><TextBlock Text="&#x1F4D1;"/></MenuItem.Icon>
+                </MenuItem>
+                <Separator/>
+                <MenuItem Header="Export to CSV..." Click="ExportToCsv_Click">
+                    <MenuItem.Icon><TextBlock Text="&#x1F4CA;"/></MenuItem.Icon>
+                </MenuItem>
+                <Separator/>
+                <MenuItem Header="View Blocked Plan" Click="ViewBlockedSidePlan_Click">
+                    <MenuItem.Icon><TextBlock Text="&#x1F50D;"/></MenuItem.Icon>
+                </MenuItem>
+                <MenuItem Header="View Blocking Plan" Click="ViewBlockingSidePlan_Click">
+                    <MenuItem.Icon><TextBlock Text="&#x1F50D;"/></MenuItem.Icon>
+                </MenuItem>
+            </ContextMenu>
+
             <Style x:Key="GridRowStyle" TargetType="DataGridRow">
                 <Setter Property="ContextMenu" Value="{StaticResource DataGridContextMenu}"/>
             </Style>
 
             <!-- Row style for blocking grid - highlight long-duration blocks -->
-            <Style x:Key="BlockingRowStyle" TargetType="DataGridRow" BasedOn="{StaticResource GridRowStyle}">
+            <Style x:Key="BlockingRowStyle" TargetType="DataGridRow">
+                <Setter Property="ContextMenu" Value="{StaticResource BlockedProcessContextMenu}"/>
                 <Style.Triggers>
                     <DataTrigger Binding="{Binding IsLongBlock}" Value="True">
                         <Setter Property="Background" Value="#33FF6B6B"/>
diff --git a/Lite/Controls/ServerTab.xaml.cs b/Lite/Controls/ServerTab.xaml.cs
index b15e362b..e08ac219 100644
--- a/Lite/Controls/ServerTab.xaml.cs
+++ b/Lite/Controls/ServerTab.xaml.cs
@@ -4861,6 +4861,104 @@ private async void GetActualPlan_Click(object sender, RoutedEventArgs e)
         catch { return null; }
     }
 
+    // ── Blocked Process Report plan lookup ──
+
+    /* SQL Server writes this 42-byte all-zero handle into executionStack frames
+       for dynamic SQL / system contexts where no persistent sql_handle exists.
+       Filter matches sp_HumanEventsBlockViewer's XPath exclusion. */
+    private static readonly string ZeroSqlHandle = "0x" + new string('0', 84);
+
+    private async void ViewBlockedSidePlan_Click(object sender, RoutedEventArgs e)
+        => await ShowBlockedProcessPlanAsync(sender, blockingSide: false);
+
+    private async void ViewBlockingSidePlan_Click(object sender, RoutedEventArgs e)
+        => await ShowBlockedProcessPlanAsync(sender, blockingSide: true);
+
+    private async System.Threading.Tasks.Task ShowBlockedProcessPlanAsync(object sender, bool blockingSide)
+    {
+        if (sender is not MenuItem menuItem) return;
+        var grid = FindParentDataGrid(menuItem);
+        if (grid?.CurrentItem is not BlockedProcessReportRow row) return;
+
+        var sideLabel = blockingSide ? "Blocking" : "Blocked";
+        var spid = blockingSide ? row.BlockingSpid : row.BlockedSpid;
+        var queryText = blockingSide ? row.BlockingSqlText : row.BlockedSqlText;
+        var label = $"Est Plan - {sideLabel} SPID {spid}";
+
+        var frames = ExtractBlockedProcessFrames(row.BlockedProcessReportXml, blockingSide);
+        if (frames.Count == 0)
+        {
+            MessageBox.Show(
+                $"The {sideLabel.ToLowerInvariant()} process report has no resolvable sql_handle. " +
+                "This usually means the query ran as dynamic SQL or a system context — " +
+                "SQL Server records a zero handle in that case and the plan can't be recovered.",
+                "No Plan Available", MessageBoxButton.OK, MessageBoxImage.Information);
+            return;
+        }
+
+        string? planXml = null;
+        try
+        {
+            var connStr = _server.GetConnectionString(_credentialService);
+            foreach (var f in frames)
+            {
+                planXml = await LocalDataService.FetchPlanBySqlHandleAsync(
+                    connStr, row.DatabaseName, f.SqlHandle, f.StmtStart, f.StmtEnd);
+                if (!string.IsNullOrEmpty(planXml)) break;
+            }
+        }
+        catch { }
+
+        if (!string.IsNullOrEmpty(planXml))
+        {
+            OpenPlanTab(planXml, label, queryText);
+            PlanViewerTabItem.IsSelected = true;
+        }
+        else
+        {
+            MessageBox.Show(
+                $"The plan for the {sideLabel.ToLowerInvariant()} query is no longer in the plan cache on {_server.ServerName}. " +
+                "Blocked process reports only give us a sql_handle — if that plan has been evicted, we can't recover it.",
+                "No Plan Available", MessageBoxButton.OK, MessageBoxImage.Information);
+        }
+    }
+
+    private static IReadOnlyList<(string SqlHandle, int StmtStart, int StmtEnd)> ExtractBlockedProcessFrames(
+        string bprXml, bool blockingSide)
+    {
+        var empty = Array.Empty<(string, int, int)>();
+        if (string.IsNullOrWhiteSpace(bprXml)) return empty;
+        try
+        {
+            var doc = System.Xml.Linq.XElement.Parse(bprXml);
+            var processContainer = blockingSide
+                ? doc.Element("blocking-process")
+                : doc.Element("blocked-process");
+            var stack = processContainer?.Element("process")?.Element("executionStack");
+            if (stack == null) return empty;
+
+            var frames = new List<(string, int, int)>();
+            foreach (var frame in stack.Elements("frame"))
+            {
+                var handle = frame.Attribute("sqlhandle")?.Value;
+                if (string.IsNullOrWhiteSpace(handle)) continue;
+                if (string.Equals(handle, ZeroSqlHandle, StringComparison.OrdinalIgnoreCase)) continue;
+
+                int stmtStart = 0;
+                int stmtEnd = -1;
+                int.TryParse(frame.Attribute("stmtstart")?.Value, out stmtStart);
+                if (int.TryParse(frame.Attribute("stmtend")?.Value, out var se)) stmtEnd = se;
+
+                frames.Add((handle!, stmtStart, stmtEnd));
+            }
+            return frames;
+        }
+        catch
+        {
+            return empty;
+        }
+    }
+
     // ── Active Queries Slicer ──
 
     private async System.Threading.Tasks.Task LoadActiveQueriesSlicerAsync()
diff --git a/Lite/Services/LocalDataService.QueryStats.cs b/Lite/Services/LocalDataService.QueryStats.cs
index f2df4f28..59ada107 100644
--- a/Lite/Services/LocalDataService.QueryStats.cs
+++ b/Lite/Services/LocalDataService.QueryStats.cs
@@ -569,6 +569,72 @@ ps.total_elapsed_time DESC
         return result as string;
     }
 
+    /// <summary>
+    /// Fetches a query plan on-demand by sql_handle + statement offsets.
+    /// Used for Blocked Process Reports, where query_hash is not present in the
+    /// XE event payload — only the sql_handle and offsets from executionStack frames.
+    /// </summary>
+    public static async Task<string?> FetchPlanBySqlHandleAsync(
+        string connectionString,
+        string databaseName,
+        string sqlHandleHex,
+        int statementStartOffset,
+        int statementEndOffset)
+    {
+        if (string.IsNullOrWhiteSpace(sqlHandleHex)) return null;
+        var handleBytes = HexStringToBytes(sqlHandleHex);
+        if (handleBytes == null || handleBytes.Length == 0) return null;
+
+        using var connection = new SqlConnection(connectionString);
+        await connection.OpenAsync();
+
+        var quotedDbName = await GetValidatedDatabaseNameAsync(connection, databaseName)
+                           ?? "[master]";
+
+        var query = $@"
+EXECUTE {quotedDbName}.sys.sp_executesql
+    N'
+SELECT TOP (1)
+    query_plan_text = tqp.query_plan
+FROM sys.dm_exec_query_stats AS qs
+OUTER APPLY sys.dm_exec_text_query_plan(qs.plan_handle, qs.statement_start_offset, qs.statement_end_offset) AS tqp
+WHERE qs.sql_handle = @h
+AND   qs.statement_start_offset = @stmt_start
+AND   qs.statement_end_offset = @stmt_end
+AND   tqp.query_plan IS NOT NULL
+ORDER BY
+    qs.last_execution_time DESC
+OPTION(RECOMPILE);',
+    N'@h varbinary(64), @stmt_start int, @stmt_end int',
+    @h, @stmt_start, @stmt_end;";
+
+        using var command = new SqlCommand(query, connection) { CommandTimeout = 30 };
+        command.Parameters.Add(new SqlParameter("@h", SqlDbType.VarBinary, 64) { Value = handleBytes });
+        command.Parameters.Add(new SqlParameter("@stmt_start", SqlDbType.Int) { Value = statementStartOffset });
+        command.Parameters.Add(new SqlParameter("@stmt_end", SqlDbType.Int) { Value = statementEndOffset });
+        var result = await command.ExecuteScalarAsync();
+        return result as string;
+    }
+
+    private static byte[]? HexStringToBytes(string hex)
+    {
+        var start = hex.StartsWith("0x", StringComparison.OrdinalIgnoreCase) ? 2 : 0;
+        var len = hex.Length - start;
+        if (len <= 0 || (len % 2) != 0) return null;
+        var bytes = new byte[len / 2];
+        for (int i = 0; i < bytes.Length; i++)
+        {
+            if (!byte.TryParse(hex.AsSpan(start + i * 2, 2),
+                               System.Globalization.NumberStyles.HexNumber,
+                               System.Globalization.CultureInfo.InvariantCulture,
+                               out bytes[i]))
+            {
+                return null;
+            }
+        }
+        return bytes;
+    }
+
     /// <summary>
     /// Gets top procedures by CPU for a server.
     /// </summary>

From 2958c0c900eed13f51dc579c341c1c50f1089842 Mon Sep 17 00:00:00 2001
From: Erik Darling <2136037+erikdarlingdata@users.noreply.github.com>
Date: Mon, 20 Apr 2026 12:16:31 -0400
Subject: [PATCH 22/49] Pre-filter query snapshot requests into #temp on Azure
 SQL DB (#857) (#869)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Follow-up to #861. The DB_ID() predicate in the WHERE clause wasn't
enough — the OUTER APPLYs to sys.dm_exec_sql_text and
sys.dm_exec_text_query_plan were still being evaluated against
master-scoped rows from sys.dm_exec_requests before the filter was
applied, tripping VIEW SERVER PERFORMANCE STATE errors for DB-scoped
logins (D365FO). A CTE or derived table wouldn't guarantee the
filter order, so materialise the filtered request rows into #req
first and drive the DMFs off that.

Co-authored-by: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
---
 .../RemoteCollectorService.QuerySnapshots.cs  | 121 ++++++++++++++++--
 1 file changed, 113 insertions(+), 8 deletions(-)

diff --git a/Lite/Services/RemoteCollectorService.QuerySnapshots.cs b/Lite/Services/RemoteCollectorService.QuerySnapshots.cs
index 7ab3765d..5148af41 100644
--- a/Lite/Services/RemoteCollectorService.QuerySnapshots.cs
+++ b/Lite/Services/RemoteCollectorService.QuerySnapshots.cs
@@ -21,7 +21,7 @@ namespace PerformanceMonitorLite.Services;
 public partial class RemoteCollectorService
 {
     private const string QuerySnapshotsBase = """
-        
+
 SET TRANSACTION ISOLATION LEVEL READ UNCOMMITTED;
 SET LOCK_TIMEOUT 1000;
 
@@ -81,17 +81,124 @@ WHERE der.session_id <> @@SPID
 AND   der.session_id >= 50
 AND   dest.text IS NOT NULL
 AND   der.database_id <> ISNULL(DB_ID(N'PerformanceMonitor'), 0)
-{2}
 ORDER BY der.cpu_time DESC, der.parallel_worker_count DESC
 OPTION(MAXDOP 1, RECOMPILE);
 """;
     private readonly static CompositeFormat QuerySnapshotsBaseFormat = CompositeFormat.Parse(QuerySnapshotsBase);
 
+    /*
+     * On Azure SQL Database with a contained / DB-scoped login (e.g. D365FO),
+     * the OUTER APPLY to sys.dm_exec_sql_text / sys.dm_exec_text_query_plan
+     * will be evaluated against master-scoped rows from sys.dm_exec_requests
+     * before the WHERE predicate applies, tripping error 300 (VIEW SERVER
+     * PERFORMANCE STATE denied). Materialising the filtered request rows
+     * into a #temp table first guarantees the DMFs only see handles from
+     * the current database. See #857.
+     */
+    private const string QuerySnapshotsAzureBase = """
+
+SET TRANSACTION ISOLATION LEVEL READ UNCOMMITTED;
+SET LOCK_TIMEOUT 1000;
+
+IF OBJECT_ID(N'tempdb..#req') IS NOT NULL DROP TABLE #req;
+
+SELECT
+    der.session_id,
+    der.database_id,
+    der.sql_handle,
+    der.plan_handle,
+    der.statement_start_offset,
+    der.statement_end_offset,
+    der.status,
+    der.blocking_session_id,
+    der.wait_type,
+    der.wait_time,
+    der.wait_resource,
+    der.cpu_time,
+    der.total_elapsed_time,
+    der.reads,
+    der.writes,
+    der.logical_reads,
+    der.granted_query_memory,
+    der.transaction_isolation_level,
+    der.dop,
+    der.parallel_worker_count,
+    der.percent_complete
+INTO #req
+FROM sys.dm_exec_requests AS der
+WHERE der.session_id <> @@SPID
+AND   der.session_id >= 50
+AND   der.database_id = DB_ID()
+AND   der.database_id <> ISNULL(DB_ID(N'PerformanceMonitor'), 0);
+
+SELECT /* PerformanceMonitorLite */
+    der.session_id,
+    database_name = d.name,
+    elapsed_time_formatted =
+        CASE
+            WHEN der.total_elapsed_time < 0
+            THEN '00 00:00:00.000'
+            ELSE RIGHT(REPLICATE('0', 2) + CONVERT(varchar(10), der.total_elapsed_time / 86400000), 2) +
+                 ' ' + RIGHT(CONVERT(varchar(30), DATEADD(second, der.total_elapsed_time / 1000, 0), 120), 9) +
+                 '.' + RIGHT('000' + CONVERT(varchar(3), der.total_elapsed_time % 1000), 3)
+        END,
+    query_text = SUBSTRING(dest.text, (der.statement_start_offset / 2) + 1,
+        ((CASE der.statement_end_offset WHEN -1 THEN DATALENGTH(dest.text)
+          ELSE der.statement_end_offset END - der.statement_start_offset) / 2) + 1),
+    query_plan = TRY_CAST(deqp.query_plan AS nvarchar(max)),
+    {0}
+    der.status,
+    der.blocking_session_id,
+    der.wait_type,
+    wait_time_ms = CONVERT(bigint, der.wait_time),
+    der.wait_resource,
+    cpu_time_ms = CONVERT(bigint, der.cpu_time),
+    total_elapsed_time_ms = CONVERT(bigint, der.total_elapsed_time),
+    der.reads,
+    der.writes,
+    der.logical_reads,
+    granted_query_memory_gb = CONVERT(decimal(38, 2), (der.granted_query_memory / 128. / 1024.)),
+    transaction_isolation_level =
+        CASE der.transaction_isolation_level
+            WHEN 0 THEN 'Unspecified'
+            WHEN 1 THEN 'Read Uncommitted'
+            WHEN 2 THEN 'Read Committed'
+            WHEN 3 THEN 'Repeatable Read'
+            WHEN 4 THEN 'Serializable'
+            WHEN 5 THEN 'Snapshot'
+            ELSE '???'
+        END,
+    der.dop,
+    der.parallel_worker_count,
+    des.login_name,
+    des.host_name,
+    des.program_name,
+    des.open_transaction_count,
+    der.percent_complete
+FROM #req AS der
+JOIN sys.dm_exec_sessions AS des
+    ON des.session_id = der.session_id
+OUTER APPLY sys.dm_exec_sql_text(COALESCE(der.sql_handle, der.plan_handle)) AS dest
+OUTER APPLY sys.dm_exec_text_query_plan(der.plan_handle, der.statement_start_offset, der.statement_end_offset) AS deqp
+LEFT JOIN sys.databases AS d
+  ON d.database_id = der.database_id
+{1}
+WHERE dest.text IS NOT NULL
+ORDER BY der.cpu_time DESC, der.parallel_worker_count DESC
+OPTION(MAXDOP 1, RECOMPILE);
+
+DROP TABLE #req;
+""";
+    private readonly static CompositeFormat QuerySnapshotsAzureBaseFormat = CompositeFormat.Parse(QuerySnapshotsAzureBase);
+
     /// <summary>
     /// Builds the query snapshots SQL with or without live query plan support.
     /// Used by both the collector and the live snapshot button.
-    /// On Azure SQL Database the result set is scoped to the current database only,
-    /// because logins without access to master can't resolve cross-database requests (see #857).
+    /// On Azure SQL Database the request rows are first materialised into a
+    /// #temp table scoped to the current database, so the downstream OUTER APPLYs
+    /// to sys.dm_exec_sql_text / sys.dm_exec_text_query_plan only ever see
+    /// current-DB handles — avoiding the VIEW SERVER PERFORMANCE STATE error
+    /// that D365FO-style DB-scoped logins hit (see #857).
     /// </summary>
     internal static string BuildQuerySnapshotsQuery(bool supportsLiveQueryPlan, bool isAzureSqlDatabase)
     {
@@ -101,10 +208,8 @@ internal static string BuildQuerySnapshotsQuery(bool supportsLiveQueryPlan, bool
         var liveQueryPlanApply = supportsLiveQueryPlan
             ? "OUTER APPLY sys.dm_exec_query_statistics_xml(der.session_id) AS deqs"
             : "";
-        var azureScopePredicate = isAzureSqlDatabase
-            ? "AND   der.database_id = DB_ID()"
-            : "";
-        return string.Format(null, QuerySnapshotsBaseFormat, liveQueryPlanColumn, liveQueryPlanApply, azureScopePredicate);
+        var template = isAzureSqlDatabase ? QuerySnapshotsAzureBaseFormat : QuerySnapshotsBaseFormat;
+        return string.Format(null, template, liveQueryPlanColumn, liveQueryPlanApply);
     }
 
     /// <summary>

From 4cebae2094f28970a82b68086fdab89a120a43ff Mon Sep 17 00:00:00 2001
From: Erik Darling <2136037+erikdarlingdata@users.noreply.github.com>
Date: Mon, 20 Apr 2026 12:26:59 -0400
Subject: [PATCH 23/49] Stop retrying collectors after non-transient permission
 denial (#857) (#870)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

The collector loop already classifies SQL errors 229 / 297 / 300 as
PERMISSIONS status and excludes them from the failure rate, but it
keeps re-running the collector every interval and logging an
identical denial each time. For DB-scoped logins on Azure SQL DB
(e.g. D365FO) this churns the collection log and gives no new
information — the permission won't change mid-session.

Flag the collector on first denial and short-circuit RunCollectorAsync
so we don't make the round-trip or the log entry. Flag is in-memory
per (server, collector) — cleared on app restart so newly granted
permissions are picked up on the next launch.

Co-authored-by: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
---
 Lite/Services/RemoteCollectorService.cs | 36 ++++++++++++++++++++++++-
 1 file changed, 35 insertions(+), 1 deletion(-)

diff --git a/Lite/Services/RemoteCollectorService.cs b/Lite/Services/RemoteCollectorService.cs
index 541c4e53..fdecb7d8 100644
--- a/Lite/Services/RemoteCollectorService.cs
+++ b/Lite/Services/RemoteCollectorService.cs
@@ -39,6 +39,15 @@ public class CollectorHealthEntry
     public int ConsecutiveErrors { get; set; }
     public int TotalErrors { get; set; }
     public int TotalSuccesses { get; set; }
+
+    /*
+     * Set when a collector hits a non-transient permission error
+     * (SQL errors 229 / 297 / 300). The scheduler skips the collector
+     * for the rest of the app session so we don't churn the log with
+     * identical denials every interval. Cleared on app restart — if
+     * permissions get granted later, the next launch retries once.
+     */
+    public bool IsPermissionRestricted { get; set; }
 }
 
 /// <summary>
@@ -225,9 +234,12 @@ private void RecordCollectorResult(int serverId, string collectorName, string st
             {
                 /* Permission errors are not transient — don't count as failures
                    (which would show FAILING) but don't count as success either.
-                   Record the error message so the user can see what's wrong. */
+                   Record the error message so the user can see what's wrong,
+                   and flag the collector so the scheduler stops retrying for
+                   the rest of the app session. */
                 entry.LastErrorTime = DateTime.UtcNow;
                 entry.LastErrorMessage = errorMessage;
+                entry.IsPermissionRestricted = true;
             }
             else
             {
@@ -239,6 +251,19 @@ Record the error message so the user can see what's wrong. */
         }
     }
 
+    /// <summary>
+    /// Returns true if a collector has hit a permission denial this session
+    /// and should be skipped without re-running. See <see cref="CollectorHealthEntry.IsPermissionRestricted"/>.
+    /// </summary>
+    private bool IsCollectorPermissionRestricted(int serverId, string collectorName)
+    {
+        lock (_healthLock)
+        {
+            return _collectorHealth.TryGetValue((serverId, collectorName), out var entry)
+                && entry.IsPermissionRestricted;
+        }
+    }
+
     /// <summary>
     /// Runs all due collectors for all enabled servers.
     /// </summary>
@@ -380,6 +405,15 @@ public async Task RunCollectorAsync(ServerConnection server, string collectorNam
                 return;
             }
 
+            // Skip collectors that have already hit a non-transient permission denial
+            // this session. Flag is in-memory — next app start retries once (see #857).
+            if (IsCollectorPermissionRestricted(GetServerId(server), collectorName))
+            {
+                _logger?.LogDebug("Skipping collector '{Collector}' for server '{Server}' - permission denied this session",
+                    collectorName, server.DisplayName);
+                return;
+            }
+
             _logger?.LogDebug("Running collector '{Collector}' for server '{Server}'",
                 collectorName, server.DisplayName);
 

From 3327c9127953b72cf605a6b1435fb14ff61af090 Mon Sep 17 00:00:00 2001
From: Erik Darling <2136037+erikdarlingdata@users.noreply.github.com>
Date: Tue, 21 Apr 2026 11:18:53 -0400
Subject: [PATCH 24/49] Skip live query plans on Azure SQL DB (#857) (#871)

sys.dm_exec_query_statistics_xml requires VIEW SERVER PERFORMANCE
STATE on Azure SQL Database regardless of scope, so DB-scoped logins
(e.g. D365FO) still hit error 300 even after the #temp pre-filter
landed in #869. The OUTER APPLY evaluates the DMF for every session
in #req and fails on the permission check before returning rows.

Force supportsLiveQueryPlan=false for SqlEngineEdition=5 in both the
collector and the Live Snapshot button paths. Boxed SQL Server and
Azure MI (edition 8) still get live plans as before.

Co-authored-by: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
---
 Lite/Controls/ServerTab.xaml.cs                     |  4 +++-
 .../RemoteCollectorService.QuerySnapshots.cs        | 13 ++++++++++---
 2 files changed, 13 insertions(+), 4 deletions(-)

diff --git a/Lite/Controls/ServerTab.xaml.cs b/Lite/Controls/ServerTab.xaml.cs
index e08ac219..1d7ab416 100644
--- a/Lite/Controls/ServerTab.xaml.cs
+++ b/Lite/Controls/ServerTab.xaml.cs
@@ -5365,7 +5365,9 @@ private async void LiveSnapshot_Click(object sender, RoutedEventArgs e)
                 ConnectTimeout = 15
             };
 
-            var query = RemoteCollectorService.BuildQuerySnapshotsQuery(supportsLiveQueryPlan: true, isAzureSqlDatabase: _isAzureSqlDatabase);
+            // Live query plans require VIEW SERVER PERFORMANCE STATE on Azure SQL DB,
+            // which DB-scoped logins don't have — skip them there. See #857.
+            var query = RemoteCollectorService.BuildQuerySnapshotsQuery(supportsLiveQueryPlan: !_isAzureSqlDatabase, isAzureSqlDatabase: _isAzureSqlDatabase);
 
             await using var connection = new SqlConnection(builder.ConnectionString);
             await connection.OpenAsync();
diff --git a/Lite/Services/RemoteCollectorService.QuerySnapshots.cs b/Lite/Services/RemoteCollectorService.QuerySnapshots.cs
index 5148af41..c18523c0 100644
--- a/Lite/Services/RemoteCollectorService.QuerySnapshots.cs
+++ b/Lite/Services/RemoteCollectorService.QuerySnapshots.cs
@@ -217,11 +217,18 @@ internal static string BuildQuerySnapshotsQuery(bool supportsLiveQueryPlan, bool
     /// </summary>
     private async Task<int> CollectQuerySnapshotsAsync(ServerConnection server, CancellationToken cancellationToken)
     {
-        // dm_exec_query_statistics_xml requires SQL Server 2016 SP1+ (version 13)
+        /*
+         * sys.dm_exec_query_statistics_xml requires SQL Server 2016 SP1+ (version 13)
+         * on boxed, and VIEW SERVER PERFORMANCE STATE on Azure SQL Database regardless
+         * of tier. DB-scoped logins (e.g. D365FO) don't have the server-level grant
+         * and the DMF raises error 300 even when only called for current-DB sessions,
+         * so we disable live query plans on Azure SQL DB entirely. See #857.
+         */
         var serverStatus = _serverManager.GetConnectionStatus(server.Id);
-        var supportsLiveQueryPlan = serverStatus.SqlMajorVersion >= 13 || serverStatus.SqlMajorVersion == 0
-            || serverStatus.SqlEngineEdition == 5 || serverStatus.SqlEngineEdition == 8;
         var isAzureSqlDatabase = serverStatus.SqlEngineEdition == 5;
+        var supportsLiveQueryPlan = !isAzureSqlDatabase
+            && (serverStatus.SqlMajorVersion >= 13 || serverStatus.SqlMajorVersion == 0
+                || serverStatus.SqlEngineEdition == 8);
 
         var query = BuildQuerySnapshotsQuery(supportsLiveQueryPlan, isAzureSqlDatabase);
 

From 2c1ccbed60fe1fb5cbff62be2d5cf5b7084f9e7b Mon Sep 17 00:00:00 2001
From: Erik Darling <2136037+erikdarlingdata@users.noreply.github.com>
Date: Tue, 21 Apr 2026 12:48:19 -0400
Subject: [PATCH 25/49] Fix FinOps recommendation severity sort order (#872)

Sort recommendations by severity rank (High=1, Medium=2, Low=3)
instead of alphabetically. Adds SeveritySort property to
RecommendationRow and uses it as SortMemberPath for the Severity
column. Display strings are unchanged.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
---
 Lite/Controls/FinOpsTab.xaml             | 2 +-
 Lite/Services/LocalDataService.FinOps.cs | 9 ++++++++-
 2 files changed, 9 insertions(+), 2 deletions(-)

diff --git a/Lite/Controls/FinOpsTab.xaml b/Lite/Controls/FinOpsTab.xaml
index ae2fc7e3..c841008a 100644
--- a/Lite/Controls/FinOpsTab.xaml
+++ b/Lite/Controls/FinOpsTab.xaml
@@ -82,7 +82,7 @@
                           AlternatingRowBackground="{DynamicResource DataGridAlternatingRowBrush}">
                     <DataGrid.Columns>
                         <DataGridTextColumn Header="Category" Binding="{Binding Category}" MinWidth="120" Width="Auto"/>
-                        <DataGridTextColumn Header="Severity" Binding="{Binding Severity}" MinWidth="80" Width="Auto">
+                        <DataGridTextColumn Header="Severity" Binding="{Binding Severity}" MinWidth="80" Width="Auto" SortMemberPath="SeveritySort">
                             <DataGridTextColumn.ElementStyle>
                                 <Style TargetType="TextBlock">
                                     <Style.Triggers>
diff --git a/Lite/Services/LocalDataService.FinOps.cs b/Lite/Services/LocalDataService.FinOps.cs
index 163cdf86..916ecac9 100644
--- a/Lite/Services/LocalDataService.FinOps.cs
+++ b/Lite/Services/LocalDataService.FinOps.cs
@@ -2176,7 +2176,7 @@ FROM cpu_utilization_stats
             AppLogger.Error("FinOps", $"Recommendation check failed (Reserved capacity): {ex.Message}");
         }
 
-        return recommendations;
+        return recommendations.OrderBy(r => r.SeveritySort).ToList();
     }
 
     private static string FormatDuration(long seconds)
@@ -2578,6 +2578,13 @@ public class RecommendationRow
     public string Detail { get; set; } = "";
     public decimal? EstMonthlySavings { get; set; }
     public string EstMonthlySavingsDisplay => EstMonthlySavings.HasValue ? $"${EstMonthlySavings.Value:N0}" : "";
+    public int SeveritySort => Severity switch
+    {
+        "High" => 1,
+        "Medium" => 2,
+        "Low" => 3,
+        _ => 4
+    };
 }
 
 /// <summary>

From eb5d326f8494f261184ef731c3038bfd7dea8189 Mon Sep 17 00:00:00 2001
From: Erik Darling <2136037+erikdarlingdata@users.noreply.github.com>
Date: Tue, 21 Apr 2026 13:33:35 -0400
Subject: [PATCH 26/49] Fix FinOps severity sort order in Dashboard (#872)

Severity column was sorting alphabetically (High, Low, Medium) instead
of by severity ranking. Added SeveritySort computed property on
FinOpsRecommendation, ordered results by it, and wired the DataGrid
column's SortMemberPath so click-sort matches the default order.

Mirrors the Lite fix in PR #874.
---
 Dashboard/Controls/FinOpsContent.xaml        |  2 +-
 Dashboard/Services/DatabaseService.FinOps.cs | 10 +++++++++-
 2 files changed, 10 insertions(+), 2 deletions(-)

diff --git a/Dashboard/Controls/FinOpsContent.xaml b/Dashboard/Controls/FinOpsContent.xaml
index e635803b..43573d47 100644
--- a/Dashboard/Controls/FinOpsContent.xaml
+++ b/Dashboard/Controls/FinOpsContent.xaml
@@ -90,7 +90,7 @@
                                 </StackPanel>
                             </DataGridTextColumn.Header>
                         </DataGridTextColumn>
-                        <DataGridTextColumn Binding="{Binding Severity}" MinWidth="80" Width="Auto">
+                        <DataGridTextColumn Binding="{Binding Severity}" SortMemberPath="SeveritySort" MinWidth="80" Width="Auto">
                             <DataGridTextColumn.Header>
                                 <StackPanel Orientation="Horizontal">
                                     <Button Style="{DynamicResource ColumnFilterButtonStyle}" Tag="Severity" Click="FinOpsFilter_Click" Margin="0,0,4,0"/>
diff --git a/Dashboard/Services/DatabaseService.FinOps.cs b/Dashboard/Services/DatabaseService.FinOps.cs
index f593d22e..0f2816eb 100644
--- a/Dashboard/Services/DatabaseService.FinOps.cs
+++ b/Dashboard/Services/DatabaseService.FinOps.cs
@@ -2470,7 +2470,7 @@ HAVING COUNT(*) >= 24
                 Logger.Error($"[{ServerLabel}] Recommendation check failed (Reserved capacity): {ex.Message}", ex);
             }
 
-            return recommendations;
+            return recommendations.OrderBy(r => r.SeveritySort).ToList();
         }
 
         private static string FormatDuration(long seconds)
@@ -2873,6 +2873,14 @@ public class FinOpsRecommendation
         public string Detail { get; set; } = "";
         public decimal? EstMonthlySavings { get; set; }
         public string EstMonthlySavingsDisplay => EstMonthlySavings.HasValue ? $"${EstMonthlySavings.Value:N0}" : "";
+
+        public int SeveritySort => Severity switch
+        {
+            "High" => 1,
+            "Medium" => 2,
+            "Low" => 3,
+            _ => 4
+        };
     }
 
     public class FinOpsHighImpactQuery

From 95bca559fe40aa5a568f330a2546f9f497800ec9 Mon Sep 17 00:00:00 2001
From: Erik Darling <2136037+erikdarlingdata@users.noreply.github.com>
Date: Tue, 21 Apr 2026 19:43:52 -0400
Subject: [PATCH 27/49] Drop sys.dm_os_schedulers from memory_stats on Azure
 SQL DB (#857) (#876)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Azure SQL Database DBs hosted in an elastic pool (notably D365FO
customer tenants) enforce VIEW SERVER PERFORMANCE STATE on
sys.dm_os_schedulers regardless of the login's DB-scoped grants —
VIEW DATABASE STATE + VIEW DATABASE PERFORMANCE STATE on the user DB
are not sufficient. Verified by reproducing the failure in a
standard Azure SQL DB elastic pool with a contained DB user; bare
sys.dm_exec_requests/sys.dm_os_sys_info/sys.dm_os_performance_counters
succeed but sys.dm_os_memory_clerks / sys.dm_os_schedulers /
sys.dm_os_waiting_tasks fail with error 300.

The other failing collectors (memory_clerks, waiting_tasks,
tempdb_stats) have no DB-scoped alternative and will stay skip-gated
via #870 for these users.

Co-authored-by: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
---
 Lite/Services/RemoteCollectorService.Memory.cs | 16 +++++++++-------
 1 file changed, 9 insertions(+), 7 deletions(-)

diff --git a/Lite/Services/RemoteCollectorService.Memory.cs b/Lite/Services/RemoteCollectorService.Memory.cs
index e90339e7..2dc6bfcb 100644
--- a/Lite/Services/RemoteCollectorService.Memory.cs
+++ b/Lite/Services/RemoteCollectorService.Memory.cs
@@ -30,6 +30,14 @@ Use sys.dm_os_sys_info committed_target_kb/committed_kb as approximations.
            Azure MI (edition 8) HAS dm_os_sys_memory, sql_memory_model_desc, and behaves like on-prem. */
         bool isAzureSqlDb = serverStatus.SqlEngineEdition == 5;
 
+        /*
+         * Azure SQL Database in an elastic pool (e.g. D365FO tenants) enforces
+         * VIEW SERVER PERFORMANCE STATE on sys.dm_os_schedulers regardless of
+         * the login's DB-scoped grants, so we skip the schedulers subquery on
+         * Azure SQL DB and report current_workers_count as NULL. The rest of
+         * the row — memory sizes from sys.dm_os_sys_info and the perf counters
+         * — succeeds for contained DB users. See #857.
+         */
         string query = isAzureSqlDb
             ? @"
 SET TRANSACTION ISOLATION LEVEL READ UNCOMMITTED;
@@ -46,7 +54,7 @@ Azure MI (edition 8) HAS dm_os_sys_memory, sql_memory_model_desc, and behaves li
     buffer_pool_mb = CONVERT(decimal(18,2), pc_buffer.cntr_value / 1024.0),
     plan_cache_mb = CONVERT(decimal(18,2), pc_plan.cntr_value * 8.0 / 1024.0),
     max_workers_count = osi.max_workers_count,
-    current_workers_count = w.current_workers
+    current_workers_count = CONVERT(int, NULL)
 FROM sys.dm_os_sys_info AS osi
 CROSS JOIN
 (
@@ -73,12 +81,6 @@ FROM sys.dm_os_performance_counters
     WHERE counter_name = N'Cache Pages'
       AND object_name LIKE N'%:Plan Cache%'
 ) AS pc_plan
-CROSS JOIN
-(
-    SELECT current_workers = SUM(active_workers_count)
-    FROM sys.dm_os_schedulers
-    WHERE status = N'VISIBLE ONLINE'
-) AS w
 OPTION(RECOMPILE);"
             : @"
 SET TRANSACTION ISOLATION LEVEL READ UNCOMMITTED;

From 791f107f68ac2c5e484d89edb38d77438ef7ba7f Mon Sep 17 00:00:00 2001
From: Erik Darling <2136037+erikdarlingdata@users.noreply.github.com>
Date: Tue, 21 Apr 2026 22:40:12 -0400
Subject: [PATCH 28/49] Release v2.8.0: version bumps and changelog (#877)

Adds nonclustered indexes to collect.query_stats, procedure_stats, and
query_store_data for Dashboard grid lookups (#835). Ports Memory Pressure
Events to Lite (#865). Multiple Azure SQL DB collector fixes (#857).
FinOps severity sort order fix (#872). Grid auto-scrolling (#843).

Co-authored-by: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
---
 CHANGELOG.md                                 | 43 ++++++++++++++++++++
 Dashboard/Dashboard.csproj                   |  8 ++--
 Installer.Core/Installer.Core.csproj         |  8 ++--
 Installer/PerformanceMonitorInstaller.csproj |  8 ++--
 Lite/PerformanceMonitorLite.csproj           |  8 ++--
 README.md                                    | 13 +++---
 6 files changed, 66 insertions(+), 22 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index eee63d09..0fef0aff 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -5,6 +5,49 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [2.8.0] - TBD
+
+### Important
+
+- **New nonclustered indexes** on `collect.query_stats`, `collect.procedure_stats`, and `collect.query_store_data` to eliminate Eager Index Spools in Dashboard grid queries. On large installations these indexes may take several minutes to build; the upgrade script uses `ONLINE = ON` on Enterprise/Developer/Azure editions and falls back to offline on Standard/Web ([#835])
+
+### Added
+
+- **Memory Pressure Events in Lite** — the collector, chart, and `get_memory_pressure_events` MCP tool previously only in the Full Edition are now available in Lite ([#865])
+- **Grid auto-scrolling** in Lite and Dashboard ([#843]) — thanks [@ClaudioESSilva](https://github.com/ClaudioESSilva)
+
+### Changed
+
+- **PlanAnalyzer and BenefitScorer** synced with PerformanceStudio's Apr 9–16 improvements
+- **Query/Procedure/Query Store stats** refactored to a phased DECOMPRESS approach; removed unhelpful `WAITFOR DECOMPRESS` filters
+- **Query/Procedure/Query Store grids** capped to TOP 500 to prevent UI freezes on large datasets
+- **Server tabs lazy-load** — only the visible server tab loads on startup; remaining tabs load on first visit
+- **Webhook URLs** encrypted with DPAPI via Windows Credential Manager
+- **DuckDB queries hardened** — parameterized values, escaped paths, fixed `IsArchiving` race
+- **Lite chart axes and sub-tab styling** polished, then ported to Dashboard
+
+### Fixed
+
+- **Memory Pressure Events chart filter** was dropping valid rows; added MCP interpretation guidance ([#865])
+- **FinOps recommendation severity sort order** in Lite and Dashboard ([#872])
+- **Overview crosshair** disappearing after tab switches or layout passes
+- **Blocked process report plan lookup** returning the wrong plan ([#867])
+- **FinOps TDE recommendation** flagging Standard edition on SQL Server 2019+ where TDE is free ([#854])
+- **Azure SQL DB collector** falls back to single-database mode when `master` is inaccessible ([#857])
+- **Azure SQL DB query snapshots** scoped to the current database ([#857])
+- **Azure SQL DB query snapshot prefilter** — request set is narrowed into `#temp` before joining DMVs to avoid Azure-specific execution plan issues ([#857])
+- **Azure SQL DB live query plans** — now skipped gracefully instead of erroring ([#857])
+- **Azure SQL DB memory_stats collector** — dropped `sys.dm_os_schedulers` which is blocked on elastic-pool contained users regardless of DB-scoped grants ([#857])
+- **Non-transient permission denials** now stop collector retries instead of looping forever ([#857])
+
+[#835]: https://github.com/erikdarlingdata/PerformanceMonitor/issues/835
+[#843]: https://github.com/erikdarlingdata/PerformanceMonitor/issues/843
+[#854]: https://github.com/erikdarlingdata/PerformanceMonitor/issues/854
+[#857]: https://github.com/erikdarlingdata/PerformanceMonitor/issues/857
+[#865]: https://github.com/erikdarlingdata/PerformanceMonitor/issues/865
+[#867]: https://github.com/erikdarlingdata/PerformanceMonitor/issues/867
+[#872]: https://github.com/erikdarlingdata/PerformanceMonitor/issues/872
+
 ## [2.7.0] - 2026-04-13
 
 ### Added
diff --git a/Dashboard/Dashboard.csproj b/Dashboard/Dashboard.csproj
index b7a0103f..aff84b73 100644
--- a/Dashboard/Dashboard.csproj
+++ b/Dashboard/Dashboard.csproj
@@ -7,10 +7,10 @@
     <StartupObject>PerformanceMonitorDashboard.Program</StartupObject>
     <AssemblyName>PerformanceMonitorDashboard</AssemblyName>
     <Product>SQL Server Performance Monitor Dashboard</Product>
-    <Version>2.7.0</Version>
-    <AssemblyVersion>2.7.0.0</AssemblyVersion>
-    <FileVersion>2.7.0.0</FileVersion>
-    <InformationalVersion>2.7.0</InformationalVersion>
+    <Version>2.8.0</Version>
+    <AssemblyVersion>2.8.0.0</AssemblyVersion>
+    <FileVersion>2.8.0.0</FileVersion>
+    <InformationalVersion>2.8.0</InformationalVersion>
     <Company>Darling Data, LLC</Company>
     <Copyright>Copyright © 2026 Darling Data, LLC</Copyright>
     <ApplicationIcon>EDD.ico</ApplicationIcon>
diff --git a/Installer.Core/Installer.Core.csproj b/Installer.Core/Installer.Core.csproj
index bb5f1f32..c5d9b0c0 100644
--- a/Installer.Core/Installer.Core.csproj
+++ b/Installer.Core/Installer.Core.csproj
@@ -7,10 +7,10 @@
     <RootNamespace>Installer.Core</RootNamespace>
     <AssemblyName>Installer.Core</AssemblyName>
     <Product>SQL Server Performance Monitor Installer Core</Product>
-    <Version>2.7.0</Version>
-    <AssemblyVersion>2.7.0.0</AssemblyVersion>
-    <FileVersion>2.7.0.0</FileVersion>
-    <InformationalVersion>2.7.0</InformationalVersion>
+    <Version>2.8.0</Version>
+    <AssemblyVersion>2.8.0.0</AssemblyVersion>
+    <FileVersion>2.8.0.0</FileVersion>
+    <InformationalVersion>2.8.0</InformationalVersion>
     <Company>Darling Data, LLC</Company>
     <Copyright>Copyright (c) 2026 Darling Data, LLC</Copyright>
     <EnableNETAnalyzers>true</EnableNETAnalyzers>
diff --git a/Installer/PerformanceMonitorInstaller.csproj b/Installer/PerformanceMonitorInstaller.csproj
index a8293d15..83b6b38e 100644
--- a/Installer/PerformanceMonitorInstaller.csproj
+++ b/Installer/PerformanceMonitorInstaller.csproj
@@ -20,10 +20,10 @@
     <!-- Application metadata -->
     <AssemblyName>PerformanceMonitorInstaller</AssemblyName>
     <Product>SQL Server Performance Monitor Installer</Product>
-    <Version>2.7.0</Version>
-    <AssemblyVersion>2.7.0.0</AssemblyVersion>
-    <FileVersion>2.7.0.0</FileVersion>
-    <InformationalVersion>2.7.0</InformationalVersion>
+    <Version>2.8.0</Version>
+    <AssemblyVersion>2.8.0.0</AssemblyVersion>
+    <FileVersion>2.8.0.0</FileVersion>
+    <InformationalVersion>2.8.0</InformationalVersion>
     <Company>Darling Data, LLC</Company>
     <Copyright>Copyright © 2026 Darling Data, LLC</Copyright>
     <Description>Installation utility for SQL Server Performance Monitor - Supports SQL Server 2016-2025</Description>
diff --git a/Lite/PerformanceMonitorLite.csproj b/Lite/PerformanceMonitorLite.csproj
index 784cd81b..a443fdee 100644
--- a/Lite/PerformanceMonitorLite.csproj
+++ b/Lite/PerformanceMonitorLite.csproj
@@ -8,10 +8,10 @@
     <AssemblyName>PerformanceMonitorLite</AssemblyName>
     <RootNamespace>PerformanceMonitorLite</RootNamespace>
     <Product>SQL Server Performance Monitor Lite</Product>
-    <Version>2.7.0</Version>
-    <AssemblyVersion>2.7.0.0</AssemblyVersion>
-    <FileVersion>2.7.0.0</FileVersion>
-    <InformationalVersion>2.7.0</InformationalVersion>
+    <Version>2.8.0</Version>
+    <AssemblyVersion>2.8.0.0</AssemblyVersion>
+    <FileVersion>2.8.0.0</FileVersion>
+    <InformationalVersion>2.8.0</InformationalVersion>
     <Company>Darling Data, LLC</Company>
     <Copyright>Copyright © 2026 Darling Data, LLC</Copyright>
     <Description>Lightweight SQL Server performance monitoring - no installation required on target servers</Description>
diff --git a/README.md b/README.md
index 19402312..a47b61a1 100644
--- a/README.md
+++ b/README.md
@@ -103,7 +103,7 @@ Data starts flowing within 1–5 minutes. That's it. No installation on your ser
 
 ### Lite Collectors
 
-23 collectors run on independent, configurable schedules:
+24 collectors run on independent, configurable schedules:
 
 | Collector | Default | Source |
 |---|---|---|
@@ -122,6 +122,7 @@ Data starts flowing within 1–5 minutes. That's it. No installation on your ser
 | deadlocks | 1 min | `system_health` Extended Events session |
 | session_stats | 1 min | `sys.dm_exec_sessions` active session tracking |
 | memory_clerks | 5 min | `sys.dm_os_memory_clerks` |
+| memory_pressure_events | 5 min | `sys.dm_os_ring_buffers` RING_BUFFER_RESOURCE_MONITOR |
 | query_store | 5 min | Query Store DMVs (per database) |
 | running_jobs | 5 min | `msdb` job history with duration vs avg/p95 |
 | database_size_stats | 15 min | `sys.master_files` + `FILEPROPERTY` + `dm_os_volume_stats` |
@@ -312,7 +313,7 @@ The Full Edition supports Azure SQL Managed Instance and AWS RDS for SQL Server
 | AWS RDS for SQL Server | Supported | Supported |
 | Azure SQL Database | Not supported | Supported |
 | Multi-server from one seat | Per-server install | Built-in |
-| Collectors | 32 | 23 |
+| Collectors | 32 | 24 |
 | Agent job monitoring | Duration vs historical avg/p95 | Duration vs historical avg/p95 |
 | Data storage | SQL Server (on target) | DuckDB + Parquet (local) |
 | Execution plans | Collected and stored (can be disabled per-collector) | Download on demand |
@@ -323,7 +324,7 @@ The Full Edition supports Azure SQL Managed Instance and AWS RDS for SQL Server
 | Dashboard | Separate app | Built-in |
 | Themes | Dark and light | Dark and light |
 | Portability | Server-bound | Single executable |
-| MCP server (LLM integration) | Built into Dashboard (63 tools) | Built-in (51 tools) |
+| MCP server (LLM integration) | Built into Dashboard (63 tools) | Built-in (52 tools) |
 
 ---
 
@@ -350,7 +351,7 @@ Plus a NOC-style landing page with server health cards (green/yellow/red severit
 | **Active Queries** | Running queries with session details, wait types, blocking, DOP, memory grants |
 | **Wait Stats** | Filterable wait statistics chart with delta calculations |
 | **CPU** | SQL Server CPU vs Other Processes over time |
-| **Memory** | Physical memory overview, SQL Server memory trend, memory clerk breakdown |
+| **Memory** | Physical memory overview, SQL Server memory trend, memory clerk breakdown, memory pressure events |
 | **Queries** | Performance trends, top queries and procedures by duration, Query Store integration, query heatmap |
 | **File I/O** | Read/write I/O trends per database file |
 | **TempDB** | Space usage breakdown and TempDB file I/O |
@@ -453,7 +454,7 @@ claude mcp add --transport http --scope user sql-monitor http://localhost:5151/
 
 ### Available Tools
 
-Full Edition exposes 63 tools, Lite Edition exposes 51. Core tools are shared across both editions.
+Full Edition exposes 63 tools, Lite Edition exposes 52. Core tools are shared across both editions.
 
 | Category | Tools |
 |---|---|
@@ -477,7 +478,7 @@ Full Edition exposes 63 tools, Lite Edition exposes 51. Core tools are shared ac
 | Scheduler | `get_cpu_scheduler_pressure`\*\* |
 | Latch/Spinlock | `get_latch_stats`\*\*, `get_spinlock_stats`\*\* |
 | Diagnostics | `get_plan_cache_bloat`\*\*, `get_critical_issues`\*\* |
-| System Events | `get_default_trace_events`\*\*, `get_trace_analysis`\*\*, `get_memory_pressure_events`\*\* |
+| System Events | `get_default_trace_events`\*\*, `get_trace_analysis`\*\*, `get_memory_pressure_events` |
 | Health Parser | `get_health_parser_system_health`\*\*, `get_health_parser_severe_errors`\*\*, `get_health_parser_io_issues`\*\*, `get_health_parser_scheduler_issues`\*\*, `get_health_parser_memory_conditions`\*\*, `get_health_parser_cpu_tasks`\*\*, `get_health_parser_memory_broker`\*\*, `get_health_parser_memory_node_oom`\*\* |
 | Plan Analysis | `analyze_query_plan`, `analyze_procedure_plan`, `analyze_query_store_plan`, `analyze_plan_xml`, `get_plan_xml` |
 | Diagnostic Analysis | `analyze_server`\*, `get_analysis_facts`\*, `compare_analysis`\*, `audit_config`\*, `get_analysis_findings`\*, `mute_analysis_finding`\* |

From 46a12856388f64ed2f8619f5e532a32d99f8757a Mon Sep 17 00:00:00 2001
From: Erik Darling <2136037+erikdarlingdata@users.noreply.github.com>
Date: Wed, 22 Apr 2026 11:24:07 -0400
Subject: [PATCH 29/49] Scope v2.8.0 webhook DPAPI note to Dashboard (#879)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Lite webhook URLs still read from plaintext settings — avoids implying
the security hardening shipped to both editions.

Co-authored-by: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
---
 CHANGELOG.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 0fef0aff..0dbc6413 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -22,7 +22,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - **Query/Procedure/Query Store stats** refactored to a phased DECOMPRESS approach; removed unhelpful `WAITFOR DECOMPRESS` filters
 - **Query/Procedure/Query Store grids** capped to TOP 500 to prevent UI freezes on large datasets
 - **Server tabs lazy-load** — only the visible server tab loads on startup; remaining tabs load on first visit
-- **Webhook URLs** encrypted with DPAPI via Windows Credential Manager
+- **Webhook URLs (Dashboard)** encrypted with DPAPI via Windows Credential Manager — Lite webhook URLs remain in plaintext settings for now
 - **DuckDB queries hardened** — parameterized values, escaped paths, fixed `IsArchiving` race
 - **Lite chart axes and sub-tab styling** polished, then ported to Dashboard
 

From 41ced86442d0b6cfa79784e5774593363f869263 Mon Sep 17 00:00:00 2001
From: Erik Darling <2136037+erikdarlingdata@users.noreply.github.com>
Date: Wed, 22 Apr 2026 13:13:08 -0400
Subject: [PATCH 30/49] Add Open Log Folder sidebar button in Lite (#873)
 (#881)

Surfaces the log directory with one click so users can grab historical
logs for bug reports. View Log still opens today's file; Open Log Folder
always opens %LocalAppData%\PerformanceMonitorLite\logs\ in Explorer.

Co-authored-by: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
---
 Lite/MainWindow.xaml    |  7 +++++++
 Lite/MainWindow.xaml.cs | 19 +++++++++++++++++++
 2 files changed, 26 insertions(+)

diff --git a/Lite/MainWindow.xaml b/Lite/MainWindow.xaml
index 21fed1fe..d1d79b94 100644
--- a/Lite/MainWindow.xaml
+++ b/Lite/MainWindow.xaml
@@ -191,6 +191,13 @@
                                 <TextBlock Text="View Log" VerticalAlignment="Center"/>
                             </StackPanel>
                         </Button>
+                        <Button Click="OpenLogFolderButton_Click" Margin="0,8,0,0"
+                                ToolTip="Open the log folder in Explorer (for grabbing logs to attach to bug reports)">
+                            <StackPanel Orientation="Horizontal">
+                                <TextBlock Text="&#xE838;" FontFamily="Segoe MDL2 Assets" FontSize="12" VerticalAlignment="Center" Margin="0,0,6,0"/>
+                                <TextBlock Text="Open Log Folder" VerticalAlignment="Center"/>
+                            </StackPanel>
+                        </Button>
                         <Button x:Name="SettingsButton" Click="SettingsButton_Click" Margin="0,8,0,0">
                             <StackPanel Orientation="Horizontal">
                                 <TextBlock Text="&#xE713;" FontFamily="Segoe MDL2 Assets" FontSize="12" VerticalAlignment="Center" Margin="0,0,6,0"/>
diff --git a/Lite/MainWindow.xaml.cs b/Lite/MainWindow.xaml.cs
index 21e15930..59819afd 100644
--- a/Lite/MainWindow.xaml.cs
+++ b/Lite/MainWindow.xaml.cs
@@ -909,6 +909,25 @@ private void ViewLogButton_Click(object sender, RoutedEventArgs e)
         }
     }
 
+    private void OpenLogFolderButton_Click(object sender, RoutedEventArgs e)
+    {
+        var logDir = AppLogger.GetLogDirectory();
+        try
+        {
+            System.IO.Directory.CreateDirectory(logDir);
+            System.Diagnostics.Process.Start(new System.Diagnostics.ProcessStartInfo
+            {
+                FileName = logDir,
+                UseShellExecute = true
+            });
+        }
+        catch (Exception ex)
+        {
+            MessageBox.Show($"Could not open log folder: {ex.Message}", "Error",
+                MessageBoxButton.OK, MessageBoxImage.Error);
+        }
+    }
+
     private void ImportSettingsButton_Click(object sender, RoutedEventArgs e)
     {
         var dialog = new Microsoft.Win32.OpenFolderDialog

From cfd7fab30303b7fe10d0e6f21ac8d44c2229257c Mon Sep 17 00:00:00 2001
From: Erik Darling <2136037+erikdarlingdata@users.noreply.github.com>
Date: Wed, 22 Apr 2026 16:19:26 -0400
Subject: [PATCH 31/49] Add right-click View Plan on Lite Deadlocks grid (#880)
 (#882)

Surfaces the estimated plan for a deadlock participant by looking up
the row's sql_handle + statement offsets (and executionStack frames as
fallback) against sys.dm_exec_query_stats. Tab is labeled "Est Plan -
Victim/Deadlocker SPID N".

Co-authored-by: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
---
 Lite/Controls/ServerTab.xaml    |  31 +++++++++-
 Lite/Controls/ServerTab.xaml.cs | 103 ++++++++++++++++++++++++++++++++
 2 files changed, 133 insertions(+), 1 deletion(-)

diff --git a/Lite/Controls/ServerTab.xaml b/Lite/Controls/ServerTab.xaml
index 6ee7b1cb..26b018c7 100644
--- a/Lite/Controls/ServerTab.xaml
+++ b/Lite/Controls/ServerTab.xaml
@@ -57,6 +57,30 @@
                 </MenuItem>
             </ContextMenu>
 
+            <!-- Context menu for Deadlocks: one row per process, so "View Plan"
+                 resolves to THIS row's process via sql_handle in the graph XML.
+                 No Get Actual Plan — re-running a mid-transaction query that just
+                 deadlocked is a foot-gun. -->
+            <ContextMenu x:Key="DeadlockContextMenu">
+                <MenuItem Header="Copy Cell" Click="CopyCell_Click">
+                    <MenuItem.Icon><TextBlock Text="&#x1F4CB;"/></MenuItem.Icon>
+                </MenuItem>
+                <MenuItem Header="Copy Row" Click="CopyRow_Click">
+                    <MenuItem.Icon><TextBlock Text="&#x1F4C4;"/></MenuItem.Icon>
+                </MenuItem>
+                <MenuItem Header="Copy All Rows" Click="CopyAllRows_Click">
+                    <MenuItem.Icon><TextBlock Text="&#x1F4D1;"/></MenuItem.Icon>
+                </MenuItem>
+                <Separator/>
+                <MenuItem Header="Export to CSV..." Click="ExportToCsv_Click">
+                    <MenuItem.Icon><TextBlock Text="&#x1F4CA;"/></MenuItem.Icon>
+                </MenuItem>
+                <Separator/>
+                <MenuItem Header="View Plan" Click="ViewDeadlockProcessPlan_Click">
+                    <MenuItem.Icon><TextBlock Text="&#x1F50D;"/></MenuItem.Icon>
+                </MenuItem>
+            </ContextMenu>
+
             <Style x:Key="GridRowStyle" TargetType="DataGridRow">
                 <Setter Property="ContextMenu" Value="{StaticResource DataGridContextMenu}"/>
             </Style>
@@ -71,6 +95,11 @@
                 </Style.Triggers>
             </Style>
 
+            <!-- Row style for deadlock grid - View Plan context menu -->
+            <Style x:Key="DeadlockRowStyle" TargetType="DataGridRow">
+                <Setter Property="ContextMenu" Value="{StaticResource DeadlockContextMenu}"/>
+            </Style>
+
             <!-- Row style for wait stats - highlight high-wait types -->
             <Style x:Key="WaitStatsRowStyle" TargetType="DataGridRow" BasedOn="{StaticResource GridRowStyle}">
                 <Style.Triggers>
@@ -1421,7 +1450,7 @@
                                 <controls:TimeRangeSlicerControl x:Name="DeadlockSlicer" Grid.Row="0"/>
                             <DataGrid x:Name="DeadlockGrid" Grid.Row="1"
                                       AutoGenerateColumns="False" IsReadOnly="True"
-                                      RowStyle="{StaticResource GridRowStyle}"
+                                      RowStyle="{StaticResource DeadlockRowStyle}"
                                       HeadersVisibility="Column" GridLinesVisibility="Horizontal"
                                       HorizontalScrollBarVisibility="Auto" VerticalScrollBarVisibility="Auto">
                                 <DataGrid.Columns>
diff --git a/Lite/Controls/ServerTab.xaml.cs b/Lite/Controls/ServerTab.xaml.cs
index 1d7ab416..1cffb93c 100644
--- a/Lite/Controls/ServerTab.xaml.cs
+++ b/Lite/Controls/ServerTab.xaml.cs
@@ -4959,6 +4959,109 @@ private async System.Threading.Tasks.Task ShowBlockedProcessPlanAsync(object sen
         }
     }
 
+    // ── Deadlock process plan lookup ──
+
+    /* Deadlock graph XML puts sqlhandle/stmtstart/stmtend directly on the
+       <process> node, with optional <executionStack><frame sqlhandle=...>
+       children for the call stack. Try process-level first, then walk frames
+       top-down like sp_HumanEventsBlockViewer does for BPRs. */
+    private async void ViewDeadlockProcessPlan_Click(object sender, RoutedEventArgs e)
+    {
+        if (sender is not MenuItem menuItem) return;
+        var grid = FindParentDataGrid(menuItem);
+        if (grid?.CurrentItem is not DeadlockProcessDetail row) return;
+
+        var sideLabel = row.IsVictim ? "Victim" : "Deadlocker";
+        var label = $"Est Plan - {sideLabel} SPID {row.Spid}";
+
+        var frames = ExtractDeadlockProcessFrames(row.DeadlockGraphXml, row.ProcessId);
+        if (frames.Count == 0)
+        {
+            MessageBox.Show(
+                $"The process has no resolvable sql_handle in the deadlock graph. " +
+                "This usually means the query ran as dynamic SQL or a system context — " +
+                "SQL Server records a zero handle in that case and the plan can't be recovered.",
+                "No Plan Available", MessageBoxButton.OK, MessageBoxImage.Information);
+            return;
+        }
+
+        string? planXml = null;
+        try
+        {
+            var connStr = _server.GetConnectionString(_credentialService);
+            foreach (var f in frames)
+            {
+                planXml = await LocalDataService.FetchPlanBySqlHandleAsync(
+                    connStr, row.DatabaseName, f.SqlHandle, f.StmtStart, f.StmtEnd);
+                if (!string.IsNullOrEmpty(planXml)) break;
+            }
+        }
+        catch { }
+
+        if (!string.IsNullOrEmpty(planXml))
+        {
+            OpenPlanTab(planXml, label, row.SqlText);
+            PlanViewerTabItem.IsSelected = true;
+        }
+        else
+        {
+            MessageBox.Show(
+                $"The plan for this {sideLabel.ToLowerInvariant()} process is no longer in the plan cache on {_server.ServerName}. " +
+                "Deadlock graphs only give us a sql_handle — if that plan has been evicted, we can't recover it.",
+                "No Plan Available", MessageBoxButton.OK, MessageBoxImage.Information);
+        }
+    }
+
+    private static IReadOnlyList<(string SqlHandle, int StmtStart, int StmtEnd)> ExtractDeadlockProcessFrames(
+        string graphXml, string processId)
+    {
+        var empty = Array.Empty<(string, int, int)>();
+        if (string.IsNullOrWhiteSpace(graphXml) || string.IsNullOrWhiteSpace(processId)) return empty;
+        try
+        {
+            var doc = System.Xml.Linq.XElement.Parse(graphXml);
+            var process = doc.Descendants("process")
+                .FirstOrDefault(p => string.Equals(p.Attribute("id")?.Value, processId, StringComparison.OrdinalIgnoreCase));
+            if (process == null) return empty;
+
+            var frames = new List<(string, int, int)>();
+
+            /* Try process-level sqlhandle first — deadlock graphs frequently put it on <process>. */
+            var procHandle = process.Attribute("sqlhandle")?.Value;
+            if (!string.IsNullOrWhiteSpace(procHandle) &&
+                !string.Equals(procHandle, ZeroSqlHandle, StringComparison.OrdinalIgnoreCase))
+            {
+                int ps = 0, pe = -1;
+                int.TryParse(process.Attribute("stmtstart")?.Value, out ps);
+                if (int.TryParse(process.Attribute("stmtend")?.Value, out var peParsed)) pe = peParsed;
+                frames.Add((procHandle!, ps, pe));
+            }
+
+            /* Then walk the executionStack frames. */
+            var stack = process.Element("executionStack");
+            if (stack != null)
+            {
+                foreach (var frame in stack.Elements("frame"))
+                {
+                    var handle = frame.Attribute("sqlhandle")?.Value;
+                    if (string.IsNullOrWhiteSpace(handle)) continue;
+                    if (string.Equals(handle, ZeroSqlHandle, StringComparison.OrdinalIgnoreCase)) continue;
+
+                    int fs = 0, fe = -1;
+                    int.TryParse(frame.Attribute("stmtstart")?.Value, out fs);
+                    if (int.TryParse(frame.Attribute("stmtend")?.Value, out var feParsed)) fe = feParsed;
+                    frames.Add((handle!, fs, fe));
+                }
+            }
+
+            return frames;
+        }
+        catch
+        {
+            return empty;
+        }
+    }
+
     // ── Active Queries Slicer ──
 
     private async System.Threading.Tasks.Task LoadActiveQueriesSlicerAsync()

From cd2bc050b0400930ad6a3a1d3a14aead0e95b840 Mon Sep 17 00:00:00 2001
From: Erik Darling <2136037+erikdarlingdata@users.noreply.github.com>
Date: Wed, 22 Apr 2026 18:36:02 -0400
Subject: [PATCH 32/49] Add right-click View Plan on Dashboard Blocked Process
 Reports and Deadlocks grids (#880) (#883)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Mirrors the Lite treatment: pulls sql_handle + statement offsets out of
the BPR or deadlock graph, runs a sys.dm_exec_query_stats /
dm_exec_text_query_plan lookup against the monitored server, and opens
the result in the existing plan viewer tab.

BPR grid gets "View Blocked Plan" + "View Blocking Plan" (the XML has
both processes). Deadlocks grid gets a single "View Plan" and finds the
matching <process> by SPID — Dashboard's row model is one-per-process.

Co-authored-by: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
---
 Dashboard/ServerTab.xaml    |  51 ++++++-
 Dashboard/ServerTab.xaml.cs | 275 ++++++++++++++++++++++++++++++++++++
 2 files changed, 324 insertions(+), 2 deletions(-)

diff --git a/Dashboard/ServerTab.xaml b/Dashboard/ServerTab.xaml
index 5c3f601a..3076cdba 100644
--- a/Dashboard/ServerTab.xaml
+++ b/Dashboard/ServerTab.xaml
@@ -32,6 +32,45 @@
             </MenuItem>
         </ContextMenu>
 
+        <!-- Context Menu for Blocked Process Report rows (copy/export + View Plan per side) -->
+        <ContextMenu x:Key="BlockingEventsContextMenu">
+            <MenuItem Header="Copy Cell" Click="CopyCell_Click">
+                <MenuItem.Icon><TextBlock Text="📋"/></MenuItem.Icon>
+            </MenuItem>
+            <MenuItem Header="Copy Row" Click="CopyRow_Click">
+                <MenuItem.Icon><TextBlock Text="📄"/></MenuItem.Icon>
+            </MenuItem>
+            <MenuItem Header="Copy All Rows" Click="CopyAllRows_Click">
+                <MenuItem.Icon><TextBlock Text="📑"/></MenuItem.Icon>
+            </MenuItem>
+            <Separator/>
+            <MenuItem Header="Export to CSV..." Click="ExportToCsv_Click">
+                <MenuItem.Icon><TextBlock Text="📊"/></MenuItem.Icon>
+            </MenuItem>
+            <Separator/>
+            <MenuItem Header="View Blocked Plan" Click="ViewBlockedSidePlan_Click"/>
+            <MenuItem Header="View Blocking Plan" Click="ViewBlockingSidePlan_Click"/>
+        </ContextMenu>
+
+        <!-- Context Menu for Deadlock rows (copy/export + View Plan) -->
+        <ContextMenu x:Key="DeadlocksContextMenu">
+            <MenuItem Header="Copy Cell" Click="CopyCell_Click">
+                <MenuItem.Icon><TextBlock Text="📋"/></MenuItem.Icon>
+            </MenuItem>
+            <MenuItem Header="Copy Row" Click="CopyRow_Click">
+                <MenuItem.Icon><TextBlock Text="📄"/></MenuItem.Icon>
+            </MenuItem>
+            <MenuItem Header="Copy All Rows" Click="CopyAllRows_Click">
+                <MenuItem.Icon><TextBlock Text="📑"/></MenuItem.Icon>
+            </MenuItem>
+            <Separator/>
+            <MenuItem Header="Export to CSV..." Click="ExportToCsv_Click">
+                <MenuItem.Icon><TextBlock Text="📊"/></MenuItem.Icon>
+            </MenuItem>
+            <Separator/>
+            <MenuItem Header="View Plan" Click="ViewDeadlockProcessPlan_Click"/>
+        </ContextMenu>
+
         <!-- Row Styles for Visual Indicators -->
         <Style x:Key="HealthRowStyle" TargetType="DataGridRow">
             <Setter Property="ContextMenu" Value="{StaticResource DataGridContextMenu}"/>
@@ -63,6 +102,14 @@
         <Style x:Key="DefaultRowStyle" TargetType="DataGridRow">
             <Setter Property="ContextMenu" Value="{StaticResource DataGridContextMenu}"/>
         </Style>
+
+        <Style x:Key="BlockingEventsPlanRowStyle" TargetType="DataGridRow">
+            <Setter Property="ContextMenu" Value="{StaticResource BlockingEventsContextMenu}"/>
+        </Style>
+
+        <Style x:Key="DeadlocksPlanRowStyle" TargetType="DataGridRow">
+            <Setter Property="ContextMenu" Value="{StaticResource DeadlocksContextMenu}"/>
+        </Style>
         </ResourceDictionary>
     </UserControl.Resources>
     <Grid>
@@ -619,7 +666,7 @@
                             <controls:TimeRangeSlicerControl x:Name="BlockingSlicer" Grid.Row="0"/>
                         <DataGrid x:Name="BlockingEventsDataGrid" Grid.Row="1" AutoGenerateColumns="False" IsReadOnly="True"
                                       GridLinesVisibility="Horizontal" CanUserResizeColumns="True"
-                                      RowStyle="{StaticResource DefaultRowStyle}"
+                                      RowStyle="{StaticResource BlockingEventsPlanRowStyle}"
                                       ScrollViewer.CanContentScroll="True" ScrollViewer.HorizontalScrollBarVisibility="Auto" ScrollViewer.VerticalScrollBarVisibility="Auto">
                                 <DataGrid.Columns>
                                     <DataGridTextColumn Binding="{Binding EventTime, Converter={StaticResource ServerTimeConverter}}" Width="150">
@@ -813,7 +860,7 @@
                             <controls:TimeRangeSlicerControl x:Name="DeadlockSlicer" Grid.Row="0"/>
                         <DataGrid x:Name="DeadlocksDataGrid" Grid.Row="1" AutoGenerateColumns="False" IsReadOnly="True"
                                       RowHeight="28" GridLinesVisibility="Horizontal" CanUserResizeColumns="True"
-                                      RowStyle="{StaticResource DefaultRowStyle}"
+                                      RowStyle="{StaticResource DeadlocksPlanRowStyle}"
                                       ScrollViewer.CanContentScroll="True" ScrollViewer.HorizontalScrollBarVisibility="Auto" ScrollViewer.VerticalScrollBarVisibility="Auto">
                                 <DataGrid.Columns>
                                     <DataGridTextColumn Binding="{Binding EventDate, Converter={StaticResource ServerTimeConverter}}" Width="150">
diff --git a/Dashboard/ServerTab.xaml.cs b/Dashboard/ServerTab.xaml.cs
index e793be13..cebd4e92 100644
--- a/Dashboard/ServerTab.xaml.cs
+++ b/Dashboard/ServerTab.xaml.cs
@@ -1,4 +1,5 @@
 using System;
+using System.Data;
 using System.Globalization;
 using System.IO;
 using System.Linq;
@@ -12,6 +13,7 @@
 using System.Windows.Controls.Primitives;
 using System.Windows.Media;
 using System.Windows.Threading;
+using Microsoft.Data.SqlClient;
 using Microsoft.Win32;
 using PerformanceMonitorDashboard.Models;
 using PerformanceMonitorDashboard.Interfaces;
@@ -2044,6 +2046,279 @@ private void DownloadDeadlockGraph_Click(object sender, RoutedEventArgs e)
             }
         }
 
+        // ── Blocked Process Report / Deadlock plan lookup ──
+
+        /* SQL Server writes this 42-byte all-zero handle into executionStack frames
+           for dynamic SQL / system contexts where no persistent sql_handle exists.
+           Filter matches sp_HumanEventsBlockViewer's XPath exclusion. */
+        private static readonly string ZeroSqlHandle = "0x" + new string('0', 84);
+
+        private async void ViewBlockedSidePlan_Click(object sender, RoutedEventArgs e)
+            => await ShowBlockedProcessPlanAsync(sender, blockingSide: false);
+
+        private async void ViewBlockingSidePlan_Click(object sender, RoutedEventArgs e)
+            => await ShowBlockedProcessPlanAsync(sender, blockingSide: true);
+
+        private async Task ShowBlockedProcessPlanAsync(object sender, bool blockingSide)
+        {
+            if (sender is not MenuItem menuItem) return;
+            if (menuItem.Parent is not ContextMenu cm) return;
+            var grid = FindDataGridFromContextMenu(cm);
+            if (grid?.SelectedItem is not BlockingEventItem row) return;
+
+            var sideLabel = blockingSide ? "Blocking" : "Blocked";
+            var label = $"Est Plan - {sideLabel} SPID {row.Spid}";
+
+            var frames = ExtractBlockedProcessFrames(row.BlockedProcessReportXml, blockingSide);
+            if (frames.Count == 0)
+            {
+                MessageBox.Show(
+                    $"The {sideLabel.ToLowerInvariant()} process report has no resolvable sql_handle. " +
+                    "This usually means the query ran as dynamic SQL or a system context — " +
+                    "SQL Server records a zero handle in that case and the plan can't be recovered.",
+                    "No Plan Available", MessageBoxButton.OK, MessageBoxImage.Information);
+                return;
+            }
+
+            string? planXml = null;
+            try
+            {
+                var connStr = _serverConnection.GetConnectionString(_credentialService);
+                foreach (var f in frames)
+                {
+                    planXml = await FetchPlanBySqlHandleAsync(
+                        connStr, row.DatabaseName, f.SqlHandle, f.StmtStart, f.StmtEnd);
+                    if (!string.IsNullOrEmpty(planXml)) break;
+                }
+            }
+            catch { }
+
+            if (!string.IsNullOrEmpty(planXml))
+            {
+                OpenPlanTab(planXml, label, row.QueryText);
+                PlanViewerTabItem.IsSelected = true;
+            }
+            else
+            {
+                MessageBox.Show(
+                    $"The plan for the {sideLabel.ToLowerInvariant()} query is no longer in the plan cache on {_serverConnection.DisplayName}. " +
+                    "Blocked process reports only give us a sql_handle — if that plan has been evicted, we can't recover it.",
+                    "No Plan Available", MessageBoxButton.OK, MessageBoxImage.Information);
+            }
+        }
+
+        private static IReadOnlyList<(string SqlHandle, int StmtStart, int StmtEnd)> ExtractBlockedProcessFrames(
+            string bprXml, bool blockingSide)
+        {
+            var empty = Array.Empty<(string, int, int)>();
+            if (string.IsNullOrWhiteSpace(bprXml)) return empty;
+            try
+            {
+                var doc = System.Xml.Linq.XElement.Parse(bprXml);
+                var processContainer = blockingSide
+                    ? doc.Element("blocking-process")
+                    : doc.Element("blocked-process");
+                var stack = processContainer?.Element("process")?.Element("executionStack");
+                if (stack == null) return empty;
+
+                var frames = new List<(string, int, int)>();
+                foreach (var frame in stack.Elements("frame"))
+                {
+                    var handle = frame.Attribute("sqlhandle")?.Value;
+                    if (string.IsNullOrWhiteSpace(handle)) continue;
+                    if (string.Equals(handle, ZeroSqlHandle, StringComparison.OrdinalIgnoreCase)) continue;
+
+                    int stmtStart = 0;
+                    int stmtEnd = -1;
+                    int.TryParse(frame.Attribute("stmtstart")?.Value, out stmtStart);
+                    if (int.TryParse(frame.Attribute("stmtend")?.Value, out var se)) stmtEnd = se;
+
+                    frames.Add((handle!, stmtStart, stmtEnd));
+                }
+                return frames;
+            }
+            catch
+            {
+                return empty;
+            }
+        }
+
+        /* Deadlock graph XML puts sqlhandle/stmtstart/stmtend directly on the
+           <process> node, with optional <executionStack><frame sqlhandle=...>
+           children for the call stack. Match by SPID since Dashboard's row
+           model doesn't carry the process graph id. */
+        private async void ViewDeadlockProcessPlan_Click(object sender, RoutedEventArgs e)
+        {
+            if (sender is not MenuItem menuItem) return;
+            if (menuItem.Parent is not ContextMenu cm) return;
+            var grid = FindDataGridFromContextMenu(cm);
+            if (grid?.SelectedItem is not DeadlockItem row) return;
+
+            var sideLabel = string.IsNullOrWhiteSpace(row.DeadlockType) ? "Process" : row.DeadlockType;
+            var label = $"Est Plan - {sideLabel} SPID {row.Spid}";
+
+            var frames = ExtractDeadlockProcessFrames(row.DeadlockGraph, row.Spid);
+            if (frames.Count == 0)
+            {
+                MessageBox.Show(
+                    "The process has no resolvable sql_handle in the deadlock graph. " +
+                    "This usually means the query ran as dynamic SQL or a system context — " +
+                    "SQL Server records a zero handle in that case and the plan can't be recovered.",
+                    "No Plan Available", MessageBoxButton.OK, MessageBoxImage.Information);
+                return;
+            }
+
+            string? planXml = null;
+            try
+            {
+                var connStr = _serverConnection.GetConnectionString(_credentialService);
+                foreach (var f in frames)
+                {
+                    planXml = await FetchPlanBySqlHandleAsync(
+                        connStr, row.DatabaseName, f.SqlHandle, f.StmtStart, f.StmtEnd);
+                    if (!string.IsNullOrEmpty(planXml)) break;
+                }
+            }
+            catch { }
+
+            if (!string.IsNullOrEmpty(planXml))
+            {
+                OpenPlanTab(planXml, label, row.Query);
+                PlanViewerTabItem.IsSelected = true;
+            }
+            else
+            {
+                MessageBox.Show(
+                    $"The plan for this process is no longer in the plan cache on {_serverConnection.DisplayName}. " +
+                    "Deadlock graphs only give us a sql_handle — if that plan has been evicted, we can't recover it.",
+                    "No Plan Available", MessageBoxButton.OK, MessageBoxImage.Information);
+            }
+        }
+
+        private static IReadOnlyList<(string SqlHandle, int StmtStart, int StmtEnd)> ExtractDeadlockProcessFrames(
+            string graphXml, short? spid)
+        {
+            var empty = Array.Empty<(string, int, int)>();
+            if (string.IsNullOrWhiteSpace(graphXml) || !spid.HasValue) return empty;
+            try
+            {
+                var doc = System.Xml.Linq.XElement.Parse(graphXml);
+                var spidStr = spid.Value.ToString(CultureInfo.InvariantCulture);
+                var process = doc.Descendants("process")
+                    .FirstOrDefault(p => string.Equals(p.Attribute("spid")?.Value, spidStr, StringComparison.Ordinal));
+                if (process == null) return empty;
+
+                var frames = new List<(string, int, int)>();
+
+                var procHandle = process.Attribute("sqlhandle")?.Value;
+                if (!string.IsNullOrWhiteSpace(procHandle) &&
+                    !string.Equals(procHandle, ZeroSqlHandle, StringComparison.OrdinalIgnoreCase))
+                {
+                    int ps = 0, pe = -1;
+                    int.TryParse(process.Attribute("stmtstart")?.Value, out ps);
+                    if (int.TryParse(process.Attribute("stmtend")?.Value, out var peParsed)) pe = peParsed;
+                    frames.Add((procHandle!, ps, pe));
+                }
+
+                var stack = process.Element("executionStack");
+                if (stack != null)
+                {
+                    foreach (var frame in stack.Elements("frame"))
+                    {
+                        var handle = frame.Attribute("sqlhandle")?.Value;
+                        if (string.IsNullOrWhiteSpace(handle)) continue;
+                        if (string.Equals(handle, ZeroSqlHandle, StringComparison.OrdinalIgnoreCase)) continue;
+
+                        int fs = 0, fe = -1;
+                        int.TryParse(frame.Attribute("stmtstart")?.Value, out fs);
+                        if (int.TryParse(frame.Attribute("stmtend")?.Value, out var feParsed)) fe = feParsed;
+                        frames.Add((handle!, fs, fe));
+                    }
+                }
+
+                return frames;
+            }
+            catch
+            {
+                return empty;
+            }
+        }
+
+        private static async Task<string?> FetchPlanBySqlHandleAsync(
+            string connectionString,
+            string databaseName,
+            string sqlHandleHex,
+            int statementStartOffset,
+            int statementEndOffset)
+        {
+            if (string.IsNullOrWhiteSpace(sqlHandleHex)) return null;
+            var handleBytes = HexStringToBytes(sqlHandleHex);
+            if (handleBytes == null || handleBytes.Length == 0) return null;
+
+            using var connection = new SqlConnection(connectionString);
+            await connection.OpenAsync();
+
+            /* Database context is only used to route the execution; sys.dm_exec_query_stats
+               is server-scoped, so if the supplied name isn't valid we fall back to master. */
+            var quotedDbName = QuoteDatabaseName(databaseName) ?? "[master]";
+
+            var query = $@"
+EXECUTE {quotedDbName}.sys.sp_executesql
+    N'
+SELECT TOP (1)
+    query_plan_text = tqp.query_plan
+FROM sys.dm_exec_query_stats AS qs
+OUTER APPLY sys.dm_exec_text_query_plan(qs.plan_handle, qs.statement_start_offset, qs.statement_end_offset) AS tqp
+WHERE qs.sql_handle = @h
+AND   qs.statement_start_offset = @stmt_start
+AND   qs.statement_end_offset = @stmt_end
+AND   tqp.query_plan IS NOT NULL
+ORDER BY
+    qs.last_execution_time DESC
+OPTION(RECOMPILE);',
+    N'@h varbinary(64), @stmt_start int, @stmt_end int',
+    @h, @stmt_start, @stmt_end;";
+
+            using var command = new SqlCommand(query, connection) { CommandTimeout = 30 };
+            command.Parameters.Add(new SqlParameter("@h", SqlDbType.VarBinary, 64) { Value = handleBytes });
+            command.Parameters.Add(new SqlParameter("@stmt_start", SqlDbType.Int) { Value = statementStartOffset });
+            command.Parameters.Add(new SqlParameter("@stmt_end", SqlDbType.Int) { Value = statementEndOffset });
+            var result = await command.ExecuteScalarAsync();
+            return result as string;
+        }
+
+        private static byte[]? HexStringToBytes(string hex)
+        {
+            var start = hex.StartsWith("0x", StringComparison.OrdinalIgnoreCase) ? 2 : 0;
+            var len = hex.Length - start;
+            if (len <= 0 || (len % 2) != 0) return null;
+            var bytes = new byte[len / 2];
+            for (int i = 0; i < bytes.Length; i++)
+            {
+                if (!byte.TryParse(hex.AsSpan(start + i * 2, 2),
+                                   NumberStyles.HexNumber,
+                                   CultureInfo.InvariantCulture,
+                                   out bytes[i]))
+                {
+                    return null;
+                }
+            }
+            return bytes;
+        }
+
+        /* Only accept names that are syntactically plain identifiers so we can safely
+           interpolate into the EXEC statement. Unknown / invalid names fall back to master. */
+        private static string? QuoteDatabaseName(string? dbName)
+        {
+            if (string.IsNullOrWhiteSpace(dbName)) return null;
+            foreach (var c in dbName)
+            {
+                if (!(char.IsLetterOrDigit(c) || c == '_' || c == '$' || c == '#' || c == '-' || c == ' '))
+                    return null;
+            }
+            return "[" + dbName.Replace("]", "]]") + "]";
+        }
+
         private void LoadUserPreferences()
         {
             var prefs = _preferencesService.GetPreferences();

From 5c988a092d1a42bc0cd3b7f543a6337617a8abc0 Mon Sep 17 00:00:00 2001
From: ClaudioESSilva <claudiosil100@gmail.com>
Date: Fri, 24 Apr 2026 14:19:11 +0100
Subject: [PATCH 33/49] Fixes #889

---
 Dashboard/Controls/FinOpsContent.xaml         |  6 ++
 Dashboard/Controls/PlanViewerControl.xaml     | 10 +--
 Dashboard/Controls/PlanViewerControl.xaml.cs  | 81 +++++++++++++------
 .../Controls/QueryPerformanceContent.xaml     | 27 ++++---
 Dashboard/Themes/CoolBreezeTheme.xaml         | 47 ++++++++++-
 Dashboard/Themes/DarkTheme.xaml               | 43 +++++++++-
 Dashboard/Themes/LightTheme.xaml              | 47 ++++++++++-
 7 files changed, 213 insertions(+), 48 deletions(-)

diff --git a/Dashboard/Controls/FinOpsContent.xaml b/Dashboard/Controls/FinOpsContent.xaml
index 43573d47..0d8d0ba7 100644
--- a/Dashboard/Controls/FinOpsContent.xaml
+++ b/Dashboard/Controls/FinOpsContent.xaml
@@ -111,6 +111,9 @@
                                         <DataTrigger Binding="{Binding Severity}" Value="Low">
                                             <Setter Property="Foreground" Value="#27AE60"/>
                                         </DataTrigger>
+                                        <DataTrigger Binding="{Binding IsSelected, RelativeSource={RelativeSource AncestorType=DataGridRow, AncestorLevel=1}, FallbackValue=False}" Value="True">
+                                            <Setter Property="Foreground" Value="{DynamicResource GridSelectionForegroundBrush}"/>
+                                        </DataTrigger>
                                     </Style.Triggers>
                                 </Style>
                             </DataGridTextColumn.ElementStyle>
@@ -416,6 +419,9 @@
                                                 <Setter Property="Foreground" Value="#E74C3C"/>
                                                 <Setter Property="FontWeight" Value="SemiBold"/>
                                             </DataTrigger>
+                                            <DataTrigger Binding="{Binding IsSelected, RelativeSource={RelativeSource AncestorType=DataGridRow, AncestorLevel=1}, FallbackValue=False}" Value="True">
+                                                <Setter Property="Foreground" Value="{DynamicResource GridSelectionForegroundBrush}"/>
+                                            </DataTrigger>
                                         </Style.Triggers>
                                     </Style>
                                 </DataGridTextColumn.ElementStyle>
diff --git a/Dashboard/Controls/PlanViewerControl.xaml b/Dashboard/Controls/PlanViewerControl.xaml
index d41669fc..2f720e50 100644
--- a/Dashboard/Controls/PlanViewerControl.xaml
+++ b/Dashboard/Controls/PlanViewerControl.xaml
@@ -77,15 +77,15 @@
 
                     <!-- Missing Indexes (center) -->
                     <Border Grid.Column="1" Padding="10,4,10,8"
-                            Background="#3D2A0E"
-                            BorderBrush="#7A5A1E" BorderThickness="0,0,1,0">
+                            Background="{DynamicResource PlanMissingIndexBgBrush}"
+                            BorderBrush="{DynamicResource PlanMissingIndexBorderBrush}" BorderThickness="0,0,1,0">
                         <ScrollViewer VerticalScrollBarVisibility="Auto"
                                       HorizontalScrollBarVisibility="Disabled">
                             <StackPanel>
                                 <TextBlock x:Name="MissingIndexHeader"
                                            Text="Missing Index Suggestions"
                                            FontSize="13"
-                                           FontWeight="SemiBold" Foreground="#FFB347"
+                                           FontWeight="SemiBold" Foreground="{DynamicResource PlanMissingIndexHeaderBrush}"
                                            Margin="0,0,0,6"/>
                                 <StackPanel x:Name="MissingIndexContent"/>
                                 <TextBlock x:Name="MissingIndexEmpty"
@@ -98,14 +98,14 @@
 
                     <!-- Wait Stats (right, fills remaining space) -->
                     <Border Grid.Column="2" Padding="10,4,10,8"
-                            Background="#1A2A3D">
+                            Background="{DynamicResource PlanWaitStatsBgBrush}">
                         <ScrollViewer VerticalScrollBarVisibility="Auto"
                                       HorizontalScrollBarVisibility="Disabled">
                             <StackPanel>
                                 <TextBlock x:Name="WaitStatsHeader"
                                            Text="Wait Stats"
                                            FontSize="13"
-                                           FontWeight="SemiBold" Foreground="#4FA3FF"
+                                           FontWeight="SemiBold" Foreground="{DynamicResource PlanWaitStatsHeaderBrush}"
                                            Margin="0,0,0,6"/>
                                 <StackPanel x:Name="WaitStatsContent"/>
                                 <TextBlock x:Name="WaitStatsEmpty"
diff --git a/Dashboard/Controls/PlanViewerControl.xaml.cs b/Dashboard/Controls/PlanViewerControl.xaml.cs
index 247581d3..c7bcac47 100644
--- a/Dashboard/Controls/PlanViewerControl.xaml.cs
+++ b/Dashboard/Controls/PlanViewerControl.xaml.cs
@@ -31,18 +31,27 @@ public partial class PlanViewerControl : UserControl
     private Border? _selectedNodeBorder;
     private Brush? _selectedNodeOriginalBorder;
     private Thickness _selectedNodeOriginalThickness;
+    private PlanNode? _selectedNode;
 
-    // Brushes
+    // Brushes — accent/neutral tones that suit every theme
     private static readonly SolidColorBrush SelectionBrush = new(Color.FromRgb(0x4F, 0xA3, 0xFF));
-    private static readonly SolidColorBrush TooltipBgBrush = new(Color.FromRgb(0x1A, 0x1D, 0x23));
-    private static readonly SolidColorBrush TooltipBorderBrush = new(Color.FromRgb(0x3A, 0x3D, 0x45));
-    private static readonly SolidColorBrush TooltipFgBrush = new(Color.FromRgb(0xE4, 0xE6, 0xEB));
-    private static readonly SolidColorBrush MutedBrush = new(Color.FromRgb(0xE4, 0xE6, 0xEB));
     private static readonly SolidColorBrush EdgeBrush = new(Color.FromRgb(0x6B, 0x72, 0x80));
-    private static readonly SolidColorBrush SectionHeaderBrush = new(Color.FromRgb(0x4F, 0xA3, 0xFF));
-    private static readonly SolidColorBrush PropSeparatorBrush = new(Color.FromRgb(0x2A, 0x2D, 0x35));
     private static readonly SolidColorBrush OrangeBrush = new(Color.FromRgb(0xFF, 0xB3, 0x47));
 
+    // Theme-aware brushes resolved at call time from Application.Resources
+    private SolidColorBrush TooltipBgBrush =>
+        (TryFindResource("PlanTooltipBgBrush") as SolidColorBrush) ?? new SolidColorBrush(Color.FromRgb(0x1A, 0x1D, 0x23));
+    private SolidColorBrush TooltipBorderBrush =>
+        (TryFindResource("PlanTooltipBorderBrush") as SolidColorBrush) ?? new SolidColorBrush(Color.FromRgb(0x3A, 0x3D, 0x45));
+    private SolidColorBrush TooltipFgBrush =>
+        (TryFindResource("PlanPanelTextBrush") as SolidColorBrush) ?? new SolidColorBrush(Color.FromRgb(0xE4, 0xE6, 0xEB));
+    private SolidColorBrush MutedBrush =>
+        (TryFindResource("PlanPanelMutedBrush") as SolidColorBrush) ?? new SolidColorBrush(Color.FromRgb(0xE4, 0xE6, 0xEB));
+    private SolidColorBrush SectionHeaderBrush =>
+        (TryFindResource("PlanSectionHeaderBrush") as SolidColorBrush) ?? new SolidColorBrush(Color.FromRgb(0x4F, 0xA3, 0xFF));
+    private SolidColorBrush PropSeparatorBrush =>
+        (TryFindResource("PlanPropSeparatorBrush") as SolidColorBrush) ?? new SolidColorBrush(Color.FromRgb(0x2A, 0x2D, 0x35));
+
     // Current property section for collapsible groups
     private StackPanel? _currentPropertySection;
 
@@ -55,6 +64,28 @@ public partial class PlanViewerControl : UserControl
     public PlanViewerControl()
     {
         InitializeComponent();
+        Helpers.ThemeManager.ThemeChanged += OnThemeChanged;
+        Unloaded += (_, _) => Helpers.ThemeManager.ThemeChanged -= OnThemeChanged;
+    }
+
+    private void OnThemeChanged(string _)
+    {
+        if (_currentStatement == null) return;
+
+        var nodeToRestore = _selectedNode;
+        RenderStatement(_currentStatement);
+
+        if (nodeToRestore == null) return;
+
+        // Find the re-created border for the previously selected node and reopen properties
+        foreach (var child in PlanCanvas.Children)
+        {
+            if (child is Border b && b.Tag == nodeToRestore)
+            {
+                SelectNode(b, nodeToRestore);
+                break;
+            }
+        }
     }
 
     public void LoadPlan(string planXml, string label, string? queryText = null)
@@ -488,14 +519,14 @@ void AddRow(string label, string value)
             var lbl = new TextBlock
             {
                 Text = label,
-                Foreground = new SolidColorBrush(Color.FromRgb(0xE0, 0xE0, 0xE0)),
+                Foreground = MutedBrush,
                 FontSize = 12,
                 Margin = new Thickness(0, 1, 12, 1)
             };
             var val = new TextBlock
             {
                 Text = value,
-                Foreground = new SolidColorBrush(Colors.White),
+                Foreground = TooltipFgBrush,
                 FontSize = 12,
                 FontWeight = FontWeights.SemiBold,
                 HorizontalAlignment = HorizontalAlignment.Right,
@@ -528,8 +559,8 @@ void AddRow(string label, string value)
 
         return new Border
         {
-            Background = new SolidColorBrush(Color.FromRgb(0x1E, 0x1E, 0x2E)),
-            BorderBrush = new SolidColorBrush(Color.FromRgb(0x3A, 0x3A, 0x5A)),
+            Background = TooltipBgBrush,
+            BorderBrush = TooltipBorderBrush,
             BorderThickness = new Thickness(1),
             Padding = new Thickness(10, 6, 10, 6),
             CornerRadius = new CornerRadius(4),
@@ -571,6 +602,7 @@ private void SelectNode(Border border, PlanNode node)
         _selectedNodeOriginalBorder = border.BorderBrush;
         _selectedNodeOriginalThickness = border.BorderThickness;
         _selectedNodeBorder = border;
+        _selectedNode = node;
         border.BorderBrush = SelectionBrush;
         border.BorderThickness = new Thickness(2);
 
@@ -1504,7 +1536,7 @@ private void AddPropertySection(string title)
             Margin = new Thickness(0, 2, 0, 0),
             Padding = new Thickness(0),
             Foreground = SectionHeaderBrush,
-            Background = new SolidColorBrush(Color.FromArgb(0x18, 0x4F, 0xA3, 0xFF)),
+            Background = (TryFindResource("BackgroundLighterBrush") as SolidColorBrush) ?? new SolidColorBrush(Color.FromArgb(0x18, 0x4F, 0xA3, 0xFF)),
             BorderBrush = PropSeparatorBrush,
             BorderThickness = new Thickness(0, 0, 0, 1)
         };
@@ -1568,6 +1600,7 @@ private void ClosePropertiesPanel()
             _selectedNodeBorder.BorderThickness = _selectedNodeOriginalThickness;
             _selectedNodeBorder = null;
         }
+        _selectedNode = null;
     }
 
     #endregion
@@ -1780,7 +1813,7 @@ private ToolTip BuildNodeTooltip(PlanNode node, List<PlanWarning>? allWarnings =
         return tip;
     }
 
-    private static void AddTooltipSection(StackPanel parent, string title)
+    private void AddTooltipSection(StackPanel parent, string title)
     {
         parent.Children.Add(new TextBlock
         {
@@ -1792,7 +1825,7 @@ private static void AddTooltipSection(StackPanel parent, string title)
         });
     }
 
-    private static void AddTooltipRow(StackPanel parent, string label, string value, bool isCode = false)
+    private void AddTooltipRow(StackPanel parent, string label, string value, bool isCode = false)
     {
         var row = new StackPanel { Orientation = Orientation.Horizontal, Margin = new Thickness(0, 1, 0, 1) };
         row.Children.Add(new TextBlock
@@ -1835,19 +1868,19 @@ private void ShowMissingIndexes(List<MissingIndex> indexes)
                 {
                     Text = mi.Table,
                     FontWeight = FontWeights.SemiBold,
-                    Foreground = new SolidColorBrush((Color)ColorConverter.ConvertFromString("#E4E6EB")),
+                    Foreground = TooltipFgBrush,
                     FontSize = 12
                 });
                 headerRow.Children.Add(new TextBlock
                 {
                     Text = $" \u2014 Impact: ",
-                    Foreground = new SolidColorBrush((Color)ColorConverter.ConvertFromString("#E4E6EB")),
+                    Foreground = MutedBrush,
                     FontSize = 12
                 });
                 headerRow.Children.Add(new TextBlock
                 {
                     Text = $"{mi.Impact:F1}%",
-                    Foreground = new SolidColorBrush((Color)ColorConverter.ConvertFromString("#FFB347")),
+                    Foreground = OrangeBrush,
                     FontSize = 12
                 });
                 itemPanel.Children.Add(headerRow);
@@ -1859,7 +1892,7 @@ private void ShowMissingIndexes(List<MissingIndex> indexes)
                         Text = mi.CreateStatement,
                         FontFamily = new FontFamily("Consolas"),
                         FontSize = 11,
-                        Foreground = new SolidColorBrush((Color)ColorConverter.ConvertFromString("#E4E6EB")),
+                        Foreground = TooltipFgBrush,
                         Background = Brushes.Transparent,
                         BorderThickness = new Thickness(0),
                         IsReadOnly = true,
@@ -1932,7 +1965,7 @@ private void ShowWaitStats(List<WaitStatInfo> waits, bool isActualPlan)
             {
                 Text = w.WaitType,
                 FontSize = 12,
-                Foreground = new SolidColorBrush((Color)ColorConverter.ConvertFromString("#E4E6EB")),
+                Foreground = TooltipFgBrush,
                 VerticalAlignment = VerticalAlignment.Center,
                 Margin = new Thickness(0, 2, 10, 2)
             };
@@ -1958,7 +1991,7 @@ private void ShowWaitStats(List<WaitStatInfo> waits, bool isActualPlan)
             {
                 Text = $"{w.WaitTimeMs:N0}ms ({w.WaitCount:N0} waits)",
                 FontSize = 12,
-                Foreground = new SolidColorBrush((Color)ColorConverter.ConvertFromString("#E4E6EB")),
+                Foreground = TooltipFgBrush,
                 VerticalAlignment = VerticalAlignment.Center,
                 Margin = new Thickness(0, 2, 0, 2)
             };
@@ -2014,8 +2047,8 @@ private void ShowRuntimeSummary(PlanStatement statement)
     {
         RuntimeSummaryContent.Children.Clear();
 
-        var labelColor = "#E4E6EB";
-        var valueColor = "#E4E6EB";
+        var labelBrush = MutedBrush;
+        var valueBrush = TooltipFgBrush;
 
         var grid = new Grid();
         grid.ColumnDefinitions.Add(new ColumnDefinition { Width = GridLength.Auto });
@@ -2030,7 +2063,7 @@ void AddRow(string label, string value)
             {
                 Text = label,
                 FontSize = 11,
-                Foreground = new SolidColorBrush((Color)ColorConverter.ConvertFromString(labelColor)),
+                Foreground = labelBrush,
                 HorizontalAlignment = HorizontalAlignment.Left,
                 Margin = new Thickness(0, 1, 8, 1)
             };
@@ -2042,7 +2075,7 @@ void AddRow(string label, string value)
             {
                 Text = value,
                 FontSize = 11,
-                Foreground = new SolidColorBrush((Color)ColorConverter.ConvertFromString(valueColor)),
+                Foreground = valueBrush,
                 Margin = new Thickness(0, 1, 0, 1)
             };
             Grid.SetRow(valueText, rowIndex);
diff --git a/Dashboard/Controls/QueryPerformanceContent.xaml b/Dashboard/Controls/QueryPerformanceContent.xaml
index 235f8efd..aa033e13 100644
--- a/Dashboard/Controls/QueryPerformanceContent.xaml
+++ b/Dashboard/Controls/QueryPerformanceContent.xaml
@@ -879,6 +879,7 @@
                                 <Style.Triggers>
                                     <DataTrigger Binding="{Binding IsNew}" Value="True"><Setter Property="Foreground" Value="#FF6B6B"/></DataTrigger>
                                     <DataTrigger Binding="{Binding IsGone}" Value="True"><Setter Property="Foreground" Value="#888888"/></DataTrigger>
+                                    <DataTrigger Binding="{Binding IsSelected, RelativeSource={RelativeSource AncestorType=DataGridRow, AncestorLevel=1}, FallbackValue=False}" Value="True"><Setter Property="Foreground" Value="{DynamicResource GridSelectionForegroundBrush}"/></DataTrigger>
                                 </Style.Triggers>
                             </Style>
                         </DataGridTextColumn.ElementStyle>
@@ -887,19 +888,19 @@
                     <DataGridTextColumn Binding="{Binding ExecutionCount, StringFormat=N0}" ElementStyle="{StaticResource NumericCell}" Width="90"><DataGridTextColumn.Header><TextBlock Text="Executions" FontWeight="Bold"/></DataGridTextColumn.Header></DataGridTextColumn>
                     <DataGridTextColumn Binding="{Binding BaselineExecutionCount, StringFormat=N0}" ElementStyle="{StaticResource NumericCell}" Width="100"><DataGridTextColumn.Header><TextBlock Text="Base Execs" FontWeight="Bold"/></DataGridTextColumn.Header></DataGridTextColumn>
                     <DataGridTextColumn Binding="{Binding ExecutionDeltaDisplay}" Width="80"><DataGridTextColumn.Header><TextBlock Text="Exec &#x0394;" FontWeight="Bold"/></DataGridTextColumn.Header>
-                        <DataGridTextColumn.ElementStyle><Style TargetType="TextBlock"><Setter Property="HorizontalAlignment" Value="Right"/><Setter Property="Padding" Value="0,0,5,0"/><Setter Property="FontWeight" Value="SemiBold"/><Setter Property="Foreground" Value="{Binding ExecutionDeltaBrush}"/></Style></DataGridTextColumn.ElementStyle></DataGridTextColumn>
+                        <DataGridTextColumn.ElementStyle><Style TargetType="TextBlock" BasedOn="{StaticResource DataGridCellText}"><Setter Property="HorizontalAlignment" Value="Right"/><Setter Property="Padding" Value="0,0,5,0"/><Setter Property="FontWeight" Value="SemiBold"/><Setter Property="Foreground" Value="{Binding ExecutionDeltaBrush}"/></Style></DataGridTextColumn.ElementStyle></DataGridTextColumn>
                     <DataGridTextColumn Binding="{Binding AvgDurationMs, StringFormat=N2}" ElementStyle="{StaticResource NumericCell}" Width="100"><DataGridTextColumn.Header><TextBlock Text="Avg Dur (ms)" FontWeight="Bold"/></DataGridTextColumn.Header></DataGridTextColumn>
                     <DataGridTextColumn Binding="{Binding BaselineAvgDurationMs, StringFormat=N2}" ElementStyle="{StaticResource NumericCell}" Width="110"><DataGridTextColumn.Header><TextBlock Text="Base Dur (ms)" FontWeight="Bold"/></DataGridTextColumn.Header></DataGridTextColumn>
                     <DataGridTextColumn Binding="{Binding DurationDeltaDisplay}" Width="80"><DataGridTextColumn.Header><TextBlock Text="Dur &#x0394;" FontWeight="Bold"/></DataGridTextColumn.Header>
-                        <DataGridTextColumn.ElementStyle><Style TargetType="TextBlock"><Setter Property="HorizontalAlignment" Value="Right"/><Setter Property="Padding" Value="0,0,5,0"/><Setter Property="FontWeight" Value="SemiBold"/><Setter Property="Foreground" Value="{Binding DurationDeltaBrush}"/></Style></DataGridTextColumn.ElementStyle></DataGridTextColumn>
+                        <DataGridTextColumn.ElementStyle><Style TargetType="TextBlock" BasedOn="{StaticResource DataGridCellText}"><Setter Property="HorizontalAlignment" Value="Right"/><Setter Property="Padding" Value="0,0,5,0"/><Setter Property="FontWeight" Value="SemiBold"/><Setter Property="Foreground" Value="{Binding DurationDeltaBrush}"/></Style></DataGridTextColumn.ElementStyle></DataGridTextColumn>
                     <DataGridTextColumn Binding="{Binding AvgCpuMs, StringFormat=N2}" ElementStyle="{StaticResource NumericCell}" Width="95"><DataGridTextColumn.Header><TextBlock Text="Avg CPU (ms)" FontWeight="Bold"/></DataGridTextColumn.Header></DataGridTextColumn>
                     <DataGridTextColumn Binding="{Binding BaselineAvgCpuMs, StringFormat=N2}" ElementStyle="{StaticResource NumericCell}" Width="110"><DataGridTextColumn.Header><TextBlock Text="Base CPU (ms)" FontWeight="Bold"/></DataGridTextColumn.Header></DataGridTextColumn>
                     <DataGridTextColumn Binding="{Binding CpuDeltaDisplay}" Width="80"><DataGridTextColumn.Header><TextBlock Text="CPU &#x0394;" FontWeight="Bold"/></DataGridTextColumn.Header>
-                        <DataGridTextColumn.ElementStyle><Style TargetType="TextBlock"><Setter Property="HorizontalAlignment" Value="Right"/><Setter Property="Padding" Value="0,0,5,0"/><Setter Property="FontWeight" Value="SemiBold"/><Setter Property="Foreground" Value="{Binding CpuDeltaBrush}"/></Style></DataGridTextColumn.ElementStyle></DataGridTextColumn>
+                        <DataGridTextColumn.ElementStyle><Style TargetType="TextBlock" BasedOn="{StaticResource DataGridCellText}"><Setter Property="HorizontalAlignment" Value="Right"/><Setter Property="Padding" Value="0,0,5,0"/><Setter Property="FontWeight" Value="SemiBold"/><Setter Property="Foreground" Value="{Binding CpuDeltaBrush}"/></Style></DataGridTextColumn.ElementStyle></DataGridTextColumn>
                     <DataGridTextColumn Binding="{Binding AvgReads, StringFormat=N0}" ElementStyle="{StaticResource NumericCell}" Width="85"><DataGridTextColumn.Header><TextBlock Text="Avg Reads" FontWeight="Bold"/></DataGridTextColumn.Header></DataGridTextColumn>
                     <DataGridTextColumn Binding="{Binding BaselineAvgReads, StringFormat=N0}" ElementStyle="{StaticResource NumericCell}" Width="95"><DataGridTextColumn.Header><TextBlock Text="Base Reads" FontWeight="Bold"/></DataGridTextColumn.Header></DataGridTextColumn>
                     <DataGridTextColumn Binding="{Binding ReadsDeltaDisplay}" Width="80"><DataGridTextColumn.Header><TextBlock Text="Reads &#x0394;" FontWeight="Bold"/></DataGridTextColumn.Header>
-                        <DataGridTextColumn.ElementStyle><Style TargetType="TextBlock"><Setter Property="HorizontalAlignment" Value="Right"/><Setter Property="Padding" Value="0,0,5,0"/><Setter Property="FontWeight" Value="SemiBold"/><Setter Property="Foreground" Value="{Binding ReadsDeltaBrush}"/></Style></DataGridTextColumn.ElementStyle></DataGridTextColumn>
+                        <DataGridTextColumn.ElementStyle><Style TargetType="TextBlock" BasedOn="{StaticResource DataGridCellText}"><Setter Property="HorizontalAlignment" Value="Right"/><Setter Property="Padding" Value="0,0,5,0"/><Setter Property="FontWeight" Value="SemiBold"/><Setter Property="Foreground" Value="{Binding ReadsDeltaBrush}"/></Style></DataGridTextColumn.ElementStyle></DataGridTextColumn>
                     <DataGridTextColumn Binding="{Binding QueryHash}" Width="140"><DataGridTextColumn.Header><TextBlock Text="Query Hash" FontWeight="Bold"/></DataGridTextColumn.Header></DataGridTextColumn>
                     <DataGridTemplateColumn Width="500"><DataGridTemplateColumn.Header><TextBlock Text="Query Text" FontWeight="Bold"/></DataGridTemplateColumn.Header>
                         <DataGridTemplateColumn.CellTemplate><DataTemplate><TextBlock Text="{Binding QueryText}" TextWrapping="Wrap" MaxHeight="90" Margin="5,2" ToolTip="{Binding QueryText}"/></DataTemplate></DataGridTemplateColumn.CellTemplate></DataGridTemplateColumn>
@@ -1194,6 +1195,7 @@
                                 <Style.Triggers>
                                     <DataTrigger Binding="{Binding IsNew}" Value="True"><Setter Property="Foreground" Value="#FF6B6B"/></DataTrigger>
                                     <DataTrigger Binding="{Binding IsGone}" Value="True"><Setter Property="Foreground" Value="#888888"/></DataTrigger>
+                                    <DataTrigger Binding="{Binding IsSelected, RelativeSource={RelativeSource AncestorType=DataGridRow, AncestorLevel=1}, FallbackValue=False}" Value="True"><Setter Property="Foreground" Value="{DynamicResource GridSelectionForegroundBrush}"/></DataTrigger>
                                 </Style.Triggers>
                             </Style>
                         </DataGridTextColumn.ElementStyle>
@@ -1203,19 +1205,19 @@
                     <DataGridTextColumn Binding="{Binding ExecutionCount, StringFormat=N0}" ElementStyle="{StaticResource NumericCell}" Width="90"><DataGridTextColumn.Header><TextBlock Text="Executions" FontWeight="Bold"/></DataGridTextColumn.Header></DataGridTextColumn>
                     <DataGridTextColumn Binding="{Binding BaselineExecutionCount, StringFormat=N0}" ElementStyle="{StaticResource NumericCell}" Width="100"><DataGridTextColumn.Header><TextBlock Text="Base Execs" FontWeight="Bold"/></DataGridTextColumn.Header></DataGridTextColumn>
                     <DataGridTextColumn Binding="{Binding ExecutionDeltaDisplay}" Width="80"><DataGridTextColumn.Header><TextBlock Text="Exec &#x0394;" FontWeight="Bold"/></DataGridTextColumn.Header>
-                        <DataGridTextColumn.ElementStyle><Style TargetType="TextBlock"><Setter Property="HorizontalAlignment" Value="Right"/><Setter Property="Padding" Value="0,0,5,0"/><Setter Property="FontWeight" Value="SemiBold"/><Setter Property="Foreground" Value="{Binding ExecutionDeltaBrush}"/></Style></DataGridTextColumn.ElementStyle></DataGridTextColumn>
+                        <DataGridTextColumn.ElementStyle><Style TargetType="TextBlock" BasedOn="{StaticResource DataGridCellText}"><Setter Property="HorizontalAlignment" Value="Right"/><Setter Property="Padding" Value="0,0,5,0"/><Setter Property="FontWeight" Value="SemiBold"/><Setter Property="Foreground" Value="{Binding ExecutionDeltaBrush}"/></Style></DataGridTextColumn.ElementStyle></DataGridTextColumn>
                     <DataGridTextColumn Binding="{Binding AvgDurationMs, StringFormat=N2}" ElementStyle="{StaticResource NumericCell}" Width="100"><DataGridTextColumn.Header><TextBlock Text="Avg Dur (ms)" FontWeight="Bold"/></DataGridTextColumn.Header></DataGridTextColumn>
                     <DataGridTextColumn Binding="{Binding BaselineAvgDurationMs, StringFormat=N2}" ElementStyle="{StaticResource NumericCell}" Width="110"><DataGridTextColumn.Header><TextBlock Text="Base Dur (ms)" FontWeight="Bold"/></DataGridTextColumn.Header></DataGridTextColumn>
                     <DataGridTextColumn Binding="{Binding DurationDeltaDisplay}" Width="80"><DataGridTextColumn.Header><TextBlock Text="Dur &#x0394;" FontWeight="Bold"/></DataGridTextColumn.Header>
-                        <DataGridTextColumn.ElementStyle><Style TargetType="TextBlock"><Setter Property="HorizontalAlignment" Value="Right"/><Setter Property="Padding" Value="0,0,5,0"/><Setter Property="FontWeight" Value="SemiBold"/><Setter Property="Foreground" Value="{Binding DurationDeltaBrush}"/></Style></DataGridTextColumn.ElementStyle></DataGridTextColumn>
+                        <DataGridTextColumn.ElementStyle><Style TargetType="TextBlock" BasedOn="{StaticResource DataGridCellText}"><Setter Property="HorizontalAlignment" Value="Right"/><Setter Property="Padding" Value="0,0,5,0"/><Setter Property="FontWeight" Value="SemiBold"/><Setter Property="Foreground" Value="{Binding DurationDeltaBrush}"/></Style></DataGridTextColumn.ElementStyle></DataGridTextColumn>
                     <DataGridTextColumn Binding="{Binding AvgCpuMs, StringFormat=N2}" ElementStyle="{StaticResource NumericCell}" Width="95"><DataGridTextColumn.Header><TextBlock Text="Avg CPU (ms)" FontWeight="Bold"/></DataGridTextColumn.Header></DataGridTextColumn>
                     <DataGridTextColumn Binding="{Binding BaselineAvgCpuMs, StringFormat=N2}" ElementStyle="{StaticResource NumericCell}" Width="110"><DataGridTextColumn.Header><TextBlock Text="Base CPU (ms)" FontWeight="Bold"/></DataGridTextColumn.Header></DataGridTextColumn>
                     <DataGridTextColumn Binding="{Binding CpuDeltaDisplay}" Width="80"><DataGridTextColumn.Header><TextBlock Text="CPU &#x0394;" FontWeight="Bold"/></DataGridTextColumn.Header>
-                        <DataGridTextColumn.ElementStyle><Style TargetType="TextBlock"><Setter Property="HorizontalAlignment" Value="Right"/><Setter Property="Padding" Value="0,0,5,0"/><Setter Property="FontWeight" Value="SemiBold"/><Setter Property="Foreground" Value="{Binding CpuDeltaBrush}"/></Style></DataGridTextColumn.ElementStyle></DataGridTextColumn>
+                        <DataGridTextColumn.ElementStyle><Style TargetType="TextBlock" BasedOn="{StaticResource DataGridCellText}"><Setter Property="HorizontalAlignment" Value="Right"/><Setter Property="Padding" Value="0,0,5,0"/><Setter Property="FontWeight" Value="SemiBold"/><Setter Property="Foreground" Value="{Binding CpuDeltaBrush}"/></Style></DataGridTextColumn.ElementStyle></DataGridTextColumn>
                     <DataGridTextColumn Binding="{Binding AvgReads, StringFormat=N0}" ElementStyle="{StaticResource NumericCell}" Width="85"><DataGridTextColumn.Header><TextBlock Text="Avg Reads" FontWeight="Bold"/></DataGridTextColumn.Header></DataGridTextColumn>
                     <DataGridTextColumn Binding="{Binding BaselineAvgReads, StringFormat=N0}" ElementStyle="{StaticResource NumericCell}" Width="95"><DataGridTextColumn.Header><TextBlock Text="Base Reads" FontWeight="Bold"/></DataGridTextColumn.Header></DataGridTextColumn>
                     <DataGridTextColumn Binding="{Binding ReadsDeltaDisplay}" Width="80"><DataGridTextColumn.Header><TextBlock Text="Reads &#x0394;" FontWeight="Bold"/></DataGridTextColumn.Header>
-                        <DataGridTextColumn.ElementStyle><Style TargetType="TextBlock"><Setter Property="HorizontalAlignment" Value="Right"/><Setter Property="Padding" Value="0,0,5,0"/><Setter Property="FontWeight" Value="SemiBold"/><Setter Property="Foreground" Value="{Binding ReadsDeltaBrush}"/></Style></DataGridTextColumn.ElementStyle></DataGridTextColumn>
+                        <DataGridTextColumn.ElementStyle><Style TargetType="TextBlock" BasedOn="{StaticResource DataGridCellText}"><Setter Property="HorizontalAlignment" Value="Right"/><Setter Property="Padding" Value="0,0,5,0"/><Setter Property="FontWeight" Value="SemiBold"/><Setter Property="Foreground" Value="{Binding ReadsDeltaBrush}"/></Style></DataGridTextColumn.ElementStyle></DataGridTextColumn>
                 </DataGrid.Columns>
             </DataGrid>
             <TextBlock x:Name="ProcStatsNoDataMessage" Style="{StaticResource NoDataMessage}"/>
@@ -1646,6 +1648,7 @@
                                 <Style.Triggers>
                                     <DataTrigger Binding="{Binding IsNew}" Value="True"><Setter Property="Foreground" Value="#FF6B6B"/></DataTrigger>
                                     <DataTrigger Binding="{Binding IsGone}" Value="True"><Setter Property="Foreground" Value="#888888"/></DataTrigger>
+                                    <DataTrigger Binding="{Binding IsSelected, RelativeSource={RelativeSource AncestorType=DataGridRow, AncestorLevel=1}, FallbackValue=False}" Value="True"><Setter Property="Foreground" Value="{DynamicResource GridSelectionForegroundBrush}"/></DataTrigger>
                                 </Style.Triggers>
                             </Style>
                         </DataGridTextColumn.ElementStyle>
@@ -1654,19 +1657,19 @@
                     <DataGridTextColumn Binding="{Binding ExecutionCount, StringFormat=N0}" ElementStyle="{StaticResource NumericCell}" Width="90"><DataGridTextColumn.Header><TextBlock Text="Executions" FontWeight="Bold"/></DataGridTextColumn.Header></DataGridTextColumn>
                     <DataGridTextColumn Binding="{Binding BaselineExecutionCount, StringFormat=N0}" ElementStyle="{StaticResource NumericCell}" Width="100"><DataGridTextColumn.Header><TextBlock Text="Base Execs" FontWeight="Bold"/></DataGridTextColumn.Header></DataGridTextColumn>
                     <DataGridTextColumn Binding="{Binding ExecutionDeltaDisplay}" Width="80"><DataGridTextColumn.Header><TextBlock Text="Exec &#x0394;" FontWeight="Bold"/></DataGridTextColumn.Header>
-                        <DataGridTextColumn.ElementStyle><Style TargetType="TextBlock"><Setter Property="HorizontalAlignment" Value="Right"/><Setter Property="Padding" Value="0,0,5,0"/><Setter Property="FontWeight" Value="SemiBold"/><Setter Property="Foreground" Value="{Binding ExecutionDeltaBrush}"/></Style></DataGridTextColumn.ElementStyle></DataGridTextColumn>
+                        <DataGridTextColumn.ElementStyle><Style TargetType="TextBlock" BasedOn="{StaticResource DataGridCellText}"><Setter Property="HorizontalAlignment" Value="Right"/><Setter Property="Padding" Value="0,0,5,0"/><Setter Property="FontWeight" Value="SemiBold"/><Setter Property="Foreground" Value="{Binding ExecutionDeltaBrush}"/></Style></DataGridTextColumn.ElementStyle></DataGridTextColumn>
                     <DataGridTextColumn Binding="{Binding AvgDurationMs, StringFormat=N2}" ElementStyle="{StaticResource NumericCell}" Width="100"><DataGridTextColumn.Header><TextBlock Text="Avg Dur (ms)" FontWeight="Bold"/></DataGridTextColumn.Header></DataGridTextColumn>
                     <DataGridTextColumn Binding="{Binding BaselineAvgDurationMs, StringFormat=N2}" ElementStyle="{StaticResource NumericCell}" Width="110"><DataGridTextColumn.Header><TextBlock Text="Base Dur (ms)" FontWeight="Bold"/></DataGridTextColumn.Header></DataGridTextColumn>
                     <DataGridTextColumn Binding="{Binding DurationDeltaDisplay}" Width="80"><DataGridTextColumn.Header><TextBlock Text="Dur &#x0394;" FontWeight="Bold"/></DataGridTextColumn.Header>
-                        <DataGridTextColumn.ElementStyle><Style TargetType="TextBlock"><Setter Property="HorizontalAlignment" Value="Right"/><Setter Property="Padding" Value="0,0,5,0"/><Setter Property="FontWeight" Value="SemiBold"/><Setter Property="Foreground" Value="{Binding DurationDeltaBrush}"/></Style></DataGridTextColumn.ElementStyle></DataGridTextColumn>
+                        <DataGridTextColumn.ElementStyle><Style TargetType="TextBlock" BasedOn="{StaticResource DataGridCellText}"><Setter Property="HorizontalAlignment" Value="Right"/><Setter Property="Padding" Value="0,0,5,0"/><Setter Property="FontWeight" Value="SemiBold"/><Setter Property="Foreground" Value="{Binding DurationDeltaBrush}"/></Style></DataGridTextColumn.ElementStyle></DataGridTextColumn>
                     <DataGridTextColumn Binding="{Binding AvgCpuMs, StringFormat=N2}" ElementStyle="{StaticResource NumericCell}" Width="95"><DataGridTextColumn.Header><TextBlock Text="Avg CPU (ms)" FontWeight="Bold"/></DataGridTextColumn.Header></DataGridTextColumn>
                     <DataGridTextColumn Binding="{Binding BaselineAvgCpuMs, StringFormat=N2}" ElementStyle="{StaticResource NumericCell}" Width="110"><DataGridTextColumn.Header><TextBlock Text="Base CPU (ms)" FontWeight="Bold"/></DataGridTextColumn.Header></DataGridTextColumn>
                     <DataGridTextColumn Binding="{Binding CpuDeltaDisplay}" Width="80"><DataGridTextColumn.Header><TextBlock Text="CPU &#x0394;" FontWeight="Bold"/></DataGridTextColumn.Header>
-                        <DataGridTextColumn.ElementStyle><Style TargetType="TextBlock"><Setter Property="HorizontalAlignment" Value="Right"/><Setter Property="Padding" Value="0,0,5,0"/><Setter Property="FontWeight" Value="SemiBold"/><Setter Property="Foreground" Value="{Binding CpuDeltaBrush}"/></Style></DataGridTextColumn.ElementStyle></DataGridTextColumn>
+                        <DataGridTextColumn.ElementStyle><Style TargetType="TextBlock" BasedOn="{StaticResource DataGridCellText}"><Setter Property="HorizontalAlignment" Value="Right"/><Setter Property="Padding" Value="0,0,5,0"/><Setter Property="FontWeight" Value="SemiBold"/><Setter Property="Foreground" Value="{Binding CpuDeltaBrush}"/></Style></DataGridTextColumn.ElementStyle></DataGridTextColumn>
                     <DataGridTextColumn Binding="{Binding AvgReads, StringFormat=N0}" ElementStyle="{StaticResource NumericCell}" Width="85"><DataGridTextColumn.Header><TextBlock Text="Avg Reads" FontWeight="Bold"/></DataGridTextColumn.Header></DataGridTextColumn>
                     <DataGridTextColumn Binding="{Binding BaselineAvgReads, StringFormat=N0}" ElementStyle="{StaticResource NumericCell}" Width="95"><DataGridTextColumn.Header><TextBlock Text="Base Reads" FontWeight="Bold"/></DataGridTextColumn.Header></DataGridTextColumn>
                     <DataGridTextColumn Binding="{Binding ReadsDeltaDisplay}" Width="80"><DataGridTextColumn.Header><TextBlock Text="Reads &#x0394;" FontWeight="Bold"/></DataGridTextColumn.Header>
-                        <DataGridTextColumn.ElementStyle><Style TargetType="TextBlock"><Setter Property="HorizontalAlignment" Value="Right"/><Setter Property="Padding" Value="0,0,5,0"/><Setter Property="FontWeight" Value="SemiBold"/><Setter Property="Foreground" Value="{Binding ReadsDeltaBrush}"/></Style></DataGridTextColumn.ElementStyle></DataGridTextColumn>
+                        <DataGridTextColumn.ElementStyle><Style TargetType="TextBlock" BasedOn="{StaticResource DataGridCellText}"><Setter Property="HorizontalAlignment" Value="Right"/><Setter Property="Padding" Value="0,0,5,0"/><Setter Property="FontWeight" Value="SemiBold"/><Setter Property="Foreground" Value="{Binding ReadsDeltaBrush}"/></Style></DataGridTextColumn.ElementStyle></DataGridTextColumn>
                     <DataGridTextColumn Binding="{Binding QueryHash}" Width="140"><DataGridTextColumn.Header><TextBlock Text="Query Hash" FontWeight="Bold"/></DataGridTextColumn.Header></DataGridTextColumn>
                     <DataGridTemplateColumn Width="500"><DataGridTemplateColumn.Header><TextBlock Text="Query Text" FontWeight="Bold"/></DataGridTemplateColumn.Header>
                         <DataGridTemplateColumn.CellTemplate><DataTemplate><TextBlock Text="{Binding QueryText}" TextWrapping="Wrap" MaxHeight="90" Margin="5,2" ToolTip="{Binding QueryText}"/></DataTemplate></DataGridTemplateColumn.CellTemplate></DataGridTemplateColumn>
diff --git a/Dashboard/Themes/CoolBreezeTheme.xaml b/Dashboard/Themes/CoolBreezeTheme.xaml
index 36437cbc..a40c3af5 100644
--- a/Dashboard/Themes/CoolBreezeTheme.xaml
+++ b/Dashboard/Themes/CoolBreezeTheme.xaml
@@ -626,7 +626,7 @@
                     <ControlTemplate.Triggers>
                         <Trigger Property="IsSelected" Value="True">
                             <Setter TargetName="border" Property="Background" Value="{StaticResource AccentBrush}"/>
-                            <Setter Property="Foreground" Value="#EEF4FA"/>
+                            <Setter Property="Foreground" Value="#FFFFFF"/>
                         </Trigger>
                         <Trigger Property="IsMouseOver" Value="True">
                             <Setter TargetName="border" Property="Background" Value="{StaticResource BackgroundLighterBrush}"/>
@@ -678,6 +678,31 @@
         </Setter>
     </Style>
 
+    <!-- ============================================ -->
+    <!-- DataGrid Selection Colors                    -->
+    <!-- ============================================ -->
+    <!-- Foreground to use on selected rows (white text on the darker accent background) -->
+    <SolidColorBrush x:Key="GridSelectionForegroundBrush" Color="#FFFFFF"/>
+
+    <!-- Override WPF system selection brushes so all controls (DataGrid, ListBox, etc.)
+         use the theme accent and the matching readable text color. -->
+    <SolidColorBrush x:Key="{x:Static SystemColors.HighlightBrushKey}"                    Color="{StaticResource AccentColor}"/>
+    <SolidColorBrush x:Key="{x:Static SystemColors.HighlightTextBrushKey}"                Color="#FFFFFF"/>
+    <SolidColorBrush x:Key="{x:Static SystemColors.InactiveSelectionHighlightBrushKey}"   Color="{StaticResource AccentColor}"/>
+    <SolidColorBrush x:Key="{x:Static SystemColors.InactiveSelectionHighlightTextBrushKey}" Color="#FFFFFF"/>
+
+    <!-- Named base style for DataGridTextColumn ElementStyles that must set an explicit
+         Foreground.  BasedOn this style; keep the unselected Foreground setter in the
+         derived style and let this base trigger override it during row selection. -->
+    <Style x:Key="DataGridCellText" TargetType="TextBlock">
+        <Setter Property="Foreground" Value="{DynamicResource ForegroundBrush}"/>
+        <Style.Triggers>
+            <DataTrigger Binding="{Binding IsSelected, RelativeSource={RelativeSource AncestorType=DataGridRow, AncestorLevel=1}, FallbackValue=False}" Value="True">
+                <Setter Property="Foreground" Value="{DynamicResource GridSelectionForegroundBrush}"/>
+            </DataTrigger>
+        </Style.Triggers>
+    </Style>
+
     <!-- ============================================ -->
     <!-- DataGrid Style                               -->
     <!-- ============================================ -->
@@ -785,7 +810,7 @@
     </Style>
 
     <!-- Right-aligned text style for numeric DataGrid columns -->
-    <Style x:Key="NumericCell" TargetType="TextBlock" BasedOn="{StaticResource {x:Type TextBlock}}">
+    <Style x:Key="NumericCell" TargetType="TextBlock" BasedOn="{StaticResource DataGridCellText}">
         <Setter Property="TextAlignment" Value="Right"/>
     </Style>
 
@@ -807,7 +832,7 @@
         <Style.Triggers>
             <Trigger Property="IsSelected" Value="True">
                 <Setter Property="Background" Value="{StaticResource AccentBrush}"/>
-                <Setter Property="Foreground" Value="#EEF4FA"/>
+                <Setter Property="Foreground" Value="#FFFFFF"/>
             </Trigger>
         </Style.Triggers>
     </Style>
@@ -817,6 +842,7 @@
         <Style.Triggers>
             <Trigger Property="IsSelected" Value="True">
                 <Setter Property="Background" Value="{StaticResource AccentBrush}"/>
+                <Setter Property="Foreground" Value="{StaticResource GridSelectionForegroundBrush}"/>
             </Trigger>
             <Trigger Property="IsMouseOver" Value="True">
                 <Setter Property="Background" Value="{StaticResource BackgroundLighterBrush}"/>
@@ -1305,6 +1331,21 @@
     <SolidColorBrush x:Key="SlicerLabelBrush" Color="#5A7A94"/>
     <SolidColorBrush x:Key="SlicerToggleBrush" Color="#364D61"/>
 
+    <!-- ============================================ -->
+    <!-- Plan Viewer Resources                        -->
+    <!-- ============================================ -->
+    <SolidColorBrush x:Key="PlanTooltipBgBrush" Color="{StaticResource BackgroundLightColor}"/>
+    <SolidColorBrush x:Key="PlanTooltipBorderBrush" Color="{StaticResource BorderColor}"/>
+    <SolidColorBrush x:Key="PlanPanelTextBrush" Color="{StaticResource ForegroundColor}"/>
+    <SolidColorBrush x:Key="PlanPanelMutedBrush" Color="{StaticResource ForegroundMutedColor}"/>
+    <SolidColorBrush x:Key="PlanSectionHeaderBrush" Color="{StaticResource AccentPressedColor}"/>
+    <SolidColorBrush x:Key="PlanPropSeparatorBrush" Color="{StaticResource BorderColor}"/>
+    <SolidColorBrush x:Key="PlanMissingIndexBgBrush" Color="#FFF3C8"/>
+    <SolidColorBrush x:Key="PlanMissingIndexBorderBrush" Color="#EEB800"/>
+    <SolidColorBrush x:Key="PlanMissingIndexHeaderBrush" Color="#BF4700"/>
+    <SolidColorBrush x:Key="PlanWaitStatsBgBrush" Color="#D5E9F5"/>
+    <SolidColorBrush x:Key="PlanWaitStatsHeaderBrush" Color="#0D47A1"/>
+
 </ResourceDictionary>
 
 
diff --git a/Dashboard/Themes/DarkTheme.xaml b/Dashboard/Themes/DarkTheme.xaml
index 20abf9bb..6f98ba5b 100644
--- a/Dashboard/Themes/DarkTheme.xaml
+++ b/Dashboard/Themes/DarkTheme.xaml
@@ -677,6 +677,31 @@
         </Setter>
     </Style>
 
+    <!-- ============================================ -->
+    <!-- DataGrid Selection Colors                    -->
+    <!-- ============================================ -->
+    <!-- Foreground to use on selected rows (light text on the blue accent background) -->
+    <SolidColorBrush x:Key="GridSelectionForegroundBrush" Color="#E4E6EB"/>
+
+    <!-- Override WPF system selection brushes so all controls (DataGrid, ListBox, etc.)
+         use the theme accent and the matching readable text color. -->
+    <SolidColorBrush x:Key="{x:Static SystemColors.HighlightBrushKey}"                    Color="{StaticResource AccentColor}"/>
+    <SolidColorBrush x:Key="{x:Static SystemColors.HighlightTextBrushKey}"                Color="#E4E6EB"/>
+    <SolidColorBrush x:Key="{x:Static SystemColors.InactiveSelectionHighlightBrushKey}"   Color="{StaticResource AccentColor}"/>
+    <SolidColorBrush x:Key="{x:Static SystemColors.InactiveSelectionHighlightTextBrushKey}" Color="#E4E6EB"/>
+
+    <!-- Named base style for DataGridTextColumn ElementStyles that must set an explicit
+         Foreground.  BasedOn this style; keep the unselected Foreground setter in the
+         derived style and let this base trigger override it during row selection. -->
+    <Style x:Key="DataGridCellText" TargetType="TextBlock">
+        <Setter Property="Foreground" Value="{DynamicResource ForegroundBrush}"/>
+        <Style.Triggers>
+            <DataTrigger Binding="{Binding IsSelected, RelativeSource={RelativeSource AncestorType=DataGridRow, AncestorLevel=1}, FallbackValue=False}" Value="True">
+                <Setter Property="Foreground" Value="{DynamicResource GridSelectionForegroundBrush}"/>
+            </DataTrigger>
+        </Style.Triggers>
+    </Style>
+
     <!-- ============================================ -->
     <!-- DataGrid Style                               -->
     <!-- ============================================ -->
@@ -784,7 +809,7 @@
     </Style>
 
     <!-- Right-aligned text style for numeric DataGrid columns -->
-    <Style x:Key="NumericCell" TargetType="TextBlock" BasedOn="{StaticResource {x:Type TextBlock}}">
+    <Style x:Key="NumericCell" TargetType="TextBlock" BasedOn="{StaticResource DataGridCellText}">
         <Setter Property="TextAlignment" Value="Right"/>
     </Style>
 
@@ -816,6 +841,7 @@
         <Style.Triggers>
             <Trigger Property="IsSelected" Value="True">
                 <Setter Property="Background" Value="{StaticResource AccentBrush}"/>
+                <Setter Property="Foreground" Value="{StaticResource GridSelectionForegroundBrush}"/>
             </Trigger>
             <Trigger Property="IsMouseOver" Value="True">
                 <Setter Property="Background" Value="{StaticResource BackgroundLighterBrush}"/>
@@ -1304,4 +1330,19 @@
     <SolidColorBrush x:Key="SlicerLabelBrush" Color="#E4E6EB"/>
     <SolidColorBrush x:Key="SlicerToggleBrush" Color="#E4E6EB"/>
 
+    <!-- ============================================ -->
+    <!-- Plan Viewer Resources                        -->
+    <!-- ============================================ -->
+    <SolidColorBrush x:Key="PlanTooltipBgBrush" Color="#1A1D23"/>
+    <SolidColorBrush x:Key="PlanTooltipBorderBrush" Color="#3A3D45"/>
+    <SolidColorBrush x:Key="PlanPanelTextBrush" Color="#E4E6EB"/>
+    <SolidColorBrush x:Key="PlanPanelMutedBrush" Color="#E4E6EB"/>
+    <SolidColorBrush x:Key="PlanSectionHeaderBrush" Color="#4FA3FF"/>
+    <SolidColorBrush x:Key="PlanPropSeparatorBrush" Color="#2A2D35"/>
+    <SolidColorBrush x:Key="PlanMissingIndexBgBrush" Color="#3D2A0E"/>
+    <SolidColorBrush x:Key="PlanMissingIndexBorderBrush" Color="#7A5A1E"/>
+    <SolidColorBrush x:Key="PlanMissingIndexHeaderBrush" Color="#FFB347"/>
+    <SolidColorBrush x:Key="PlanWaitStatsBgBrush" Color="#1A2A3D"/>
+    <SolidColorBrush x:Key="PlanWaitStatsHeaderBrush" Color="#4FA3FF"/>
+
 </ResourceDictionary>
diff --git a/Dashboard/Themes/LightTheme.xaml b/Dashboard/Themes/LightTheme.xaml
index 4e22f4f3..2bee5d50 100644
--- a/Dashboard/Themes/LightTheme.xaml
+++ b/Dashboard/Themes/LightTheme.xaml
@@ -626,7 +626,7 @@
                     <ControlTemplate.Triggers>
                         <Trigger Property="IsSelected" Value="True">
                             <Setter TargetName="border" Property="Background" Value="{StaticResource AccentBrush}"/>
-                            <Setter Property="Foreground" Value="#E4E6EB"/>
+                            <Setter Property="Foreground" Value="#1A1D23"/>
                         </Trigger>
                         <Trigger Property="IsMouseOver" Value="True">
                             <Setter TargetName="border" Property="Background" Value="{StaticResource BackgroundLighterBrush}"/>
@@ -678,6 +678,31 @@
         </Setter>
     </Style>
 
+    <!-- ============================================ -->
+    <!-- DataGrid Selection Colors                    -->
+    <!-- ============================================ -->
+    <!-- Foreground to use on selected rows (dark text on the light accent background) -->
+    <SolidColorBrush x:Key="GridSelectionForegroundBrush" Color="#1A1D23"/>
+
+    <!-- Override WPF system selection brushes so all controls (DataGrid, ListBox, etc.)
+         use the theme accent and the matching readable text color. -->
+    <SolidColorBrush x:Key="{x:Static SystemColors.HighlightBrushKey}"                    Color="{StaticResource AccentColor}"/>
+    <SolidColorBrush x:Key="{x:Static SystemColors.HighlightTextBrushKey}"                Color="#1A1D23"/>
+    <SolidColorBrush x:Key="{x:Static SystemColors.InactiveSelectionHighlightBrushKey}"   Color="{StaticResource AccentColor}"/>
+    <SolidColorBrush x:Key="{x:Static SystemColors.InactiveSelectionHighlightTextBrushKey}" Color="#1A1D23"/>
+
+    <!-- Named base style for DataGridTextColumn ElementStyles that must set an explicit
+         Foreground.  BasedOn this style; keep the unselected Foreground setter in the
+         derived style and let this base trigger override it during row selection. -->
+    <Style x:Key="DataGridCellText" TargetType="TextBlock">
+        <Setter Property="Foreground" Value="{DynamicResource ForegroundBrush}"/>
+        <Style.Triggers>
+            <DataTrigger Binding="{Binding IsSelected, RelativeSource={RelativeSource AncestorType=DataGridRow, AncestorLevel=1}, FallbackValue=False}" Value="True">
+                <Setter Property="Foreground" Value="{DynamicResource GridSelectionForegroundBrush}"/>
+            </DataTrigger>
+        </Style.Triggers>
+    </Style>
+
     <!-- ============================================ -->
     <!-- DataGrid Style                               -->
     <!-- ============================================ -->
@@ -785,7 +810,7 @@
     </Style>
 
     <!-- Right-aligned text style for numeric DataGrid columns -->
-    <Style x:Key="NumericCell" TargetType="TextBlock" BasedOn="{StaticResource {x:Type TextBlock}}">
+    <Style x:Key="NumericCell" TargetType="TextBlock" BasedOn="{StaticResource DataGridCellText}">
         <Setter Property="TextAlignment" Value="Right"/>
     </Style>
 
@@ -807,7 +832,7 @@
         <Style.Triggers>
             <Trigger Property="IsSelected" Value="True">
                 <Setter Property="Background" Value="{StaticResource AccentBrush}"/>
-                <Setter Property="Foreground" Value="#E4E6EB"/>
+                <Setter Property="Foreground" Value="#1A1D23"/>
             </Trigger>
         </Style.Triggers>
     </Style>
@@ -817,6 +842,7 @@
         <Style.Triggers>
             <Trigger Property="IsSelected" Value="True">
                 <Setter Property="Background" Value="{StaticResource AccentBrush}"/>
+                <Setter Property="Foreground" Value="{StaticResource GridSelectionForegroundBrush}"/>
             </Trigger>
             <Trigger Property="IsMouseOver" Value="True">
                 <Setter Property="Background" Value="{StaticResource BackgroundLighterBrush}"/>
@@ -1305,4 +1331,19 @@
     <SolidColorBrush x:Key="SlicerLabelBrush" Color="#718096"/>
     <SolidColorBrush x:Key="SlicerToggleBrush" Color="#4A5568"/>
 
+    <!-- ============================================ -->
+    <!-- Plan Viewer Resources                        -->
+    <!-- ============================================ -->
+    <SolidColorBrush x:Key="PlanTooltipBgBrush" Color="#FFFFFF"/>
+    <SolidColorBrush x:Key="PlanTooltipBorderBrush" Color="{StaticResource BorderColor}"/>
+    <SolidColorBrush x:Key="PlanPanelTextBrush" Color="{StaticResource ForegroundColor}"/>
+    <SolidColorBrush x:Key="PlanPanelMutedBrush" Color="{StaticResource ForegroundMutedColor}"/>
+    <SolidColorBrush x:Key="PlanSectionHeaderBrush" Color="{StaticResource AccentPressedColor}"/>
+    <SolidColorBrush x:Key="PlanPropSeparatorBrush" Color="{StaticResource BorderColor}"/>
+    <SolidColorBrush x:Key="PlanMissingIndexBgBrush" Color="#FFF8E1"/>
+    <SolidColorBrush x:Key="PlanMissingIndexBorderBrush" Color="#FFD54F"/>
+    <SolidColorBrush x:Key="PlanMissingIndexHeaderBrush" Color="#E65100"/>
+    <SolidColorBrush x:Key="PlanWaitStatsBgBrush" Color="#E3F2FD"/>
+    <SolidColorBrush x:Key="PlanWaitStatsHeaderBrush" Color="#1565C0"/>
+
 </ResourceDictionary>

From 6ded45bf5910610e091b5a7ecd47e9cd20f035a6 Mon Sep 17 00:00:00 2001
From: ClaudioESSilva <claudiosil100@gmail.com>
Date: Fri, 24 Apr 2026 14:39:09 +0100
Subject: [PATCH 34/49] fixes #889 on Lite

---
 Lite/Controls/FinOpsTab.xaml            |  6 ++
 Lite/Controls/PlanViewerControl.xaml    | 10 +--
 Lite/Controls/PlanViewerControl.xaml.cs | 85 ++++++++++++++++++-------
 Lite/Themes/CoolBreezeTheme.xaml        | 42 +++++++++++-
 Lite/Themes/DarkTheme.xaml              | 40 +++++++++++-
 Lite/Themes/LightTheme.xaml             | 42 +++++++++++-
 6 files changed, 191 insertions(+), 34 deletions(-)

diff --git a/Lite/Controls/FinOpsTab.xaml b/Lite/Controls/FinOpsTab.xaml
index c841008a..27c07ff4 100644
--- a/Lite/Controls/FinOpsTab.xaml
+++ b/Lite/Controls/FinOpsTab.xaml
@@ -97,6 +97,9 @@
                                         <DataTrigger Binding="{Binding Severity}" Value="Low">
                                             <Setter Property="Foreground" Value="#27AE60"/>
                                         </DataTrigger>
+                                        <DataTrigger Binding="{Binding IsSelected, RelativeSource={RelativeSource AncestorType=DataGridRow, AncestorLevel=1}, FallbackValue=False}" Value="True">
+                                            <Setter Property="Foreground" Value="{DynamicResource GridSelectionForegroundBrush}"/>
+                                        </DataTrigger>
                                     </Style.Triggers>
                                 </Style>
                             </DataGridTextColumn.ElementStyle>
@@ -375,6 +378,9 @@
                                                 <Setter Property="Foreground" Value="#E74C3C"/>
                                                 <Setter Property="FontWeight" Value="SemiBold"/>
                                             </DataTrigger>
+                                            <DataTrigger Binding="{Binding IsSelected, RelativeSource={RelativeSource AncestorType=DataGridRow, AncestorLevel=1}, FallbackValue=False}" Value="True">
+                                                <Setter Property="Foreground" Value="{DynamicResource GridSelectionForegroundBrush}"/>
+                                            </DataTrigger>
                                         </Style.Triggers>
                                     </Style>
                                 </DataGridTextColumn.ElementStyle>
diff --git a/Lite/Controls/PlanViewerControl.xaml b/Lite/Controls/PlanViewerControl.xaml
index 8a752579..aa44384f 100644
--- a/Lite/Controls/PlanViewerControl.xaml
+++ b/Lite/Controls/PlanViewerControl.xaml
@@ -80,15 +80,15 @@
 
                     <!-- Missing Indexes (center) -->
                     <Border Grid.Column="1" Padding="10,4,10,8"
-                            Background="#3D2A0E"
-                            BorderBrush="#7A5A1E" BorderThickness="0,0,1,0">
+                            Background="{DynamicResource PlanMissingIndexBgBrush}"
+                            BorderBrush="{DynamicResource PlanMissingIndexBorderBrush}" BorderThickness="0,0,1,0">
                         <ScrollViewer VerticalScrollBarVisibility="Auto"
                                       HorizontalScrollBarVisibility="Disabled">
                             <StackPanel>
                                 <TextBlock x:Name="MissingIndexHeader"
                                            Text="Missing Index Suggestions"
                                            FontSize="13"
-                                           FontWeight="SemiBold" Foreground="#FFB347"
+                                           FontWeight="SemiBold" Foreground="{DynamicResource PlanMissingIndexHeaderBrush}"
                                            Margin="0,0,0,6"/>
                                 <StackPanel x:Name="MissingIndexContent"/>
                                 <TextBlock x:Name="MissingIndexEmpty"
@@ -101,14 +101,14 @@
 
                     <!-- Wait Stats (right, fills remaining space) -->
                     <Border Grid.Column="2" Padding="10,4,10,8"
-                            Background="#1A2A3D">
+                            Background="{DynamicResource PlanWaitStatsBgBrush}">
                         <ScrollViewer VerticalScrollBarVisibility="Auto"
                                       HorizontalScrollBarVisibility="Disabled">
                             <StackPanel>
                                 <TextBlock x:Name="WaitStatsHeader"
                                            Text="Wait Stats"
                                            FontSize="13"
-                                           FontWeight="SemiBold" Foreground="#4FA3FF"
+                                           FontWeight="SemiBold" Foreground="{DynamicResource PlanWaitStatsHeaderBrush}"
                                            Margin="0,0,0,6"/>
                                 <StackPanel x:Name="WaitStatsContent"/>
                                 <TextBlock x:Name="WaitStatsEmpty"
diff --git a/Lite/Controls/PlanViewerControl.xaml.cs b/Lite/Controls/PlanViewerControl.xaml.cs
index fb4af2e5..4af6ba71 100644
--- a/Lite/Controls/PlanViewerControl.xaml.cs
+++ b/Lite/Controls/PlanViewerControl.xaml.cs
@@ -31,18 +31,27 @@ public partial class PlanViewerControl : UserControl
     private Border? _selectedNodeBorder;
     private Brush? _selectedNodeOriginalBorder;
     private Thickness _selectedNodeOriginalThickness;
+    private PlanNode? _selectedNode;
 
-    // Brushes
+    // Brushes — accent/neutral tones that suit every theme
     private static readonly SolidColorBrush SelectionBrush = new(Color.FromRgb(0x4F, 0xA3, 0xFF));
-    private static readonly SolidColorBrush TooltipBgBrush = new(Color.FromRgb(0x1A, 0x1D, 0x23));
-    private static readonly SolidColorBrush TooltipBorderBrush = new(Color.FromRgb(0x3A, 0x3D, 0x45));
-    private static readonly SolidColorBrush TooltipFgBrush = new(Color.FromRgb(0xE4, 0xE6, 0xEB));
-    private static readonly SolidColorBrush MutedBrush = new(Color.FromRgb(0xE4, 0xE6, 0xEB));
     private static readonly SolidColorBrush EdgeBrush = new(Color.FromRgb(0x6B, 0x72, 0x80));
-    private static readonly SolidColorBrush SectionHeaderBrush = new(Color.FromRgb(0x4F, 0xA3, 0xFF));
-    private static readonly SolidColorBrush PropSeparatorBrush = new(Color.FromRgb(0x2A, 0x2D, 0x35));
     private static readonly SolidColorBrush OrangeBrush = new(Color.FromRgb(0xFF, 0xB3, 0x47));
 
+    // Theme-aware brushes resolved at call time from Application.Resources
+    private SolidColorBrush TooltipBgBrush =>
+        (TryFindResource("PlanTooltipBgBrush") as SolidColorBrush) ?? new SolidColorBrush(Color.FromRgb(0x1A, 0x1D, 0x23));
+    private SolidColorBrush TooltipBorderBrush =>
+        (TryFindResource("PlanTooltipBorderBrush") as SolidColorBrush) ?? new SolidColorBrush(Color.FromRgb(0x3A, 0x3D, 0x45));
+    private SolidColorBrush TooltipFgBrush =>
+        (TryFindResource("PlanPanelTextBrush") as SolidColorBrush) ?? new SolidColorBrush(Color.FromRgb(0xE4, 0xE6, 0xEB));
+    private SolidColorBrush MutedBrush =>
+        (TryFindResource("PlanPanelMutedBrush") as SolidColorBrush) ?? new SolidColorBrush(Color.FromRgb(0xE4, 0xE6, 0xEB));
+    private SolidColorBrush SectionHeaderBrush =>
+        (TryFindResource("PlanSectionHeaderBrush") as SolidColorBrush) ?? new SolidColorBrush(Color.FromRgb(0x4F, 0xA3, 0xFF));
+    private SolidColorBrush PropSeparatorBrush =>
+        (TryFindResource("PlanPropSeparatorBrush") as SolidColorBrush) ?? new SolidColorBrush(Color.FromRgb(0x2A, 0x2D, 0x35));
+
     // Current property section for collapsible groups
     private StackPanel? _currentPropertySection;
 
@@ -55,6 +64,28 @@ public partial class PlanViewerControl : UserControl
     public PlanViewerControl()
     {
         InitializeComponent();
+        Helpers.ThemeManager.ThemeChanged += OnThemeChanged;
+        Unloaded += (_, _) => Helpers.ThemeManager.ThemeChanged -= OnThemeChanged;
+    }
+
+    private void OnThemeChanged(string _)
+    {
+        if (_currentStatement == null) return;
+
+        var nodeToRestore = _selectedNode;
+        RenderStatement(_currentStatement);
+
+        if (nodeToRestore == null) return;
+
+        // Find the re-created border for the previously selected node and reopen properties
+        foreach (var child in PlanCanvas.Children)
+        {
+            if (child is Border b && b.Tag == nodeToRestore)
+            {
+                SelectNode(b, nodeToRestore);
+                break;
+            }
+        }
     }
 
     public void LoadPlan(string planXml, string label, string? queryText = null)
@@ -498,6 +529,10 @@ private Border BuildEdgeTooltipContent(PlanNode child)
         grid.ColumnDefinitions.Add(new ColumnDefinition { Width = new GridLength(1, GridUnitType.Star) });
         grid.ColumnDefinitions.Add(new ColumnDefinition { Width = GridLength.Auto });
         int row = 0;
+        var bgBrush = TooltipBgBrush;
+        var borderBrush = TooltipBorderBrush;
+        var mutedBrush = MutedBrush;
+        var fgBrush = TooltipFgBrush;
 
         void AddRow(string label, string value)
         {
@@ -505,14 +540,14 @@ void AddRow(string label, string value)
             var lbl = new TextBlock
             {
                 Text = label,
-                Foreground = new SolidColorBrush(Color.FromRgb(0xE0, 0xE0, 0xE0)),
+                Foreground = mutedBrush,
                 FontSize = 12,
                 Margin = new Thickness(0, 1, 12, 1)
             };
             var val = new TextBlock
             {
                 Text = value,
-                Foreground = new SolidColorBrush(Colors.White),
+                Foreground = fgBrush,
                 FontSize = 12,
                 FontWeight = FontWeights.SemiBold,
                 HorizontalAlignment = HorizontalAlignment.Right,
@@ -545,8 +580,8 @@ void AddRow(string label, string value)
 
         return new Border
         {
-            Background = new SolidColorBrush(Color.FromRgb(0x1E, 0x1E, 0x2E)),
-            BorderBrush = new SolidColorBrush(Color.FromRgb(0x3A, 0x3A, 0x5A)),
+            Background = bgBrush,
+            BorderBrush = borderBrush,
             BorderThickness = new Thickness(1),
             Padding = new Thickness(10, 6, 10, 6),
             CornerRadius = new CornerRadius(4),
@@ -588,6 +623,7 @@ private void SelectNode(Border border, PlanNode node)
         _selectedNodeOriginalBorder = border.BorderBrush;
         _selectedNodeOriginalThickness = border.BorderThickness;
         _selectedNodeBorder = border;
+        _selectedNode = node;
         border.BorderBrush = SelectionBrush;
         border.BorderThickness = new Thickness(2);
 
@@ -1521,7 +1557,7 @@ private void AddPropertySection(string title)
             Margin = new Thickness(0, 2, 0, 0),
             Padding = new Thickness(0),
             Foreground = SectionHeaderBrush,
-            Background = new SolidColorBrush(Color.FromArgb(0x18, 0x4F, 0xA3, 0xFF)),
+            Background = (TryFindResource("BackgroundLighterBrush") as SolidColorBrush) ?? new SolidColorBrush(Color.FromArgb(0x18, 0x4F, 0xA3, 0xFF)),
             BorderBrush = PropSeparatorBrush,
             BorderThickness = new Thickness(0, 0, 0, 1)
         };
@@ -1580,6 +1616,7 @@ private void ClosePropertiesPanel()
             _selectedNodeBorder.BorderThickness = _selectedNodeOriginalThickness;
             _selectedNodeBorder = null;
         }
+        _selectedNode = null;
     }
 
     #endregion
@@ -1792,7 +1829,7 @@ private ToolTip BuildNodeTooltip(PlanNode node, List<PlanWarning>? allWarnings =
         return tip;
     }
 
-    private static void AddTooltipSection(StackPanel parent, string title)
+    private void AddTooltipSection(StackPanel parent, string title)
     {
         parent.Children.Add(new TextBlock
         {
@@ -1804,7 +1841,7 @@ private static void AddTooltipSection(StackPanel parent, string title)
         });
     }
 
-    private static void AddTooltipRow(StackPanel parent, string label, string value, bool isCode = false)
+    private void AddTooltipRow(StackPanel parent, string label, string value, bool isCode = false)
     {
         var row = new StackPanel { Orientation = Orientation.Horizontal, Margin = new Thickness(0, 1, 0, 1) };
         row.Children.Add(new TextBlock
@@ -1847,19 +1884,19 @@ private void ShowMissingIndexes(List<MissingIndex> indexes)
                 {
                     Text = mi.Table,
                     FontWeight = FontWeights.SemiBold,
-                    Foreground = new SolidColorBrush((Color)ColorConverter.ConvertFromString("#E4E6EB")),
+                    Foreground = TooltipFgBrush,
                     FontSize = 12
                 });
                 headerRow.Children.Add(new TextBlock
                 {
                     Text = $" \u2014 Impact: ",
-                    Foreground = new SolidColorBrush((Color)ColorConverter.ConvertFromString("#E4E6EB")),
+                    Foreground = MutedBrush,
                     FontSize = 12
                 });
                 headerRow.Children.Add(new TextBlock
                 {
                     Text = $"{mi.Impact:F1}%",
-                    Foreground = new SolidColorBrush((Color)ColorConverter.ConvertFromString("#FFB347")),
+                    Foreground = OrangeBrush,
                     FontSize = 12
                 });
                 itemPanel.Children.Add(headerRow);
@@ -1871,7 +1908,7 @@ private void ShowMissingIndexes(List<MissingIndex> indexes)
                         Text = mi.CreateStatement,
                         FontFamily = new FontFamily("Consolas"),
                         FontSize = 11,
-                        Foreground = new SolidColorBrush((Color)ColorConverter.ConvertFromString("#E4E6EB")),
+                        Foreground = TooltipFgBrush,
                         Background = Brushes.Transparent,
                         BorderThickness = new Thickness(0),
                         IsReadOnly = true,
@@ -1944,7 +1981,7 @@ private void ShowWaitStats(List<WaitStatInfo> waits, bool isActualPlan)
             {
                 Text = w.WaitType,
                 FontSize = 12,
-                Foreground = new SolidColorBrush((Color)ColorConverter.ConvertFromString("#E4E6EB")),
+                Foreground = TooltipFgBrush,
                 VerticalAlignment = VerticalAlignment.Center,
                 Margin = new Thickness(0, 2, 10, 2)
             };
@@ -1970,7 +2007,7 @@ private void ShowWaitStats(List<WaitStatInfo> waits, bool isActualPlan)
             {
                 Text = $"{w.WaitTimeMs:N0}ms ({w.WaitCount:N0} waits)",
                 FontSize = 12,
-                Foreground = new SolidColorBrush((Color)ColorConverter.ConvertFromString("#E4E6EB")),
+                Foreground = TooltipFgBrush,
                 VerticalAlignment = VerticalAlignment.Center,
                 Margin = new Thickness(0, 2, 0, 2)
             };
@@ -2026,8 +2063,8 @@ private void ShowRuntimeSummary(PlanStatement statement)
     {
         RuntimeSummaryContent.Children.Clear();
 
-        var labelColor = "#E4E6EB";
-        var valueColor = "#E4E6EB";
+        var labelBrush = MutedBrush;
+        var valueBrush = TooltipFgBrush;
 
         var grid = new Grid();
         grid.ColumnDefinitions.Add(new ColumnDefinition { Width = GridLength.Auto });
@@ -2042,7 +2079,7 @@ void AddRow(string label, string value)
             {
                 Text = label,
                 FontSize = 11,
-                Foreground = new SolidColorBrush((Color)ColorConverter.ConvertFromString(labelColor)),
+                Foreground = labelBrush,
                 HorizontalAlignment = HorizontalAlignment.Left,
                 Margin = new Thickness(0, 1, 8, 1)
             };
@@ -2054,7 +2091,7 @@ void AddRow(string label, string value)
             {
                 Text = value,
                 FontSize = 11,
-                Foreground = new SolidColorBrush((Color)ColorConverter.ConvertFromString(valueColor)),
+                Foreground = valueBrush,
                 Margin = new Thickness(0, 1, 0, 1)
             };
             Grid.SetRow(valueText, rowIndex);
diff --git a/Lite/Themes/CoolBreezeTheme.xaml b/Lite/Themes/CoolBreezeTheme.xaml
index 010d8a8c..6cefefad 100644
--- a/Lite/Themes/CoolBreezeTheme.xaml
+++ b/Lite/Themes/CoolBreezeTheme.xaml
@@ -735,8 +735,30 @@
         <Setter Property="Background" Value="#9DBFD9"/>
     </Style>
 
+    <!-- Foreground to use on selected rows (white text on the cool-breeze accent background) -->
+    <SolidColorBrush x:Key="GridSelectionForegroundBrush" Color="#FFFFFF"/>
+
+    <!-- Override WPF system selection brushes so all controls (DataGrid, ListBox, etc.)
+         use the theme accent and the matching readable text color. -->
+    <SolidColorBrush x:Key="{x:Static SystemColors.HighlightBrushKey}"                    Color="{StaticResource AccentColor}"/>
+    <SolidColorBrush x:Key="{x:Static SystemColors.HighlightTextBrushKey}"                Color="#FFFFFF"/>
+    <SolidColorBrush x:Key="{x:Static SystemColors.InactiveSelectionHighlightBrushKey}"   Color="{StaticResource AccentColor}"/>
+    <SolidColorBrush x:Key="{x:Static SystemColors.InactiveSelectionHighlightTextBrushKey}" Color="#FFFFFF"/>
+
+    <!-- Named base style for DataGridTextColumn ElementStyles that must set an explicit
+         Foreground.  BasedOn this style; keep the unselected Foreground setter in the
+         derived style and let this base trigger override it during row selection. -->
+    <Style x:Key="DataGridCellText" TargetType="TextBlock">
+        <Setter Property="Foreground" Value="{DynamicResource ForegroundBrush}"/>
+        <Style.Triggers>
+            <DataTrigger Binding="{Binding IsSelected, RelativeSource={RelativeSource AncestorType=DataGridRow, AncestorLevel=1}, FallbackValue=False}" Value="True">
+                <Setter Property="Foreground" Value="{DynamicResource GridSelectionForegroundBrush}"/>
+            </DataTrigger>
+        </Style.Triggers>
+    </Style>
+
     <!-- Right-aligned text style for numeric DataGrid columns -->
-    <Style x:Key="NumericCell" TargetType="TextBlock" BasedOn="{StaticResource {x:Type TextBlock}}">
+    <Style x:Key="NumericCell" TargetType="TextBlock" BasedOn="{StaticResource DataGridCellText}">
         <Setter Property="TextAlignment" Value="Right"/>
     </Style>
 
@@ -758,7 +780,7 @@
         <Style.Triggers>
             <Trigger Property="IsSelected" Value="True">
                 <Setter Property="Background" Value="{StaticResource AccentBrush}"/>
-                <Setter Property="Foreground" Value="#EEF4FA"/>
+                <Setter Property="Foreground" Value="#FFFFFF"/>
             </Trigger>
         </Style.Triggers>
     </Style>
@@ -768,6 +790,7 @@
         <Style.Triggers>
             <Trigger Property="IsSelected" Value="True">
                 <Setter Property="Background" Value="{StaticResource AccentBrush}"/>
+                <Setter Property="Foreground" Value="{StaticResource GridSelectionForegroundBrush}"/>
             </Trigger>
             <Trigger Property="IsMouseOver" Value="True">
                 <Setter Property="Background" Value="{StaticResource BackgroundLighterBrush}"/>
@@ -1242,6 +1265,21 @@
     </Style>
 
 
+    <!-- ============================================ -->
+    <!-- Plan Viewer Resources                        -->
+    <!-- ============================================ -->
+    <SolidColorBrush x:Key="PlanTooltipBgBrush" Color="{StaticResource BackgroundLightColor}"/>
+    <SolidColorBrush x:Key="PlanTooltipBorderBrush" Color="{StaticResource BorderColor}"/>
+    <SolidColorBrush x:Key="PlanPanelTextBrush" Color="{StaticResource ForegroundColor}"/>
+    <SolidColorBrush x:Key="PlanPanelMutedBrush" Color="{StaticResource ForegroundMutedColor}"/>
+    <SolidColorBrush x:Key="PlanSectionHeaderBrush" Color="{StaticResource AccentPressedColor}"/>
+    <SolidColorBrush x:Key="PlanPropSeparatorBrush" Color="{StaticResource BorderColor}"/>
+    <SolidColorBrush x:Key="PlanMissingIndexBgBrush" Color="#FFF3C8"/>
+    <SolidColorBrush x:Key="PlanMissingIndexBorderBrush" Color="#EEB800"/>
+    <SolidColorBrush x:Key="PlanMissingIndexHeaderBrush" Color="#BF4700"/>
+    <SolidColorBrush x:Key="PlanWaitStatsBgBrush" Color="#D5E9F5"/>
+    <SolidColorBrush x:Key="PlanWaitStatsHeaderBrush" Color="#0D47A1"/>
+
 </ResourceDictionary>
 
 
diff --git a/Lite/Themes/DarkTheme.xaml b/Lite/Themes/DarkTheme.xaml
index 869af3de..1702d76a 100644
--- a/Lite/Themes/DarkTheme.xaml
+++ b/Lite/Themes/DarkTheme.xaml
@@ -735,8 +735,30 @@
         <Setter Property="Background" Value="#3D5A80"/>
     </Style>
 
+    <!-- Foreground to use on selected rows (light text on the blue accent background) -->
+    <SolidColorBrush x:Key="GridSelectionForegroundBrush" Color="#E4E6EB"/>
+
+    <!-- Override WPF system selection brushes so all controls (DataGrid, ListBox, etc.)
+         use the theme accent and the matching readable text color. -->
+    <SolidColorBrush x:Key="{x:Static SystemColors.HighlightBrushKey}"                    Color="{StaticResource AccentColor}"/>
+    <SolidColorBrush x:Key="{x:Static SystemColors.HighlightTextBrushKey}"                Color="#E4E6EB"/>
+    <SolidColorBrush x:Key="{x:Static SystemColors.InactiveSelectionHighlightBrushKey}"   Color="{StaticResource AccentColor}"/>
+    <SolidColorBrush x:Key="{x:Static SystemColors.InactiveSelectionHighlightTextBrushKey}" Color="#E4E6EB"/>
+
+    <!-- Named base style for DataGridTextColumn ElementStyles that must set an explicit
+         Foreground.  BasedOn this style; keep the unselected Foreground setter in the
+         derived style and let this base trigger override it during row selection. -->
+    <Style x:Key="DataGridCellText" TargetType="TextBlock">
+        <Setter Property="Foreground" Value="{DynamicResource ForegroundBrush}"/>
+        <Style.Triggers>
+            <DataTrigger Binding="{Binding IsSelected, RelativeSource={RelativeSource AncestorType=DataGridRow, AncestorLevel=1}, FallbackValue=False}" Value="True">
+                <Setter Property="Foreground" Value="{DynamicResource GridSelectionForegroundBrush}"/>
+            </DataTrigger>
+        </Style.Triggers>
+    </Style>
+
     <!-- Right-aligned text style for numeric DataGrid columns -->
-    <Style x:Key="NumericCell" TargetType="TextBlock" BasedOn="{StaticResource {x:Type TextBlock}}">
+    <Style x:Key="NumericCell" TargetType="TextBlock" BasedOn="{StaticResource DataGridCellText}">
         <Setter Property="TextAlignment" Value="Right"/>
     </Style>
 
@@ -768,6 +790,7 @@
         <Style.Triggers>
             <Trigger Property="IsSelected" Value="True">
                 <Setter Property="Background" Value="{StaticResource AccentBrush}"/>
+                <Setter Property="Foreground" Value="{StaticResource GridSelectionForegroundBrush}"/>
             </Trigger>
             <Trigger Property="IsMouseOver" Value="True">
                 <Setter Property="Background" Value="{StaticResource BackgroundLighterBrush}"/>
@@ -1252,4 +1275,19 @@
     <SolidColorBrush x:Key="SlicerLabelBrush" Color="#E4E6EB"/>
     <SolidColorBrush x:Key="SlicerToggleBrush" Color="#E4E6EB"/>
 
+    <!-- ============================================ -->
+    <!-- Plan Viewer Resources                        -->
+    <!-- ============================================ -->
+    <SolidColorBrush x:Key="PlanTooltipBgBrush" Color="#1A1D23"/>
+    <SolidColorBrush x:Key="PlanTooltipBorderBrush" Color="#3A3D45"/>
+    <SolidColorBrush x:Key="PlanPanelTextBrush" Color="#E4E6EB"/>
+    <SolidColorBrush x:Key="PlanPanelMutedBrush" Color="#E4E6EB"/>
+    <SolidColorBrush x:Key="PlanSectionHeaderBrush" Color="#4FA3FF"/>
+    <SolidColorBrush x:Key="PlanPropSeparatorBrush" Color="#2A2D35"/>
+    <SolidColorBrush x:Key="PlanMissingIndexBgBrush" Color="#3D2A0E"/>
+    <SolidColorBrush x:Key="PlanMissingIndexBorderBrush" Color="#7A5A1E"/>
+    <SolidColorBrush x:Key="PlanMissingIndexHeaderBrush" Color="#FFB347"/>
+    <SolidColorBrush x:Key="PlanWaitStatsBgBrush" Color="#1A2A3D"/>
+    <SolidColorBrush x:Key="PlanWaitStatsHeaderBrush" Color="#4FA3FF"/>
+
 </ResourceDictionary>
diff --git a/Lite/Themes/LightTheme.xaml b/Lite/Themes/LightTheme.xaml
index e9908300..ce564069 100644
--- a/Lite/Themes/LightTheme.xaml
+++ b/Lite/Themes/LightTheme.xaml
@@ -735,8 +735,30 @@
         <Setter Property="Background" Value="#BBDEFB"/>
     </Style>
 
+    <!-- Foreground to use on selected rows (dark text on the light accent background) -->
+    <SolidColorBrush x:Key="GridSelectionForegroundBrush" Color="#1A1D23"/>
+
+    <!-- Override WPF system selection brushes so all controls (DataGrid, ListBox, etc.)
+         use the theme accent and the matching readable text color. -->
+    <SolidColorBrush x:Key="{x:Static SystemColors.HighlightBrushKey}"                    Color="{StaticResource AccentColor}"/>
+    <SolidColorBrush x:Key="{x:Static SystemColors.HighlightTextBrushKey}"                Color="#1A1D23"/>
+    <SolidColorBrush x:Key="{x:Static SystemColors.InactiveSelectionHighlightBrushKey}"   Color="{StaticResource AccentColor}"/>
+    <SolidColorBrush x:Key="{x:Static SystemColors.InactiveSelectionHighlightTextBrushKey}" Color="#1A1D23"/>
+
+    <!-- Named base style for DataGridTextColumn ElementStyles that must set an explicit
+         Foreground.  BasedOn this style; keep the unselected Foreground setter in the
+         derived style and let this base trigger override it during row selection. -->
+    <Style x:Key="DataGridCellText" TargetType="TextBlock">
+        <Setter Property="Foreground" Value="{DynamicResource ForegroundBrush}"/>
+        <Style.Triggers>
+            <DataTrigger Binding="{Binding IsSelected, RelativeSource={RelativeSource AncestorType=DataGridRow, AncestorLevel=1}, FallbackValue=False}" Value="True">
+                <Setter Property="Foreground" Value="{DynamicResource GridSelectionForegroundBrush}"/>
+            </DataTrigger>
+        </Style.Triggers>
+    </Style>
+
     <!-- Right-aligned text style for numeric DataGrid columns -->
-    <Style x:Key="NumericCell" TargetType="TextBlock" BasedOn="{StaticResource {x:Type TextBlock}}">
+    <Style x:Key="NumericCell" TargetType="TextBlock" BasedOn="{StaticResource DataGridCellText}">
         <Setter Property="TextAlignment" Value="Right"/>
     </Style>
 
@@ -758,7 +780,7 @@
         <Style.Triggers>
             <Trigger Property="IsSelected" Value="True">
                 <Setter Property="Background" Value="{StaticResource AccentBrush}"/>
-                <Setter Property="Foreground" Value="#E4E6EB"/>
+                <Setter Property="Foreground" Value="#1A1D23"/>
             </Trigger>
         </Style.Triggers>
     </Style>
@@ -768,6 +790,7 @@
         <Style.Triggers>
             <Trigger Property="IsSelected" Value="True">
                 <Setter Property="Background" Value="{StaticResource AccentBrush}"/>
+                <Setter Property="Foreground" Value="{StaticResource GridSelectionForegroundBrush}"/>
             </Trigger>
             <Trigger Property="IsMouseOver" Value="True">
                 <Setter Property="Background" Value="{StaticResource BackgroundLighterBrush}"/>
@@ -1242,4 +1265,19 @@
     </Style>
 
 
+    <!-- ============================================ -->
+    <!-- Plan Viewer Resources                        -->
+    <!-- ============================================ -->
+    <SolidColorBrush x:Key="PlanTooltipBgBrush" Color="#FFFFFF"/>
+    <SolidColorBrush x:Key="PlanTooltipBorderBrush" Color="{StaticResource BorderColor}"/>
+    <SolidColorBrush x:Key="PlanPanelTextBrush" Color="{StaticResource ForegroundColor}"/>
+    <SolidColorBrush x:Key="PlanPanelMutedBrush" Color="{StaticResource ForegroundMutedColor}"/>
+    <SolidColorBrush x:Key="PlanSectionHeaderBrush" Color="{StaticResource AccentPressedColor}"/>
+    <SolidColorBrush x:Key="PlanPropSeparatorBrush" Color="{StaticResource BorderColor}"/>
+    <SolidColorBrush x:Key="PlanMissingIndexBgBrush" Color="#FFF8E1"/>
+    <SolidColorBrush x:Key="PlanMissingIndexBorderBrush" Color="#FFD54F"/>
+    <SolidColorBrush x:Key="PlanMissingIndexHeaderBrush" Color="#E65100"/>
+    <SolidColorBrush x:Key="PlanWaitStatsBgBrush" Color="#E3F2FD"/>
+    <SolidColorBrush x:Key="PlanWaitStatsHeaderBrush" Color="#1565C0"/>
+
 </ResourceDictionary>

From 6c01da9f9a4f66f18327399c35e86393a6cd622d Mon Sep 17 00:00:00 2001
From: Erik Darling <2136037+erikdarlingdata@users.noreply.github.com>
Date: Fri, 24 Apr 2026 10:45:39 -0400
Subject: [PATCH 35/49] Add Off collection preset and re-enable-all behavior
 for named presets (#888) (#891)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

config.apply_collection_preset now accepts a fourth preset, Off, which
sets enabled = 0 across every row in config.collection_schedule without
touching frequencies. The three existing presets (Aggressive, Balanced,
Low-Impact) now also set enabled = 1 on every row before applying their
frequencies, so switching back from Off reliably resumes collection —
including daily/on-load collectors not in the preset list.

Pair with two SQL Agent jobs to compose time-of-day windows (apply
Off at the start of a quiet window, apply a named preset to resume)
without needing a scheduler feature in the collectors themselves.

Heads up: applying a non-Off preset overrides any manual
UPDATE config.collection_schedule SET enabled = 0 on a specific
collector. Documented in the proc header.

Co-authored-by: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
---
 CHANGELOG.md                       |  2 +
 README.md                          |  2 +-
 install/41_schedule_management.sql | 70 +++++++++++++++++++++++-------
 3 files changed, 58 insertions(+), 16 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 0dbc6413..a0b1f540 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -15,6 +15,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 - **Memory Pressure Events in Lite** — the collector, chart, and `get_memory_pressure_events` MCP tool previously only in the Full Edition are now available in Lite ([#865])
 - **Grid auto-scrolling** in Lite and Dashboard ([#843]) — thanks [@ClaudioESSilva](https://github.com/ClaudioESSilva)
+- **`Off` collection preset** — `config.apply_collection_preset @preset_name = N'Off'` disables every collector in one call. Pair it with a second Agent job that applies a non-`Off` preset at the start of your active window to get overnight / quiet-hours scoping without writing scheduler code. Non-`Off` presets now also set `enabled = 1` across the board so the switch reliably resumes collection ([#888])
 
 ### Changed
 
@@ -47,6 +48,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 [#865]: https://github.com/erikdarlingdata/PerformanceMonitor/issues/865
 [#867]: https://github.com/erikdarlingdata/PerformanceMonitor/issues/867
 [#872]: https://github.com/erikdarlingdata/PerformanceMonitor/issues/872
+[#888]: https://github.com/erikdarlingdata/PerformanceMonitor/issues/888
 
 ## [2.7.0] - 2026-04-13
 
diff --git a/README.md b/README.md
index a47b61a1..a3008652 100644
--- a/README.md
+++ b/README.md
@@ -56,7 +56,7 @@ All release binaries are digitally signed via [SignPath](https://signpath.io) 
 
 ## What You Get
 
-🔍 **32 specialized T-SQL collectors** running on configurable schedules with named presets (Aggressive, Balanced, Low-Impact) — wait stats, query performance, blocking chains, deadlock graphs, memory grants, file I/O, tempdb, perfmon counters, FinOps/capacity, and more. Query text and execution plan collection can be disabled per-collector for sensitive environments.
+🔍 **32 specialized T-SQL collectors** running on configurable schedules with named presets (Off, Aggressive, Balanced, Low-Impact) — wait stats, query performance, blocking chains, deadlock graphs, memory grants, file I/O, tempdb, perfmon counters, FinOps/capacity, and more. Query text and execution plan collection can be disabled per-collector for sensitive environments. Switch presets with a pair of SQL Agent jobs to get quiet-hours / overnight windows without writing any code.
 
 🚨 **Real-time alerts** for blocking, deadlocks, and high CPU — system tray notifications, styled HTML emails with full XML attachments, and webhook notifications for external integrations
 
diff --git a/install/41_schedule_management.sql b/install/41_schedule_management.sql
index 46c93b8a..e9944b45 100644
--- a/install/41_schedule_management.sql
+++ b/install/41_schedule_management.sql
@@ -142,10 +142,18 @@ GO
 
 /*
 Apply a named collection preset
-Changes all scheduled collector frequencies in one operation.
-Does not modify enabled/disabled state or daily/on-load collectors.
 
-Valid preset names: Aggressive, Balanced, Low-Impact
+Valid preset names: Off, Aggressive, Balanced, Low-Impact
+
+Off sets enabled = 0 on every row in config.collection_schedule and changes
+nothing else — no frequency edits. The other three set enabled = 1 on every
+row (so switching back from Off reliably reactivates collection) and update
+frequency_minutes for the collectors they list. Daily/on-load collectors
+that aren't in the preset keep their existing frequency.
+
+Heads up: applying a non-Off preset overrides any manual
+UPDATE config.collection_schedule SET enabled = 0 on a specific collector.
+If that matters in your environment, re-disable it after switching presets.
 */
 IF OBJECT_ID(N'config.apply_collection_preset', N'P') IS NULL
 BEGIN
@@ -169,9 +177,33 @@ BEGIN
         @rows_updated bigint = 0;
 
     BEGIN TRY
-        IF @preset_name NOT IN (N'Aggressive', N'Balanced', N'Low-Impact')
+        IF @preset_name NOT IN (N'Off', N'Aggressive', N'Balanced', N'Low-Impact')
         BEGIN
-            RAISERROR(N'Invalid preset name "%s". Valid presets: Aggressive, Balanced, Low-Impact', 16, 1, @preset_name);
+            RAISERROR(N'Invalid preset name "%s". Valid presets: Off, Aggressive, Balanced, Low-Impact', 16, 1, @preset_name);
+            RETURN;
+        END;
+
+        /*
+        Off disables every collector and exits. No frequency table needed.
+        Pair with a second Agent job that applies a non-Off preset at the
+        start of your active window to resume collection.
+        */
+        IF @preset_name = N'Off'
+        BEGIN
+            UPDATE
+                config.collection_schedule
+            SET
+                enabled = 0,
+                modified_date = SYSDATETIME();
+
+            SET @rows_updated = ROWCOUNT_BIG();
+
+            IF @debug = 1
+            BEGIN
+                RAISERROR(N'Applied "Off" preset — %I64d collectors disabled', 0, 1, @rows_updated) WITH NOWAIT;
+            END;
+
+            PRINT 'Applied "Off" collection preset (' + CONVERT(varchar(10), @rows_updated) + ' collectors disabled)';
             RETURN;
         END;
 
@@ -303,20 +335,27 @@ BEGIN
         END;
 
         /*
-        Apply the preset to all matching collectors.
-        Only updates frequency - does not change enabled/disabled state.
-        Skips daily/on-load collectors not in the preset.
+        Re-enable every collector first so a switch from Off → named preset
+        reliably resumes collection, including daily/on-load collectors that
+        aren't in the preset frequency table.
+        */
+        UPDATE
+            config.collection_schedule
+        SET
+            enabled = 1,
+            modified_date = SYSDATETIME()
+        WHERE
+            enabled = 0;
+
+        /*
+        Apply the preset frequencies to the collectors it lists.
+        Daily/on-load collectors not in the preset keep their existing frequency.
         */
         UPDATE
             cs
         SET
             cs.frequency_minutes = p.frequency_minutes,
-            cs.next_run_time =
-                CASE
-                    WHEN cs.enabled = 1
-                    THEN SYSDATETIME()
-                    ELSE cs.next_run_time
-                END,
+            cs.next_run_time = SYSDATETIME(),
             cs.modified_date = SYSDATETIME()
         FROM config.collection_schedule AS cs
         JOIN @preset AS p
@@ -416,11 +455,12 @@ PRINT '';
 PRINT 'Available procedures:';
 PRINT '- config.update_collector_frequency - Change frequency for specific collector';
 PRINT '- config.set_collector_enabled - Enable/disable specific collector';
-PRINT '- config.apply_collection_preset - Apply a named preset (Aggressive, Balanced, Low-Impact)';
+PRINT '- config.apply_collection_preset - Apply a named preset (Off, Aggressive, Balanced, Low-Impact)';
 PRINT '- config.show_collection_schedule - Display current schedule';
 PRINT '';
 PRINT 'Examples:';
 PRINT '  EXECUTE config.apply_collection_preset @preset_name = N''Aggressive'', @debug = 1;';
 PRINT '  EXECUTE config.apply_collection_preset @preset_name = N''Balanced'';';
 PRINT '  EXECUTE config.apply_collection_preset @preset_name = N''Low-Impact'';';
+PRINT '  EXECUTE config.apply_collection_preset @preset_name = N''Off'';  -- disables all collectors';
 GO

From fdd824a9682f8da234b4a7aaf37e63bb25e20e25 Mon Sep 17 00:00:00 2001
From: Erik Darling <2136037+erikdarlingdata@users.noreply.github.com>
Date: Sat, 25 Apr 2026 10:29:21 -0400
Subject: [PATCH 36/49] Bump DuckDB.NET to 1.5.2

Pulls in two upstream bugfix releases relevant to Lite's collector pattern:
- 1.5.2 fixes unbounded row group growth on indexed tables under repeated
  load+insert cycles, and memory leaks/race conditions in prepared statements.
- 1.5.1 hardens WAL checkpoint marking, prevents memory corruption in
  concurrent TrimFreeBlocks, and improves Windows UTF-8/UTF-16 handling.

No storage version change within 1.5.x.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
---
 Lite/PerformanceMonitorLite.csproj | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/Lite/PerformanceMonitorLite.csproj b/Lite/PerformanceMonitorLite.csproj
index a443fdee..7b8936e0 100644
--- a/Lite/PerformanceMonitorLite.csproj
+++ b/Lite/PerformanceMonitorLite.csproj
@@ -37,8 +37,8 @@
 
   <ItemGroup>
     <!-- DuckDB for local data storage -->
-    <PackageReference Include="DuckDB.NET.Data" Version="1.5.0" />
-    <PackageReference Include="DuckDB.NET.Bindings.Full" Version="1.5.0" />
+    <PackageReference Include="DuckDB.NET.Data" Version="1.5.2" />
+    <PackageReference Include="DuckDB.NET.Bindings.Full" Version="1.5.2" />
 
     <!-- SQL Server connectivity -->
     <PackageReference Include="Microsoft.Data.SqlClient" Version="6.1.4" />

From 4bdd81e195dd5eaeab0b5ef4f7ba1e35b336813e Mon Sep 17 00:00:00 2001
From: Erik Darling <2136037+erikdarlingdata@users.noreply.github.com>
Date: Sat, 25 Apr 2026 10:46:49 -0400
Subject: [PATCH 37/49] Bump Microsoft.Extensions.*, System.Text.Json,
 ScottPlot.WPF
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Patch-level upgrades only:
- Microsoft.Extensions.Configuration / Configuration.Json / Hosting / Logging:
  10.0.5 -> 10.0.7 (Dashboard, Lite)
- System.Text.Json: 10.0.5 -> 10.0.7 (Lite)
- ScottPlot.WPF: 5.1.57 -> 5.1.58 (Dashboard, Lite)

Microsoft.Data.SqlClient (6.1.4 -> 7.0.1) and ModelContextProtocol
(0.7.0-preview.1 -> 1.2.0) intentionally left out — both deserve dedicated
PRs after a focused review.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
---
 Dashboard/Dashboard.csproj         | 8 ++++----
 Lite/PerformanceMonitorLite.csproj | 8 ++++----
 2 files changed, 8 insertions(+), 8 deletions(-)

diff --git a/Dashboard/Dashboard.csproj b/Dashboard/Dashboard.csproj
index aff84b73..bf76c58d 100644
--- a/Dashboard/Dashboard.csproj
+++ b/Dashboard/Dashboard.csproj
@@ -36,12 +36,12 @@
     <PackageReference Include="CredentialManagement" Version="1.0.2" />
     <PackageReference Include="Hardcodet.NotifyIcon.Wpf" Version="2.0.1" />
     <PackageReference Include="Microsoft.Data.SqlClient" Version="6.1.4" />
-    <PackageReference Include="Microsoft.Extensions.Configuration" Version="10.0.5" />
-    <PackageReference Include="Microsoft.Extensions.Configuration.Json" Version="10.0.5" />
-    <PackageReference Include="ScottPlot.WPF" Version="5.1.57" />
+    <PackageReference Include="Microsoft.Extensions.Configuration" Version="10.0.7" />
+    <PackageReference Include="Microsoft.Extensions.Configuration.Json" Version="10.0.7" />
+    <PackageReference Include="ScottPlot.WPF" Version="5.1.58" />
     <PackageReference Include="ModelContextProtocol" Version="0.7.0-preview.1" />
     <PackageReference Include="ModelContextProtocol.AspNetCore" Version="0.7.0-preview.1" />
-    <PackageReference Include="Microsoft.Extensions.Hosting" Version="10.0.5" />
+    <PackageReference Include="Microsoft.Extensions.Hosting" Version="10.0.7" />
     <PackageReference Include="Velopack" Version="0.0.1298" />
   </ItemGroup>
 
diff --git a/Lite/PerformanceMonitorLite.csproj b/Lite/PerformanceMonitorLite.csproj
index a443fdee..58a184d1 100644
--- a/Lite/PerformanceMonitorLite.csproj
+++ b/Lite/PerformanceMonitorLite.csproj
@@ -44,22 +44,22 @@
     <PackageReference Include="Microsoft.Data.SqlClient" Version="6.1.4" />
 
     <!-- Charting -->
-    <PackageReference Include="ScottPlot.WPF" Version="5.1.57" />
+    <PackageReference Include="ScottPlot.WPF" Version="5.1.58" />
 
     <!-- Windows Credential Manager for secure credential storage -->
     <PackageReference Include="CredentialManagement" Version="1.0.2" />
 
     <!-- Background service hosting -->
-    <PackageReference Include="Microsoft.Extensions.Hosting" Version="10.0.5" />
+    <PackageReference Include="Microsoft.Extensions.Hosting" Version="10.0.7" />
 
     <!-- Logging -->
-    <PackageReference Include="Microsoft.Extensions.Logging" Version="10.0.5" />
+    <PackageReference Include="Microsoft.Extensions.Logging" Version="10.0.7" />
 
     <!-- System tray -->
     <PackageReference Include="Hardcodet.NotifyIcon.Wpf" Version="2.0.1" />
 
     <!-- JSON configuration -->
-    <PackageReference Include="System.Text.Json" Version="10.0.5" />
+    <PackageReference Include="System.Text.Json" Version="10.0.7" />
 
     <!-- MCP server for LLM tool access -->
     <PackageReference Include="ModelContextProtocol" Version="0.7.0-preview.1" />

From 90907b4440dd38ae8652b5de9ec9cf6d1c14c094 Mon Sep 17 00:00:00 2001
From: Erik Darling <2136037+erikdarlingdata@users.noreply.github.com>
Date: Sat, 25 Apr 2026 11:02:18 -0400
Subject: [PATCH 38/49] Bump Microsoft.Data.SqlClient to 7.0.1
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

SqlClient 7.0 split Azure/Entra dependencies out of the core package, so
projects with Entra-Interactive auth paths (ActiveDirectoryInteractive)
also need the new Microsoft.Data.SqlClient.Extensions.Azure helper to
keep MFA login working at runtime.

Bumps to 7.0.1 across:
- Dashboard (+ Extensions.Azure 1.0.0)
- Lite (+ Extensions.Azure 1.0.0)
- Installer.Core (+ Extensions.Azure 1.0.0; transitive via Installer/InstallerGui/Installer.Tests)
- InstallerGui (+ Extensions.Azure 1.0.0)
- Installer (no Extensions.Azure — no Entra path)
- Installer.Tests (no Extensions.Azure — no Entra path)

Connection strings already set Encrypt explicitly everywhere, so the
4.0-era default flip is a no-op for this repo. SQL Server 2012+ remains
supported (so all of 2016/2017/2019/2022/2025 stay reachable).

Verified:
- All six projects build clean
- Installer.Tests: 46/46 passing against real SQL
- Lite.Tests: 257/257 passing against real SQL
- Dashboard and Lite launch and stay running

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
---
 Dashboard/Dashboard.csproj                   | 3 ++-
 Installer.Core/Installer.Core.csproj         | 3 ++-
 Installer.Tests/Installer.Tests.csproj       | 2 +-
 Installer/PerformanceMonitorInstaller.csproj | 2 +-
 InstallerGui/InstallerGui.csproj             | 3 ++-
 Lite/PerformanceMonitorLite.csproj           | 3 ++-
 6 files changed, 10 insertions(+), 6 deletions(-)

diff --git a/Dashboard/Dashboard.csproj b/Dashboard/Dashboard.csproj
index bf76c58d..2d08cfae 100644
--- a/Dashboard/Dashboard.csproj
+++ b/Dashboard/Dashboard.csproj
@@ -35,7 +35,8 @@
   <ItemGroup>
     <PackageReference Include="CredentialManagement" Version="1.0.2" />
     <PackageReference Include="Hardcodet.NotifyIcon.Wpf" Version="2.0.1" />
-    <PackageReference Include="Microsoft.Data.SqlClient" Version="6.1.4" />
+    <PackageReference Include="Microsoft.Data.SqlClient" Version="7.0.1" />
+    <PackageReference Include="Microsoft.Data.SqlClient.Extensions.Azure" Version="1.0.0" />
     <PackageReference Include="Microsoft.Extensions.Configuration" Version="10.0.7" />
     <PackageReference Include="Microsoft.Extensions.Configuration.Json" Version="10.0.7" />
     <PackageReference Include="ScottPlot.WPF" Version="5.1.58" />
diff --git a/Installer.Core/Installer.Core.csproj b/Installer.Core/Installer.Core.csproj
index c5d9b0c0..d37056cb 100644
--- a/Installer.Core/Installer.Core.csproj
+++ b/Installer.Core/Installer.Core.csproj
@@ -19,7 +19,8 @@
   </PropertyGroup>
 
   <ItemGroup>
-    <PackageReference Include="Microsoft.Data.SqlClient" Version="6.1.4" />
+    <PackageReference Include="Microsoft.Data.SqlClient" Version="7.0.1" />
+    <PackageReference Include="Microsoft.Data.SqlClient.Extensions.Azure" Version="1.0.0" />
   </ItemGroup>
 
   <!-- Embed SQL scripts as assembly resources for Dashboard consumption -->
diff --git a/Installer.Tests/Installer.Tests.csproj b/Installer.Tests/Installer.Tests.csproj
index 18a446f8..6c8dd23d 100644
--- a/Installer.Tests/Installer.Tests.csproj
+++ b/Installer.Tests/Installer.Tests.csproj
@@ -16,7 +16,7 @@
       <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
     </PackageReference>
     <PackageReference Include="xunit.v3" Version="3.2.2" />
-    <PackageReference Include="Microsoft.Data.SqlClient" Version="6.1.4" />
+    <PackageReference Include="Microsoft.Data.SqlClient" Version="7.0.1" />
   </ItemGroup>
 
   <ItemGroup>
diff --git a/Installer/PerformanceMonitorInstaller.csproj b/Installer/PerformanceMonitorInstaller.csproj
index 83b6b38e..222138f1 100644
--- a/Installer/PerformanceMonitorInstaller.csproj
+++ b/Installer/PerformanceMonitorInstaller.csproj
@@ -31,7 +31,7 @@
   </PropertyGroup>
 
   <ItemGroup>
-    <PackageReference Include="Microsoft.Data.SqlClient" Version="6.1.4" />
+    <PackageReference Include="Microsoft.Data.SqlClient" Version="7.0.1" />
   </ItemGroup>
 
   <ItemGroup>
diff --git a/InstallerGui/InstallerGui.csproj b/InstallerGui/InstallerGui.csproj
index 61d0342e..6e6a58ef 100644
--- a/InstallerGui/InstallerGui.csproj
+++ b/InstallerGui/InstallerGui.csproj
@@ -27,7 +27,8 @@
   </PropertyGroup>
 
   <ItemGroup>
-    <PackageReference Include="Microsoft.Data.SqlClient" Version="6.1.4" />
+    <PackageReference Include="Microsoft.Data.SqlClient" Version="7.0.1" />
+    <PackageReference Include="Microsoft.Data.SqlClient.Extensions.Azure" Version="1.0.0" />
   </ItemGroup>
 
   <ItemGroup>
diff --git a/Lite/PerformanceMonitorLite.csproj b/Lite/PerformanceMonitorLite.csproj
index 80701a65..d8fe59b7 100644
--- a/Lite/PerformanceMonitorLite.csproj
+++ b/Lite/PerformanceMonitorLite.csproj
@@ -41,7 +41,8 @@
     <PackageReference Include="DuckDB.NET.Bindings.Full" Version="1.5.2" />
 
     <!-- SQL Server connectivity -->
-    <PackageReference Include="Microsoft.Data.SqlClient" Version="6.1.4" />
+    <PackageReference Include="Microsoft.Data.SqlClient" Version="7.0.1" />
+    <PackageReference Include="Microsoft.Data.SqlClient.Extensions.Azure" Version="1.0.0" />
 
     <!-- Charting -->
     <PackageReference Include="ScottPlot.WPF" Version="5.1.58" />

From 987317c42ececed2e4d77f9dc58ec496de8bc1d0 Mon Sep 17 00:00:00 2001
From: Erik Darling <2136037+erikdarlingdata@users.noreply.github.com>
Date: Sat, 25 Apr 2026 11:04:08 -0400
Subject: [PATCH 39/49] Bump ModelContextProtocol to 1.2.0
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Moves Dashboard and Lite from the 0.7.0-preview.1 SDK to the stable 1.2.0
release. The C# SDK landed 1.0 between these two points and the codebase
happens to use only the stable subset of the surface (attributes,
AddMcpServer/WithHttpTransport/WithTools<T>/MapMcp, DI-bound tool
methods) — none of the breaking changes (filter API rename, RequestContext
ctor, RunSessionHandler, binary-content types, McpServerHandlers,
legacy SSE) touch this repo.

154 [McpServerTool] sites and 39 [McpServerToolType] sites compile
unchanged. Zero source code changes — packaging only.

Verified:
- Dashboard and Lite build clean (0 errors)
- Lite launches; the in-process MCP server starts on :5151
- A POST initialize against the new Streamable HTTP transport returns
  the full server capabilities and tool descriptions

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
---
 Dashboard/Dashboard.csproj         | 4 ++--
 Lite/PerformanceMonitorLite.csproj | 4 ++--
 2 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/Dashboard/Dashboard.csproj b/Dashboard/Dashboard.csproj
index 2d08cfae..32a0716d 100644
--- a/Dashboard/Dashboard.csproj
+++ b/Dashboard/Dashboard.csproj
@@ -40,8 +40,8 @@
     <PackageReference Include="Microsoft.Extensions.Configuration" Version="10.0.7" />
     <PackageReference Include="Microsoft.Extensions.Configuration.Json" Version="10.0.7" />
     <PackageReference Include="ScottPlot.WPF" Version="5.1.58" />
-    <PackageReference Include="ModelContextProtocol" Version="0.7.0-preview.1" />
-    <PackageReference Include="ModelContextProtocol.AspNetCore" Version="0.7.0-preview.1" />
+    <PackageReference Include="ModelContextProtocol" Version="1.2.0" />
+    <PackageReference Include="ModelContextProtocol.AspNetCore" Version="1.2.0" />
     <PackageReference Include="Microsoft.Extensions.Hosting" Version="10.0.7" />
     <PackageReference Include="Velopack" Version="0.0.1298" />
   </ItemGroup>
diff --git a/Lite/PerformanceMonitorLite.csproj b/Lite/PerformanceMonitorLite.csproj
index d8fe59b7..c38cb028 100644
--- a/Lite/PerformanceMonitorLite.csproj
+++ b/Lite/PerformanceMonitorLite.csproj
@@ -63,8 +63,8 @@
     <PackageReference Include="System.Text.Json" Version="10.0.7" />
 
     <!-- MCP server for LLM tool access -->
-    <PackageReference Include="ModelContextProtocol" Version="0.7.0-preview.1" />
-    <PackageReference Include="ModelContextProtocol.AspNetCore" Version="0.7.0-preview.1" />
+    <PackageReference Include="ModelContextProtocol" Version="1.2.0" />
+    <PackageReference Include="ModelContextProtocol.AspNetCore" Version="1.2.0" />
     <PackageReference Include="Velopack" Version="0.0.1298" />
   </ItemGroup>
 

From 2366f575e11e8ea012f7a1652bf2b4b5f5f58431 Mon Sep 17 00:00:00 2001
From: Erik Darling <2136037+erikdarlingdata@users.noreply.github.com>
Date: Sat, 25 Apr 2026 11:33:39 -0400
Subject: [PATCH 40/49] Bump Microsoft.NET.Test.Sdk to 18.4.0
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Patch-level upgrade in the two test projects (Installer.Tests, Lite.Tests).
Test-only — no shipping code touched.

Verified: Installer.Tests 46/46, Lite.Tests 257/257 passing.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
---
 Installer.Tests/Installer.Tests.csproj | 2 +-
 Lite.Tests/Lite.Tests.csproj           | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/Installer.Tests/Installer.Tests.csproj b/Installer.Tests/Installer.Tests.csproj
index 6c8dd23d..d605a241 100644
--- a/Installer.Tests/Installer.Tests.csproj
+++ b/Installer.Tests/Installer.Tests.csproj
@@ -10,7 +10,7 @@
   </PropertyGroup>
 
   <ItemGroup>
-    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="18.3.0" />
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="18.4.0" />
     <PackageReference Include="xunit.runner.visualstudio" Version="3.1.5">
       <PrivateAssets>all</PrivateAssets>
       <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
diff --git a/Lite.Tests/Lite.Tests.csproj b/Lite.Tests/Lite.Tests.csproj
index 874fd31f..a1c95836 100644
--- a/Lite.Tests/Lite.Tests.csproj
+++ b/Lite.Tests/Lite.Tests.csproj
@@ -9,7 +9,7 @@
   </PropertyGroup>
 
   <ItemGroup>
-    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="18.3.0" />
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="18.4.0" />
     <PackageReference Include="xunit.runner.visualstudio" Version="3.1.5">
       <PrivateAssets>all</PrivateAssets>
       <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>

From b23d64b578fdb66ea3a685ba5540f1e114584d50 Mon Sep 17 00:00:00 2001
From: Erik Darling <2136037+erikdarlingdata@users.noreply.github.com>
Date: Sat, 25 Apr 2026 18:57:54 -0400
Subject: [PATCH 41/49] Raise install loop timeout from 5 minutes to 1 hour
 (#884) (#886)

ExecuteInstallationAsync applied StandardTimeoutSeconds (300s) to every
batch in the main install script list. 98_validate_installation.sql runs
every enabled collector with @debug = 1 via a cursor in a single batch,
which on large databases (e.g. 7M-row collect.query_stats) takes longer
than 5 minutes and fails the entire install/upgrade.

ExecuteAllUpgradesAsync already uses UpgradeTimeoutSeconds (3600s) for
upgrades/{from}-to-{to}/ scripts (cfd7d6e, #538/#539). Apply the same
ceiling to the main install loop so files like 98_validate_installation
and large-table DDL get the same hour instead of the 5 minutes that was
only ever a comfortable default for small databases.

Co-authored-by: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
---
 Installer.Core/InstallationService.cs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/Installer.Core/InstallationService.cs b/Installer.Core/InstallationService.cs
index e26f99f5..c675a8e9 100644
--- a/Installer.Core/InstallationService.cs
+++ b/Installer.Core/InstallationService.cs
@@ -432,7 +432,7 @@ Files execute without transaction wrapping because many contain DDL.
                     batchNumber++;
 
                     using var command = new SqlCommand(trimmedBatch, connection);
-                    command.CommandTimeout = StandardTimeoutSeconds;
+                    command.CommandTimeout = UpgradeTimeoutSeconds;
 
                     try
                     {

From 69fe460538a2df7e21ec4010f99cfb855132c971 Mon Sep 17 00:00:00 2001
From: Erik Darling <2136037+erikdarlingdata@users.noreply.github.com>
Date: Mon, 27 Apr 2026 20:11:56 -0400
Subject: [PATCH 42/49] Add Purge Now action to Manage Servers (#900)

- New "Purge Now" button on Manage Servers window with override modes
  (configured / 1 / 3 / 7 / custom / all). All option uses TRUNCATE.
- Right-click menu now mirrors all per-row actions (Edit, Toggle Favorite,
  Check Server Version, Purge Now, Remove) above existing copy/export.
- config.data_retention reworked: @retention_days = NULL respects per-collector
  schedule, 0 TRUNCATEs every collect.* table, N > 0 overrides every cutoff
  to N days. Old @truncate_all parameter removed; @retention_days = 0 covers
  that case. Truncate path snapshots row count before wiping for reporting.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
---
 Dashboard/ManageServersWindow.xaml    |   8 +
 Dashboard/ManageServersWindow.xaml.cs |  67 ++++++++
 Dashboard/PurgeNowDialog.xaml         |  53 ++++++
 Dashboard/PurgeNowDialog.xaml.cs      | 114 +++++++++++++
 Dashboard/Services/ServerManager.cs   |  88 ++++++++++
 install/43_data_retention.sql         | 226 +++++++++++++++++++++-----
 6 files changed, 515 insertions(+), 41 deletions(-)
 create mode 100644 Dashboard/PurgeNowDialog.xaml
 create mode 100644 Dashboard/PurgeNowDialog.xaml.cs

diff --git a/Dashboard/ManageServersWindow.xaml b/Dashboard/ManageServersWindow.xaml
index 99d1650c..c96e9863 100644
--- a/Dashboard/ManageServersWindow.xaml
+++ b/Dashboard/ManageServersWindow.xaml
@@ -9,6 +9,13 @@
     <Window.Resources>
         <BooleanToVisibilityConverter x:Key="BoolToVisibilityConverter"/>
         <ContextMenu x:Key="DataGridContextMenu">
+            <MenuItem Header="Edit..." Click="EditServer_Click"/>
+            <MenuItem Header="Toggle Favorite" Click="ToggleFavorite_Click"/>
+            <MenuItem Header="Check Server Version" Click="CheckForUpdates_Click"/>
+            <MenuItem Header="Purge Now" Click="PurgeNow_Click"/>
+            <MenuItem Header="Remove" Click="RemoveServer_Click"
+                      Foreground="{DynamicResource ErrorBrush}"/>
+            <Separator/>
             <MenuItem Header="Copy Cell" Click="CopyCell_Click">
                 <MenuItem.Icon><TextBlock Text="&#x1F4CB;"/></MenuItem.Icon>
             </MenuItem>
@@ -91,6 +98,7 @@
                 <Button Content="Edit..." Width="80" Height="30" Margin="0,0,8,0" Click="EditServer_Click"/>
                 <Button x:Name="ToggleFavoriteButton" Content="Toggle Favorite" Width="110" Height="30" Margin="0,0,8,0" Click="ToggleFavorite_Click"/>
                 <Button x:Name="CheckUpdatesButton" Content="Check Server Version" Width="140" Height="30" Margin="0,0,8,0" Click="CheckForUpdates_Click"/>
+                <Button Content="Purge Now" Width="100" Height="30" Margin="0,0,8,0" Click="PurgeNow_Click"/>
                 <Button Content="Remove" Width="80" Height="30" Margin="0,0,8,0" Click="RemoveServer_Click"
                         Foreground="{DynamicResource ErrorBrush}"/>
             </StackPanel>
diff --git a/Dashboard/ManageServersWindow.xaml.cs b/Dashboard/ManageServersWindow.xaml.cs
index bbd2ea74..c2ad284c 100644
--- a/Dashboard/ManageServersWindow.xaml.cs
+++ b/Dashboard/ManageServersWindow.xaml.cs
@@ -297,6 +297,73 @@ string Normalize(string v)
             }
         }
 
+        private async void PurgeNow_Click(object sender, RoutedEventArgs e)
+        {
+            if (ServersDataGrid.SelectedItem is not ServerConnection server)
+            {
+                MessageBox.Show(
+                    "Please select a server to purge.",
+                    "No Server Selected",
+                    MessageBoxButton.OK,
+                    MessageBoxImage.Information);
+                return;
+            }
+
+            var dialog = new PurgeNowDialog(server.DisplayNameWithIntent) { Owner = this };
+            if (dialog.ShowDialog() != true) return;
+
+            Cursor = System.Windows.Input.Cursors.Wait;
+            try
+            {
+                var result = await _serverManager.RunDataRetentionAsync(
+                    server,
+                    dialog.RetentionDaysOverride);
+
+                bool wasTruncate = dialog.RetentionDaysOverride == 0;
+                string body;
+                if (wasTruncate)
+                {
+                    body = $"All collector tables truncated.\n\n" +
+                           $"Rows wiped: {result.RowsDeleted:N0}\n" +
+                           $"Tables affected: {result.TableCount}\n" +
+                           $"Status: {result.Status}\n" +
+                           $"Duration: {result.DurationMs} ms";
+                }
+                else
+                {
+                    body = $"Purge complete.\n\n" +
+                           $"Rows deleted: {result.RowsDeleted:N0}\n" +
+                           $"Tables touched: {result.TableCount}\n" +
+                           $"Status: {result.Status}\n" +
+                           $"Duration: {result.DurationMs} ms";
+                }
+
+                if (!string.Equals(result.Status, "SUCCESS", StringComparison.Ordinal) &&
+                    !string.IsNullOrEmpty(result.Message))
+                {
+                    body += $"\n\nMessage: {result.Message}";
+                }
+
+                MessageBox.Show(this, body, "Purge Complete",
+                    MessageBoxButton.OK,
+                    string.Equals(result.Status, "SUCCESS", StringComparison.Ordinal)
+                        ? MessageBoxImage.Information
+                        : MessageBoxImage.Warning);
+            }
+            catch (Exception ex)
+            {
+                MessageBox.Show(this,
+                    $"Failed to run purge on '{server.DisplayNameWithIntent}':\n\n{ex.Message}",
+                    "Purge Failed",
+                    MessageBoxButton.OK,
+                    MessageBoxImage.Error);
+            }
+            finally
+            {
+                Cursor = null;
+            }
+        }
+
         private void CopyCell_Click(object sender, RoutedEventArgs e)
         {
             if (sender is MenuItem menuItem && menuItem.Parent is ContextMenu contextMenu)
diff --git a/Dashboard/PurgeNowDialog.xaml b/Dashboard/PurgeNowDialog.xaml
new file mode 100644
index 00000000..29f23cbc
--- /dev/null
+++ b/Dashboard/PurgeNowDialog.xaml
@@ -0,0 +1,53 @@
+<Window x:Class="PerformanceMonitorDashboard.PurgeNowDialog"
+        xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
+        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
+        Title="Purge Now"
+        Height="320" Width="500"
+        WindowStartupLocation="CenterOwner"
+        ResizeMode="NoResize"
+        Background="{DynamicResource BackgroundBrush}">
+    <Grid Margin="20">
+        <Grid.RowDefinitions>
+            <RowDefinition Height="Auto"/>
+            <RowDefinition Height="Auto"/>
+            <RowDefinition Height="Auto"/>
+            <RowDefinition Height="Auto"/>
+            <RowDefinition Height="*"/>
+            <RowDefinition Height="Auto"/>
+        </Grid.RowDefinitions>
+
+        <TextBlock Grid.Row="0" x:Name="HeaderText" TextWrapping="Wrap" FontSize="13" FontWeight="Bold"
+                   Foreground="{DynamicResource ForegroundBrush}" Margin="0,0,0,12"/>
+
+        <TextBlock Grid.Row="1" Text="Purge mode:" Margin="0,0,0,4"
+                   Foreground="{DynamicResource ForegroundBrush}"/>
+
+        <ComboBox Grid.Row="2" x:Name="ModeComboBox" Height="28" Margin="0,0,0,12"
+                  SelectionChanged="ModeComboBox_SelectionChanged">
+            <ComboBoxItem Content="Use configured retention" IsSelected="True" Tag="configured"/>
+            <ComboBoxItem Content="1 day" Tag="1"/>
+            <ComboBoxItem Content="3 days" Tag="3"/>
+            <ComboBoxItem Content="7 days" Tag="7"/>
+            <ComboBoxItem Content="Custom..." Tag="custom"/>
+            <ComboBoxItem x:Name="AllItem" Content="All — TRUNCATE everything" Tag="all"
+                          Foreground="{DynamicResource ErrorBrush}"/>
+        </ComboBox>
+
+        <StackPanel Grid.Row="3" x:Name="CustomDaysPanel" Orientation="Horizontal" Margin="0,0,0,12"
+                    Visibility="Collapsed">
+            <TextBlock Text="Retention (days):" VerticalAlignment="Center" Margin="0,0,8,0"
+                       Foreground="{DynamicResource ForegroundBrush}"/>
+            <TextBox x:Name="CustomDaysBox" Width="80" Height="26" Padding="6,0,6,0"
+                     VerticalContentAlignment="Center"
+                     Text="14" PreviewTextInput="CustomDaysBox_PreviewTextInput"/>
+        </StackPanel>
+
+        <TextBlock Grid.Row="4" x:Name="WarningText" TextWrapping="Wrap" FontSize="11"
+                   Foreground="{DynamicResource ErrorBrush}" Margin="0,4,0,8"/>
+
+        <StackPanel Grid.Row="5" Orientation="Horizontal" HorizontalAlignment="Right">
+            <Button x:Name="PurgeButton" Content="Purge" Width="80" Height="28" Margin="0,0,8,0" Click="Purge_Click"/>
+            <Button Content="Cancel" Width="80" Height="28" Click="Cancel_Click" IsCancel="True"/>
+        </StackPanel>
+    </Grid>
+</Window>
diff --git a/Dashboard/PurgeNowDialog.xaml.cs b/Dashboard/PurgeNowDialog.xaml.cs
new file mode 100644
index 00000000..c3b5a549
--- /dev/null
+++ b/Dashboard/PurgeNowDialog.xaml.cs
@@ -0,0 +1,114 @@
+/*
+ * Copyright (c) 2026 Erik Darling, Darling Data LLC
+ *
+ * This file is part of the SQL Server Performance Monitor.
+ *
+ * Licensed under the MIT License. See LICENSE file in the project root for full license information.
+ */
+
+using System.Text.RegularExpressions;
+using System.Windows;
+using System.Windows.Controls;
+using System.Windows.Input;
+
+namespace PerformanceMonitorDashboard
+{
+    public partial class PurgeNowDialog : Window
+    {
+        private readonly string _serverDisplayName;
+
+        /// <summary>
+        /// null = use configured retention.
+        /// 0 = TRUNCATE every collect.* table.
+        /// N > 0 = override every table's cutoff to N days.
+        /// </summary>
+        public int? RetentionDaysOverride { get; private set; }
+
+        public PurgeNowDialog(string serverDisplayName)
+        {
+            InitializeComponent();
+            _serverDisplayName = serverDisplayName;
+            HeaderText.Text = $"Purge collected data on '{serverDisplayName}'.";
+            UpdateWarningForMode("configured");
+        }
+
+        private void ModeComboBox_SelectionChanged(object sender, SelectionChangedEventArgs e)
+        {
+            /* Fires once during InitializeComponent before other named elements exist; bail until window is loaded. */
+            if (CustomDaysPanel is null || WarningText is null) return;
+
+            if (ModeComboBox.SelectedItem is not ComboBoxItem item) return;
+
+            string tag = item.Tag as string ?? "configured";
+            CustomDaysPanel.Visibility = tag == "custom" ? Visibility.Visible : Visibility.Collapsed;
+            UpdateWarningForMode(tag);
+        }
+
+        private void UpdateWarningForMode(string tag)
+        {
+            WarningText.Text = tag switch
+            {
+                "configured" => "Deletes data older than the per-collector retention configured in config.collection_schedule. Cannot be undone.",
+                "all"        => "WARNING: TRUNCATEs every collect.* table. Wipes ALL collected monitoring data on this server. Cannot be undone.",
+                "custom"     => "Deletes data older than the specified number of days. Cannot be undone.",
+                _            => $"Deletes data older than {tag} day(s). Cannot be undone."
+            };
+        }
+
+        private void CustomDaysBox_PreviewTextInput(object sender, TextCompositionEventArgs e)
+        {
+            e.Handled = !Regex.IsMatch(e.Text, "^[0-9]+$");
+        }
+
+        private void Purge_Click(object sender, RoutedEventArgs e)
+        {
+            if (ModeComboBox.SelectedItem is not ComboBoxItem item) return;
+
+            string tag = item.Tag as string ?? "configured";
+
+            switch (tag)
+            {
+                case "configured":
+                    RetentionDaysOverride = null;
+                    break;
+
+                case "1":
+                case "3":
+                case "7":
+                    RetentionDaysOverride = int.Parse(tag);
+                    break;
+
+                case "custom":
+                    if (!int.TryParse(CustomDaysBox.Text, out int days) || days < 1)
+                    {
+                        MessageBox.Show(this,
+                            "Enter a whole number of days greater than 0.",
+                            "Invalid Retention",
+                            MessageBoxButton.OK,
+                            MessageBoxImage.Warning);
+                        return;
+                    }
+                    RetentionDaysOverride = days;
+                    break;
+
+                case "all":
+                    var confirm = MessageBox.Show(this,
+                        $"This will TRUNCATE every collect.* table on '{_serverDisplayName}', wiping all monitoring data.\n\nAre you absolutely sure?",
+                        "Confirm Purge All",
+                        MessageBoxButton.YesNo,
+                        MessageBoxImage.Warning,
+                        MessageBoxResult.No);
+                    if (confirm != MessageBoxResult.Yes) return;
+                    RetentionDaysOverride = 0;
+                    break;
+            }
+
+            DialogResult = true;
+        }
+
+        private void Cancel_Click(object sender, RoutedEventArgs e)
+        {
+            DialogResult = false;
+        }
+    }
+}
diff --git a/Dashboard/Services/ServerManager.cs b/Dashboard/Services/ServerManager.cs
index d3686645..29ce934f 100644
--- a/Dashboard/Services/ServerManager.cs
+++ b/Dashboard/Services/ServerManager.cs
@@ -196,6 +196,94 @@ IF DB_ID('PerformanceMonitor') IS NOT NULL
             Logger.Info($"Dropped PerformanceMonitor database and Agent jobs on '{server.DisplayName}'");
         }
 
+        public class PurgeResult
+        {
+            public int RowsDeleted { get; set; }
+            public int TableCount { get; set; }
+            public int DurationMs { get; set; }
+            public string Status { get; set; } = "";
+            public string? Message { get; set; }
+        }
+
+        /// <summary>
+        /// Runs config.data_retention against the PerformanceMonitor database on the given server.
+        /// </summary>
+        /// <param name="retentionDaysOverride">
+        /// null = use per-collector retention from config.collection_schedule.
+        /// 0 = TRUNCATE every collect.* table.
+        /// N > 0 = override every table's cutoff to N days.
+        /// </param>
+        public async Task<PurgeResult> RunDataRetentionAsync(
+            ServerConnection server,
+            int? retentionDaysOverride)
+        {
+            var connectionString = server.GetConnectionString(_credentialService);
+            var builder = new SqlConnectionStringBuilder(connectionString)
+            {
+                InitialCatalog = "PerformanceMonitor",
+                ConnectTimeout = 10
+            };
+
+            using var connection = new SqlConnection(builder.ConnectionString);
+            await connection.OpenAsync();
+
+            using (var cmd = new SqlCommand("config.data_retention", connection))
+            {
+                cmd.CommandType = System.Data.CommandType.StoredProcedure;
+                cmd.CommandTimeout = 600;
+
+                if (retentionDaysOverride.HasValue)
+                {
+                    cmd.Parameters.Add(new SqlParameter("@retention_days", System.Data.SqlDbType.Int) { Value = retentionDaysOverride.Value });
+                }
+
+                await cmd.ExecuteNonQueryAsync();
+            }
+
+            using var readCmd = new SqlCommand(@"
+SELECT TOP (1)
+    cl.collection_status,
+    cl.rows_collected,
+    cl.duration_ms,
+    cl.error_message
+FROM config.collection_log AS cl
+WHERE cl.collector_name = N'data_retention'
+ORDER BY cl.collection_time DESC;", connection);
+            readCmd.CommandTimeout = 30;
+
+            using var reader = await readCmd.ExecuteReaderAsync();
+            var result = new PurgeResult();
+
+            if (await reader.ReadAsync())
+            {
+                result.Status = reader.IsDBNull(0) ? "" : reader.GetString(0);
+                result.RowsDeleted = reader.IsDBNull(1) ? 0 : reader.GetInt32(1);
+                result.DurationMs = reader.IsDBNull(2) ? 0 : reader.GetInt32(2);
+                result.Message = reader.IsDBNull(3) ? null : reader.GetString(3);
+
+                if (result.Message is not null && result.Message.StartsWith("Cleaned ", StringComparison.Ordinal))
+                {
+                    int spaceIdx = result.Message.IndexOf(' ', 8);
+                    if (spaceIdx > 8 && int.TryParse(result.Message.AsSpan(8, spaceIdx - 8), out int tableCount))
+                    {
+                        result.TableCount = tableCount;
+                    }
+                }
+                else if (result.Message is not null && result.Message.StartsWith("TRUNCATE all: ", StringComparison.Ordinal))
+                {
+                    int spaceIdx = result.Message.IndexOf(' ', 14);
+                    if (spaceIdx > 14 && int.TryParse(result.Message.AsSpan(14, spaceIdx - 14), out int tableCount))
+                    {
+                        result.TableCount = tableCount;
+                    }
+                }
+            }
+
+            Logger.Info($"Ran data_retention on '{server.DisplayName}': status={result.Status}, rowsDeleted={result.RowsDeleted}, tables={result.TableCount}, durationMs={result.DurationMs}");
+
+            return result;
+        }
+
         public void UpdateLastConnected(string id)
         {
             lock (_serversLock)
diff --git a/install/43_data_retention.sql b/install/43_data_retention.sql
index 09fa8666..96749569 100644
--- a/install/43_data_retention.sql
+++ b/install/43_data_retention.sql
@@ -35,7 +35,7 @@ GO
 ALTER PROCEDURE
     config.data_retention
 (
-    @retention_days integer = 30, /*Fallback retention for tables without a collection_schedule entry*/
+    @retention_days integer = NULL, /*NULL = use per-collector retention from config.collection_schedule (30-day fallback). 0 = TRUNCATE every collect.* table. N > 0 = override every table's cutoff to N days.*/
     @batch_size integer = 10000, /*Number of rows to delete per batch to avoid blocking*/
     @debug bit = 0 /*Print debugging information*/
 )
@@ -45,8 +45,16 @@ BEGIN
     SET NOCOUNT ON;
     SET TRANSACTION ISOLATION LEVEL READ UNCOMMITTED;
 
+    /*
+    NULL @retention_days means "respect per-collector schedule" with a 30-day fallback for unscheduled tables.
+    Non-NULL means "use this value as the cutoff everywhere" — schedule overrides are skipped.
+    */
     DECLARE
-        @retention_date datetime2(7) = DATEADD(DAY, -@retention_days, SYSDATETIME()),
+        @apply_schedule_override bit = CASE WHEN @retention_days IS NULL THEN 1 ELSE 0 END,
+        @effective_retention_days integer = ISNULL(@retention_days, 30);
+
+    DECLARE
+        @retention_date datetime2(7) = DATEADD(DAY, -@effective_retention_days, SYSDATETIME()),
         @total_deleted bigint = 0,
         @start_time datetime2(7) = SYSDATETIME(),
         @table_name sysname,
@@ -60,9 +68,9 @@ BEGIN
         /*
         Parameter validation
         */
-        IF @retention_days < 1
+        IF @retention_days IS NOT NULL AND @retention_days < 0
         BEGIN
-            RAISERROR(N'@retention_days must be at least 1', 16, 1);
+            RAISERROR(N'@retention_days must be 0 or greater', 16, 1);
             RETURN;
         END;
 
@@ -72,6 +80,130 @@ BEGIN
             RETURN;
         END;
 
+        /*
+        Purge-all branch: TRUNCATE every collect.* table when @retention_days = 0.
+        No FKs, schema-bound views, or indexed views reference collect.* so this is safe.
+        Config tables (including config.collection_log) are intentionally left alone.
+        */
+        IF @retention_days = 0
+        BEGIN
+            IF @debug = 1
+            BEGIN
+                RAISERROR(N'Starting purge-all: TRUNCATE every collect.* table', 0, 1) WITH NOWAIT;
+            END;
+
+            DECLARE
+                @truncate_table_name sysname,
+                @truncate_sql nvarchar(max),
+                @truncate_table_count integer = 0,
+                @truncate_error_count integer = 0,
+                @truncate_rows_before bigint = 0,
+                @truncate_cursor cursor;
+
+            /*
+            Snapshot total row count across collect.* before truncating so we can report
+            how many rows the user actually wiped. TRUNCATE doesn't return a count.
+            */
+            SELECT
+                @truncate_rows_before = ISNULL(SUM(p.rows), 0)
+            FROM sys.tables AS t
+            JOIN sys.schemas AS s
+              ON s.schema_id = t.schema_id
+            JOIN sys.partitions AS p
+              ON p.object_id = t.object_id
+              AND p.index_id IN (0, 1)
+            WHERE s.name = N'collect'
+            AND   t.is_ms_shipped = 0;
+
+            SET @truncate_cursor = CURSOR LOCAL FAST_FORWARD FOR
+                SELECT
+                    t.name
+                FROM sys.tables AS t
+                JOIN sys.schemas AS s
+                  ON s.schema_id = t.schema_id
+                WHERE s.name = N'collect'
+                AND   t.is_ms_shipped = 0
+                ORDER BY
+                    t.name;
+
+            OPEN @truncate_cursor;
+            FETCH NEXT FROM @truncate_cursor INTO @truncate_table_name;
+
+            WHILE @@FETCH_STATUS = 0
+            BEGIN
+                BEGIN TRY
+                    SET @truncate_sql = N'TRUNCATE TABLE collect.' + QUOTENAME(@truncate_table_name) + N';';
+
+                    IF @debug = 1
+                    BEGIN
+                        RAISERROR(N'  %s', 0, 1, @truncate_sql) WITH NOWAIT;
+                    END;
+
+                    EXECUTE sys.sp_executesql @truncate_sql;
+                    SET @truncate_table_count = @truncate_table_count + 1;
+                END TRY
+                BEGIN CATCH
+                    SET @truncate_error_count = @truncate_error_count + 1;
+                    SET @message = N'TRUNCATE failed for collect.' + QUOTENAME(@truncate_table_name) + N': ' + ERROR_MESSAGE();
+
+                    IF @debug = 1
+                    BEGIN
+                        RAISERROR(@message, 0, 1) WITH NOWAIT;
+                    END;
+
+                    INSERT INTO
+                        config.collection_log
+                    (
+                        collector_name,
+                        collection_status,
+                        error_message
+                    )
+                    VALUES
+                    (
+                        N'data_retention',
+                        N'ERROR',
+                        @message
+                    );
+                END CATCH;
+
+                FETCH NEXT FROM @truncate_cursor INTO @truncate_table_name;
+            END;
+
+            CLOSE @truncate_cursor;
+
+            INSERT INTO
+                config.collection_log
+            (
+                collector_name,
+                collection_status,
+                rows_collected,
+                duration_ms,
+                error_message
+            )
+            VALUES
+            (
+                N'data_retention',
+                CASE WHEN @truncate_error_count = 0 THEN N'SUCCESS' ELSE N'WARNING' END,
+                /*rows_collected is INT; clamp the bigint snapshot to int range*/
+                CONVERT(integer, CASE WHEN @truncate_rows_before > 2147483647 THEN 2147483647 ELSE @truncate_rows_before END),
+                DATEDIFF(MILLISECOND, @start_time, SYSDATETIME()),
+                N'TRUNCATE all: ' + CONVERT(nvarchar(10), @truncate_table_count) + N' tables truncated, '
+                + CONVERT(nvarchar(20), @truncate_rows_before) + N' rows wiped'
+                + CASE WHEN @truncate_error_count > 0
+                       THEN N', ' + CONVERT(nvarchar(10), @truncate_error_count) + N' errors'
+                       ELSE N''
+                  END
+            );
+
+            IF @debug = 1
+            BEGIN
+                RAISERROR(N'Purge-all completed: %d tables truncated, %I64d rows wiped, %d errors', 0, 1,
+                    @truncate_table_count, @truncate_rows_before, @truncate_error_count) WITH NOWAIT;
+            END;
+
+            RETURN;
+        END;
+
         IF @debug = 1
         BEGIN
             DECLARE @retention_date_string nvarchar(30) = CONVERT(nvarchar(30), @retention_date, 120);
@@ -247,42 +379,48 @@ BEGIN
 
         /*
         Override retention_date per-collector from config.collection_schedule.
-        Direct match: strip _collector/_analyzer suffix and match table name prefix.
+        Skipped when @retention_days was supplied — caller wants a flat cutoff across every table.
         */
-        UPDATE ttc
-        SET ttc.retention_date = DATEADD(DAY, -cs.retention_days, SYSDATETIME())
-        FROM #tables_to_clean AS ttc
-        JOIN config.collection_schedule AS cs
-          ON ttc.table_name LIKE REPLACE(REPLACE(cs.collector_name, N'_collector', N''), N'_analyzer', N'') + N'%';
+        IF @apply_schedule_override = 1
+        BEGIN
+            /*
+            Direct match: strip _collector/_analyzer suffix and match table name prefix.
+            */
+            UPDATE ttc
+            SET ttc.retention_date = DATEADD(DAY, -cs.retention_days, SYSDATETIME())
+            FROM #tables_to_clean AS ttc
+            JOIN config.collection_schedule AS cs
+              ON ttc.table_name LIKE REPLACE(REPLACE(cs.collector_name, N'_collector', N''), N'_analyzer', N'') + N'%';
 
-        /*
-        Special mappings for tables whose names don't match their collector:
-        - HealthParser_* tables -> system_health_collector
-        - blocking_BlockedProcessReport -> process_blocked_process_xml
-        - deadlocks (sp_BlitzLock output) -> process_deadlock_xml
-        */
-        UPDATE ttc
-        SET ttc.retention_date = DATEADD(DAY, -cs.retention_days, SYSDATETIME())
-        FROM #tables_to_clean AS ttc
-        CROSS JOIN config.collection_schedule AS cs
-        WHERE
-        (
-            ttc.table_name LIKE N'HealthParser%'
-            AND cs.collector_name = N'system_health_collector'
-        )
-        OR
-        (
-            ttc.table_name = N'blocking_BlockedProcessReport'
-            AND cs.collector_name = N'process_blocked_process_xml'
-        )
-        OR
-        (
-            ttc.table_name = N'deadlocks'
-            AND cs.collector_name = N'process_deadlock_xml'
-        );
+            /*
+            Special mappings for tables whose names don't match their collector:
+            - HealthParser_* tables -> system_health_collector
+            - blocking_BlockedProcessReport -> process_blocked_process_xml
+            - deadlocks (sp_BlitzLock output) -> process_deadlock_xml
+            */
+            UPDATE ttc
+            SET ttc.retention_date = DATEADD(DAY, -cs.retention_days, SYSDATETIME())
+            FROM #tables_to_clean AS ttc
+            CROSS JOIN config.collection_schedule AS cs
+            WHERE
+            (
+                ttc.table_name LIKE N'HealthParser%'
+                AND cs.collector_name = N'system_health_collector'
+            )
+            OR
+            (
+                ttc.table_name = N'blocking_BlockedProcessReport'
+                AND cs.collector_name = N'process_blocked_process_xml'
+            )
+            OR
+            (
+                ttc.table_name = N'deadlocks'
+                AND cs.collector_name = N'process_deadlock_xml'
+            );
+        END;
 
         /*
-        Special handling for config.collection_log - keep 2x longer
+        Special handling for config.collection_log - keep 2x longer than the effective retention
         */
         INSERT INTO
             #tables_to_clean
@@ -296,7 +434,7 @@ BEGIN
             schema_name = N'config',
             table_name = N'collection_log',
             time_column_name = N'collection_time',
-            retention_date = DATEADD(DAY, -(@retention_days * 2), SYSDATETIME())
+            retention_date = DATEADD(DAY, -(@effective_retention_days * 2), SYSDATETIME())
         WHERE EXISTS
         (
             SELECT
@@ -486,13 +624,19 @@ GO
 
 PRINT 'Data retention procedure created successfully (DYNAMIC VERSION)';
 PRINT 'Use config.data_retention to automatically purge old monitoring data';
-PRINT 'Uses per-collector retention from config.collection_schedule when available';
-PRINT 'Falls back to @retention_days parameter for unmatched tables';
+PRINT '';
+PRINT '  @retention_days = NULL (default): respect per-collector retention in config.collection_schedule';
+PRINT '                                    (30-day fallback for unscheduled tables)';
+PRINT '  @retention_days = 0            : TRUNCATE every collect.* table';
+PRINT '  @retention_days = N (N > 0)    : override every table''s cutoff to N days';
 PRINT '';
 PRINT 'Examples:';
 PRINT '  -- Use per-collector retention (default)';
 PRINT '  EXECUTE config.data_retention @debug = 1;';
 PRINT '';
-PRINT '  -- Override fallback to 90 days for tables without schedule entries';
-PRINT '  EXECUTE config.data_retention @retention_days = 90;';
+PRINT '  -- Override every table to 7-day retention';
+PRINT '  EXECUTE config.data_retention @retention_days = 7;';
+PRINT '';
+PRINT '  -- Purge all collected data (TRUNCATE every collect.* table)';
+PRINT '  EXECUTE config.data_retention @retention_days = 0;';
 GO

From e3d2d5be196fbf9d24a6f4b21b81851209aa8f33 Mon Sep 17 00:00:00 2001
From: Erik Darling <2136037+erikdarlingdata@users.noreply.github.com>
Date: Mon, 27 Apr 2026 20:26:26 -0400
Subject: [PATCH 43/49] Surface total non-idle CPU and let alerts target it
 (#899)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

The CPU alert and headline previously only used SQL Server's scheduler
ProcessUtilization, which answers "how busy are SQL's schedulers" — not
"is the box in trouble." On a noisy host that distinction matters.

Changes (Lite):
- Overview cards now show total non-idle CPU prominently with the SQL
  number alongside, e.g. "64% (SQL 60%)". Color tracks the alert metric.
- New CpuAlertMode enum (Total / SqlOnly), default Total. Settings has a
  "measured as" dropdown next to the CPU threshold.
- Alert evaluator and tray notifications use CpuPercentForAlert and label
  the value as "Total CPU" or "SQL CPU" so users know which metric tripped.
- Persists alert_cpu_mode in settings.json.

No data model or schema changes — sqlserver_cpu_utilization and
other_process_cpu_utilization were already collected; only the
presentation/alert layer needed work. Dashboard mirror is a follow-up.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
---
 Lite/App.xaml.cs                           | 12 ++++++
 Lite/MainWindow.xaml.cs                    | 16 ++++----
 Lite/Services/LocalDataService.Overview.cs | 44 +++++++++++++++++++---
 Lite/Windows/SettingsWindow.xaml           |  9 +++--
 Lite/Windows/SettingsWindow.xaml.cs        | 10 ++++-
 5 files changed, 74 insertions(+), 17 deletions(-)

diff --git a/Lite/App.xaml.cs b/Lite/App.xaml.cs
index 8583a087..0164df15 100644
--- a/Lite/App.xaml.cs
+++ b/Lite/App.xaml.cs
@@ -17,6 +17,14 @@
 
 namespace PerformanceMonitorLite;
 
+public enum CpuAlertMode
+{
+    /// <summary>sql_server_cpu + other_process_cpu — matches OS user+system, "is the box in trouble".</summary>
+    Total,
+    /// <summary>SQL Server scheduler ProcessUtilization only.</summary>
+    SqlOnly
+}
+
 public partial class App : Application
 {
     [DllImport("shell32.dll", SetLastError = true)]
@@ -71,6 +79,8 @@ public partial class App : Application
     public static bool NotifyConnectionChanges { get; set; } = true;
     public static bool AlertCpuEnabled { get; set; } = true;
     public static int AlertCpuThreshold { get; set; } = 80;
+    /// <summary>Which CPU metric the alert evaluates against. Total = sql_server_cpu + other_process_cpu (matches OS user+system). SqlOnly = SQL Server scheduler %.</summary>
+    public static CpuAlertMode AlertCpuMode { get; set; } = CpuAlertMode.Total;
     public static bool AlertBlockingEnabled { get; set; } = true;
     public static int AlertBlockingThreshold { get; set; } = 1;
     public static bool AlertDeadlockEnabled { get; set; } = true;
@@ -323,6 +333,8 @@ public static void LoadAlertSettings()
             if (root.TryGetProperty("notify_connection_changes", out v)) NotifyConnectionChanges = v.GetBoolean();
             if (root.TryGetProperty("alert_cpu_enabled", out v)) AlertCpuEnabled = v.GetBoolean();
             if (root.TryGetProperty("alert_cpu_threshold", out v)) AlertCpuThreshold = v.GetInt32();
+            if (root.TryGetProperty("alert_cpu_mode", out v) && Enum.TryParse<CpuAlertMode>(v.GetString(), out var mode))
+                AlertCpuMode = mode;
             if (root.TryGetProperty("alert_blocking_enabled", out v)) AlertBlockingEnabled = v.GetBoolean();
             if (root.TryGetProperty("alert_blocking_threshold", out v)) AlertBlockingThreshold = v.GetInt32();
             if (root.TryGetProperty("alert_deadlock_enabled", out v)) AlertDeadlockEnabled = v.GetBoolean();
diff --git a/Lite/MainWindow.xaml.cs b/Lite/MainWindow.xaml.cs
index 59819afd..28254627 100644
--- a/Lite/MainWindow.xaml.cs
+++ b/Lite/MainWindow.xaml.cs
@@ -1288,10 +1288,12 @@ private async void CheckPerformanceAlerts(ServerSummaryItem summary)
         /* Skip popup/email alerts if user has acknowledged or silenced this server */
         bool suppressPopups = !_alertStateService.ShouldShowAlerts(key);
 
-        /* CPU alerts */
+        /* CPU alerts — uses the metric the user selected (Total non-idle CPU by default, or SQL Server only). */
+        var alertCpuValue = summary.CpuPercentForAlert;
+        string cpuMetricLabel = App.AlertCpuMode == CpuAlertMode.Total ? "Total CPU" : "SQL CPU";
         bool cpuExceeded = App.AlertCpuEnabled
-            && summary.CpuPercent.HasValue
-            && summary.CpuPercent.Value >= App.AlertCpuThreshold;
+            && alertCpuValue.HasValue
+            && alertCpuValue.Value >= App.AlertCpuThreshold;
 
         if (cpuExceeded)
         {
@@ -1306,16 +1308,16 @@ private async void CheckPerformanceAlerts(ServerSummaryItem summary)
                 {
                     _trayService.ShowNotification(
                         "High CPU",
-                        $"{summary.DisplayName}: CPU at {summary.CpuPercent:F0}% (threshold: {App.AlertCpuThreshold}%)",
+                        $"{summary.DisplayName}: {cpuMetricLabel} at {alertCpuValue:F0}% (threshold: {App.AlertCpuThreshold}%)",
                         Hardcodet.Wpf.TaskbarNotification.BalloonIcon.Warning);
                 }
 
-                var cpuDetailText = $"  CPU: {summary.CpuPercent:F0}%\n  Threshold: {App.AlertCpuThreshold}%";
+                var cpuDetailText = $"  {cpuMetricLabel}: {alertCpuValue:F0}%\n  Threshold: {App.AlertCpuThreshold}%";
 
                 await _emailAlertService.TrySendAlertEmailAsync(
                     "High CPU",
                     summary.DisplayName,
-                    $"{summary.CpuPercent:F0}%",
+                    $"{alertCpuValue:F0}%",
                     $"{App.AlertCpuThreshold}%",
                     summary.ServerId,
                     muted: isMuted,
@@ -1327,7 +1329,7 @@ await _emailAlertService.TrySendAlertEmailAsync(
             _activeCpuAlert[key] = false;
             _trayService.ShowNotification(
                 "CPU Resolved",
-                $"{summary.DisplayName}: CPU back to {summary.CpuPercent:F0}%",
+                $"{summary.DisplayName}: {cpuMetricLabel} back to {alertCpuValue:F0}%",
                 Hardcodet.Wpf.TaskbarNotification.BalloonIcon.Info);
         }
 
diff --git a/Lite/Services/LocalDataService.Overview.cs b/Lite/Services/LocalDataService.Overview.cs
index eee8a893..104b9e20 100644
--- a/Lite/Services/LocalDataService.Overview.cs
+++ b/Lite/Services/LocalDataService.Overview.cs
@@ -24,16 +24,18 @@ public partial class LocalDataService
         using var connection = await OpenConnectionAsync();
 
         double? cpuPercent = null;
+        double? otherProcessCpuPercent = null;
         double? memoryMb = null;
         int blockingCount = 0;
         int deadlockCount = 0;
         DateTime? lastCollection = null;
 
-        /* Latest CPU */
+        /* Latest CPU — read both SQL Server CPU and other-process CPU so the UI can surface
+           total non-idle CPU alongside the SQL-only number. */
         using (var cmd = connection.CreateCommand())
         {
             cmd.CommandText = @"
-SELECT sqlserver_cpu_utilization, sample_time
+SELECT sqlserver_cpu_utilization, other_process_cpu_utilization, sample_time
 FROM v_cpu_utilization_stats
 WHERE server_id = $1
 ORDER BY sample_time DESC
@@ -43,7 +45,8 @@ ORDER BY sample_time DESC
             if (await reader.ReadAsync())
             {
                 cpuPercent = reader.IsDBNull(0) ? null : ToDouble(reader.GetValue(0));
-                lastCollection = reader.IsDBNull(1) ? null : reader.GetDateTime(1);
+                otherProcessCpuPercent = reader.IsDBNull(1) ? null : ToDouble(reader.GetValue(1));
+                lastCollection = reader.IsDBNull(2) ? null : reader.GetDateTime(2);
             }
         }
 
@@ -112,6 +115,7 @@ FROM v_collection_log
             DisplayName = displayName,
             ServerId = serverId,
             CpuPercent = cpuPercent,
+            OtherProcessCpuPercent = otherProcessCpuPercent,
             MemoryMb = memoryMb,
             BlockingCount = blockingCount,
             DeadlockCount = deadlockCount,
@@ -128,13 +132,34 @@ public class ServerSummaryItem
     public bool? IsOnline { get; set; }
     /// <summary>True when the server is reachable but one or more collectors have consecutive errors.</summary>
     public bool HasCollectorErrors { get; set; }
+    /// <summary>SQL Server scheduler ProcessUtilization from sys.dm_os_ring_buffers. NULL on Azure SQL DB.</summary>
     public double? CpuPercent { get; set; }
+    /// <summary>Non-SQL-Server CPU on the host (computed as 100 - SystemIdle - ProcessUtilization). NULL on Azure SQL DB.</summary>
+    public double? OtherProcessCpuPercent { get; set; }
+    /// <summary>Total non-idle CPU on the host = sql_server + other_process. Tracks closer to OS user+system counters.</summary>
+    public double? TotalCpuPercent =>
+        CpuPercent.HasValue ? CpuPercent.Value + (OtherProcessCpuPercent ?? 0) : null;
+    /// <summary>The CPU value the alert evaluator and headline display use. Driven by App.AlertCpuMode.</summary>
+    public double? CpuPercentForAlert =>
+        App.AlertCpuMode == CpuAlertMode.Total ? (TotalCpuPercent ?? CpuPercent) : CpuPercent;
     public double? MemoryMb { get; set; }
     public int BlockingCount { get; set; }
     public int DeadlockCount { get; set; }
     public DateTime? LastCollectionTime { get; set; }
 
-    public string CpuDisplay => CpuPercent.HasValue ? $"{CpuPercent:F0}%" : "--";
+    /// <summary>
+    /// Headline CPU display. Shows total non-idle CPU prominently with the SQL-only number alongside,
+    /// e.g. "64% (SQL 60%)". Falls back to a single number when only one value is available.
+    /// </summary>
+    public string CpuDisplay
+    {
+        get
+        {
+            if (!CpuPercent.HasValue) return "--";
+            if (!OtherProcessCpuPercent.HasValue) return $"{CpuPercent:F0}%";
+            return $"{TotalCpuPercent:F0}% (SQL {CpuPercent:F0}%)";
+        }
+    }
     public string MemoryDisplay => MemoryMb.HasValue ? $"{MemoryMb / 1024.0:F1} GB" : "--";
     public string BlockingDisplay => BlockingCount > 0 ? BlockingCount.ToString() : "0";
     public string DeadlockDisplay => DeadlockCount > 0 ? DeadlockCount.ToString() : "0";
@@ -158,14 +183,21 @@ public class ServerSummaryItem
     public bool IsOffline => IsOnline == false;
 
     /* Color coding */
-    public SolidColorBrush CpuBrush => MakeBrush(CpuPercent >= 80 ? "#E57373" : CpuPercent >= 50 ? "#FFB74D" : "#81C784");
+    public SolidColorBrush CpuBrush
+    {
+        get
+        {
+            var v = CpuPercentForAlert;
+            return MakeBrush(v >= 80 ? "#E57373" : v >= 50 ? "#FFB74D" : "#81C784");
+        }
+    }
     public SolidColorBrush BlockingBrush => MakeBrush(BlockingCount > 0 ? "#FFB74D" : "#81C784");
     public SolidColorBrush DeadlockBrush => MakeBrush(DeadlockCount > 0 ? "#E57373" : "#81C784");
     public SolidColorBrush CardBorderBrush => MakeBrush(
         IsOnline == false ? "#E57373" :
         DeadlockCount > 0 ? "#E57373" :
         BlockingCount > 0 ? "#FFB74D" :
-        CpuPercent >= 80 ? "#FFB74D" :
+        CpuPercentForAlert >= 80 ? "#FFB74D" :
         HasCollectorErrors ? "#FFD54F" :   // amber border when collectors are failing
         "#2a2d35");
 
diff --git a/Lite/Windows/SettingsWindow.xaml b/Lite/Windows/SettingsWindow.xaml
index f10c76e8..47fe448c 100644
--- a/Lite/Windows/SettingsWindow.xaml
+++ b/Lite/Windows/SettingsWindow.xaml
@@ -161,9 +161,12 @@
                     <TextBox x:Name="AlertCpuThresholdBox" Width="45" Text="80" Margin="6,0,0,0" VerticalAlignment="Center"/>
                     <TextBlock Text="%" VerticalAlignment="Center" Margin="2,0,0,0"
                                Foreground="{DynamicResource ForegroundBrush}"/>
-                    <TextBlock Text="(default 80% — Lite collects directly from DMVs so catches spikes faster than Dashboard)"
-                               FontSize="10" FontStyle="Italic" Foreground="{DynamicResource ForegroundMutedBrush}"
-                               VerticalAlignment="Center" Margin="8,0,0,0"/>
+                    <TextBlock Text="measured as" VerticalAlignment="Center" Margin="8,0,4,0"
+                               Foreground="{DynamicResource ForegroundBrush}"/>
+                    <ComboBox x:Name="AlertCpuModeBox" Width="220" VerticalAlignment="Center">
+                        <ComboBoxItem Content="Total non-idle CPU (SQL + other processes)" Tag="Total"/>
+                        <ComboBoxItem Content="SQL Server only (scheduler %)" Tag="SqlOnly"/>
+                    </ComboBox>
                 </StackPanel>
                 <StackPanel Orientation="Horizontal" Margin="20,6,0,0">
                     <CheckBox x:Name="AlertBlockingCheckBox" Content="Blocking sessions &#x2265;" VerticalAlignment="Center"
diff --git a/Lite/Windows/SettingsWindow.xaml.cs b/Lite/Windows/SettingsWindow.xaml.cs
index c0c8f24e..d619aa2d 100644
--- a/Lite/Windows/SettingsWindow.xaml.cs
+++ b/Lite/Windows/SettingsWindow.xaml.cs
@@ -576,6 +576,7 @@ private void LoadAlertSettings()
         NotifyConnectionCheckBox.IsChecked = App.NotifyConnectionChanges;
         AlertCpuCheckBox.IsChecked = App.AlertCpuEnabled;
         AlertCpuThresholdBox.Text = App.AlertCpuThreshold.ToString();
+        AlertCpuModeBox.SelectedIndex = App.AlertCpuMode == CpuAlertMode.SqlOnly ? 1 : 0;
         AlertBlockingCheckBox.IsChecked = App.AlertBlockingEnabled;
         AlertBlockingThresholdBox.Text = App.AlertBlockingThreshold.ToString();
         AlertDeadlockCheckBox.IsChecked = App.AlertDeadlockEnabled;
@@ -615,6 +616,7 @@ private bool SaveAlertSettings()
         App.AlertCpuEnabled = AlertCpuCheckBox.IsChecked == true;
         if (int.TryParse(AlertCpuThresholdBox.Text, out var cpu) && cpu > 0 && cpu <= 100)
             App.AlertCpuThreshold = cpu;
+        App.AlertCpuMode = AlertCpuModeBox.SelectedIndex == 1 ? CpuAlertMode.SqlOnly : CpuAlertMode.Total;
         App.AlertBlockingEnabled = AlertBlockingCheckBox.IsChecked == true;
         if (int.TryParse(AlertBlockingThresholdBox.Text, out var blocking) && blocking > 0)
             App.AlertBlockingThreshold = blocking;
@@ -675,6 +677,7 @@ private bool SaveAlertSettings()
             root["notify_connection_changes"] = App.NotifyConnectionChanges;
             root["alert_cpu_enabled"] = App.AlertCpuEnabled;
             root["alert_cpu_threshold"] = App.AlertCpuThreshold;
+            root["alert_cpu_mode"] = App.AlertCpuMode.ToString();
             root["alert_blocking_enabled"] = App.AlertBlockingEnabled;
             root["alert_blocking_threshold"] = App.AlertBlockingThreshold;
             root["alert_deadlock_enabled"] = App.AlertDeadlockEnabled;
@@ -728,6 +731,7 @@ private void AlertsEnabledCheckBox_Changed(object sender, RoutedEventArgs e)
     private void RestoreAlertDefaultsButton_Click(object sender, RoutedEventArgs e)
     {
         AlertCpuThresholdBox.Text = "80";
+        AlertCpuModeBox.SelectedIndex = 0; // Total
         AlertBlockingThresholdBox.Text = "1";
         AlertDeadlockThresholdBox.Text = "1";
         AlertPoisonWaitThresholdBox.Text = "500";
@@ -753,7 +757,10 @@ private void UpdateAlertPreviewText()
         var parts = new System.Collections.Generic.List<string>();
 
         if (AlertCpuCheckBox.IsChecked == true)
-            parts.Add($"CPU > {AlertCpuThresholdBox.Text}%");
+        {
+            string cpuLabel = AlertCpuModeBox.SelectedIndex == 1 ? "SQL CPU" : "Total CPU";
+            parts.Add($"{cpuLabel} > {AlertCpuThresholdBox.Text}%");
+        }
         if (AlertBlockingCheckBox.IsChecked == true)
             parts.Add($"blocking >= {AlertBlockingThresholdBox.Text}");
         if (AlertDeadlockCheckBox.IsChecked == true)
@@ -778,6 +785,7 @@ private void UpdateAlertControlStates()
         NotifyConnectionCheckBox.IsEnabled = enabled;
         AlertCpuCheckBox.IsEnabled = enabled;
         AlertCpuThresholdBox.IsEnabled = enabled;
+        AlertCpuModeBox.IsEnabled = enabled;
         AlertBlockingCheckBox.IsEnabled = enabled;
         AlertBlockingThresholdBox.IsEnabled = enabled;
         AlertDeadlockCheckBox.IsEnabled = enabled;

From 0c9303ebfbf31236a4b719eb6b9a153f9787bc62 Mon Sep 17 00:00:00 2001
From: Erik Darling <2136037+erikdarlingdata@users.noreply.github.com>
Date: Mon, 27 Apr 2026 21:20:29 -0400
Subject: [PATCH 44/49] Sync columnstore icon routing + Parallelism subtype
 icons from PerformanceStudio

Ports PerformanceStudio PRs #285 and #288 (net result; the temporary R/D/G
overlay from #285 was replaced by real icons in #288).

PlanIconMapper.GetIconName now takes optional storageType and logicalOp:
- Columnstore scans (Clustered/Index Scan with Storage="ColumnStore" on the
  Object element) route to the columnstore_index_* icons. Covers both CCI
  and NCCI for scan/delete/insert/update/merge.
- The three Parallelism subtypes (Repartition/Distribute/Gather Streams)
  route to their own icons instead of all sharing parallelism.png.

ShowPlanParser: the IconName assignment moves from immediately after PhysicalOp
parsing to after StorageType and LogicalOp are populated, so the new routing
has the inputs it needs.

Three new icons (MIT-licensed contribution from @rferraton via PS #288) added
to both Dashboard and Lite Resources/PlanIcons. The existing Resource glob
in each csproj picks them up automatically.

Last upstream sync from PerformanceStudio was 2026-04-16 (#856), scoped to
PlanAnalyzer + BenefitScorer. This is a follow-up scoped to plan-viewer
icon routing.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
---
 .../parallelism_distribute_streams.png        | Bin 0 -> 8276 bytes
 .../PlanIcons/parallelism_gather_streams.png  | Bin 0 -> 8311 bytes
 .../parallelism_repartition_streams.png       | Bin 0 -> 10650 bytes
 Dashboard/Services/PlanIconMapper.cs          |  38 +++++++++++++++++-
 Dashboard/Services/ShowPlanParser.cs          |  11 ++++-
 .../parallelism_distribute_streams.png        | Bin 0 -> 8276 bytes
 .../PlanIcons/parallelism_gather_streams.png  | Bin 0 -> 8311 bytes
 .../parallelism_repartition_streams.png       | Bin 0 -> 10650 bytes
 Lite/Services/PlanIconMapper.cs               |  38 +++++++++++++++++-
 Lite/Services/ShowPlanParser.cs               |  11 ++++-
 10 files changed, 92 insertions(+), 6 deletions(-)
 create mode 100644 Dashboard/Resources/PlanIcons/parallelism_distribute_streams.png
 create mode 100644 Dashboard/Resources/PlanIcons/parallelism_gather_streams.png
 create mode 100644 Dashboard/Resources/PlanIcons/parallelism_repartition_streams.png
 create mode 100644 Lite/Resources/PlanIcons/parallelism_distribute_streams.png
 create mode 100644 Lite/Resources/PlanIcons/parallelism_gather_streams.png
 create mode 100644 Lite/Resources/PlanIcons/parallelism_repartition_streams.png

diff --git a/Dashboard/Resources/PlanIcons/parallelism_distribute_streams.png b/Dashboard/Resources/PlanIcons/parallelism_distribute_streams.png
new file mode 100644
index 0000000000000000000000000000000000000000..f85dd59f1f5131006ba3efdf14fc1f347ef3a701
GIT binary patch
literal 8276
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
F{U4F4DXstj

literal 0
HcmV?d00001

diff --git a/Dashboard/Resources/PlanIcons/parallelism_gather_streams.png b/Dashboard/Resources/PlanIcons/parallelism_gather_streams.png
new file mode 100644
index 0000000000000000000000000000000000000000..14078f719732e95ce831c558c517a9e4c1ecf321
GIT binary patch
literal 8311
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
BNumG%

literal 0
HcmV?d00001

diff --git a/Dashboard/Resources/PlanIcons/parallelism_repartition_streams.png b/Dashboard/Resources/PlanIcons/parallelism_repartition_streams.png
new file mode 100644
index 0000000000000000000000000000000000000000..bda974d6fd4b67fd8e5edf56f151cc345e6c39a1
GIT binary patch
literal 10650
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
AF#rGn

literal 0
HcmV?d00001

diff --git a/Dashboard/Services/PlanIconMapper.cs b/Dashboard/Services/PlanIconMapper.cs
index 6ed411e3..c83e8b05 100644
--- a/Dashboard/Services/PlanIconMapper.cs
+++ b/Dashboard/Services/PlanIconMapper.cs
@@ -175,8 +175,44 @@ public static class PlanIconMapper
         ["Language Construct Catch All"] = "language_construct_catch_all",
     };
 
-    public static string GetIconName(string physicalOp)
+    public static string GetIconName(string physicalOp, string? storageType = null, string? logicalOp = null)
     {
+        // Parallelism subtypes: PhysicalOp="Parallelism" + LogicalOp identifies which.
+        if (string.Equals(physicalOp, "Parallelism", StringComparison.Ordinal) && logicalOp != null)
+        {
+            switch (logicalOp)
+            {
+                case "Repartition Streams": return "parallelism_repartition_streams";
+                case "Distribute Streams":  return "parallelism_distribute_streams";
+                case "Gather Streams":      return "parallelism_gather_streams";
+            }
+        }
+
+        // Columnstore scans surface as PhysicalOp="Clustered Index Scan" / "Index Scan"
+        // with Storage="ColumnStore" on the Object element. Route to the columnstore icon.
+        if (string.Equals(storageType, "ColumnStore", StringComparison.OrdinalIgnoreCase))
+        {
+            switch (physicalOp)
+            {
+                case "Clustered Index Scan":
+                case "Index Scan":
+                case "Columnstore Index Scan":
+                    return "columnstore_index_scan";
+                case "Clustered Index Delete":
+                case "Index Delete":
+                    return "columnstore_index_delete";
+                case "Clustered Index Insert":
+                case "Index Insert":
+                    return "columnstore_index_insert";
+                case "Clustered Index Update":
+                case "Index Update":
+                    return "columnstore_index_update";
+                case "Clustered Index Merge":
+                case "Index Merge":
+                    return "columnstore_index_merge";
+            }
+        }
+
         if (IconMap.TryGetValue(physicalOp, out var iconName))
             return iconName;
 
diff --git a/Dashboard/Services/ShowPlanParser.cs b/Dashboard/Services/ShowPlanParser.cs
index d99793ec..5d56c894 100644
--- a/Dashboard/Services/ShowPlanParser.cs
+++ b/Dashboard/Services/ShowPlanParser.cs
@@ -665,8 +665,10 @@ private static PlanNode ParseRelOp(XElement relOpEl)
             node.PhysicalOp = "Lazy " + node.PhysicalOp;
         }
 
-        // Map to icon
-        node.IconName = PlanIconMapper.GetIconName(node.PhysicalOp);
+        // Icon mapping is deferred until after StorageType and LogicalOp are
+        // parsed below, so columnstore scans (Clustered/Index Scan with
+        // Storage="ColumnStore") and Parallelism subtypes route to their
+        // specific icons.
 
         // Handle operator-specific element
         var physicalOpEl = GetOperatorElement(relOpEl);
@@ -1365,6 +1367,11 @@ private static PlanNode ParseRelOp(XElement relOpEl)
             }
         }
 
+        // Map to icon — done here so columnstore scans (Clustered/Index Scan
+        // with Storage="ColumnStore") and Parallelism subtypes (which depend on
+        // LogicalOp) can be routed to their specific icons.
+        node.IconName = PlanIconMapper.GetIconName(node.PhysicalOp, node.StorageType, node.LogicalOp);
+
         // Recurse into child RelOps
         foreach (var childRelOp in FindChildRelOps(relOpEl))
         {
diff --git a/Lite/Resources/PlanIcons/parallelism_distribute_streams.png b/Lite/Resources/PlanIcons/parallelism_distribute_streams.png
new file mode 100644
index 0000000000000000000000000000000000000000..f85dd59f1f5131006ba3efdf14fc1f347ef3a701
GIT binary patch
literal 8276
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
F{U4F4DXstj

literal 0
HcmV?d00001

diff --git a/Lite/Resources/PlanIcons/parallelism_gather_streams.png b/Lite/Resources/PlanIcons/parallelism_gather_streams.png
new file mode 100644
index 0000000000000000000000000000000000000000..14078f719732e95ce831c558c517a9e4c1ecf321
GIT binary patch
literal 8311
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
BNumG%

literal 0
HcmV?d00001

diff --git a/Lite/Resources/PlanIcons/parallelism_repartition_streams.png b/Lite/Resources/PlanIcons/parallelism_repartition_streams.png
new file mode 100644
index 0000000000000000000000000000000000000000..bda974d6fd4b67fd8e5edf56f151cc345e6c39a1
GIT binary patch
literal 10650
zcmV;LDP`7)P)<h;3K|Lk000e1NJLTq0046U003GD1^@s6i{NP(00001b5ch_0olnc
ze*gdg1ZP1_K>z@;j|==^1poj5AY({UO#lFTCIA3{ga82g0001h=l}q9FaQARU;qF*
zm;eA5aGbhPJOBUy32;bRa{vGi!vFvd!vV){sAK>D00(qQO+^Rl1R4PeGv5C*7XSbt
z07*naRCwC$oq3#GRk6pvb#C`;$s{vL$OdF1WW^9<M?naSvWb8J**B2@f(o+9u08}2
zo`UG(u`48mKp<d15K-A>S4klI9<q>3lF3Z>boV{={<uq@+uf67q6B!KoP7F|>D%4+
zo?BI?mS0t!EBptB_5EEGIa~w}ctJ#777=CZ*yzZ$<<hBi>QrEWwf62*Dz)HKnMgjL
z_pG(oSZj0ES`A<8t+fNTvT5U^kk5Cs);?o{q1M`kg+ig<mY+x=-^E({gfkKM^|h_6
z+VJpwe}J|2{R*_3>ifQIv58n~`&(<@tT2(_<@?8NW!DDjw~MuQQ9JZ2SZjCKob#H^
zn8;}0Wnj1XSgCassou)6cIkI0@Hb$)Sj)KtR6L;HC(cZ3{o{bYx)WKKDR9rT3riVV
zvz2Yh(WWZa+H-*?fcoh8s&zSj`Q$t_qF<n38#d<}sZE+lTi#2jy&nPB04WhcRax?J
zhN~W#3u^gx@+Vt8+2m?Wp?VuIE@l@nXX$#r|KLm-Yt3fyrNcie6bhY;m<NGx6xFKo
z{=BuE|KJQ3WG!R*)H+iP?E6+0#*R)mU_9_uSJGdfwu*Bn&7rBS!2Y#$C<zkEf1H`V
z?++J|@xW+t?Bg?Ue8hMEun21{sD`iN6jb$?e7>+8v=dMxA_c%#)fz#vpwn~t{0DV)
zb^ouJp3CK`j4?Z^YG1$;kzOKlmB3&HM1+EGnf&q+F8<?UP{oK~RTJE^)*qM4<+_VV
zXI0GsIT2|CEKmr~?TbhTv{}S_XpC8y+5jUD5Rpkh_eh#@1<QTUE#zmft^n&JA{Avw
zM2_%0IbuVar^fT9`@VmZ@B0&~s;d0Yxf&e^`~Wy1q?c5(IjwC4?wB&0+um(L02NRK
zk))b6#yh|m4%oD-3qYH-_FJiTCU+umH&7cLTeCjL4Uf!X;+$qAlrjyMV@D07fKk{<
zM1G%2rOxnu{{+wTR(wtwc?R$+*Qu#ARyXIk{^40XF~1p61(9GegapxmtsSLfMEh!B
z{{%Bt)u`(Az>i!{cj1Z_F8SRIUR%|M2{;*^L^kU0h*0#@Dt~*7h)l`n^9QBV>6XtK
zBfkawZ@cD7KrPH)-onKX&EoA<*+_FaCJ8*D!;Gvz$1W*HPj^+-dw^rzZ@e?JiSs7R
zW@)zITrQ9zC6K6PEtaW&Uz+5cNSPFg2vwfYuU8#|x2+EZBapAXJkPrc`0nS&v9Y@X
zcLAwrg)Cgr%Dj(Su%REJs<gKGT=mB#H03RnSf%Lpm#!}`<+UXNLnX1gHn2j3!}jb=
z+KYdn5=z*%z*E33(ZsC6A71~63!YktqTw>tqGToHLIVA-k?M`4PvWmdYdN@2<=jyX
zTy*RZs?)~xfR8f9O#K{qsNF^64Pa1oY|1N3`Q9Iwgn}O4wt}i3Fe!8pC8T5I@<iX&
zl7&*bP-DJ^D%w|=dEM^RRe8}@erK$;qkuPnT_Sd6bC%m4pUDMN7outjSmf$?EnYlg
ztOg8|aGC;`@V#-41rC|=+kZAO{)GjuNO-`#g+gKAXFB+AYfFj911=-qo883so>>fP
z5e;b-u1*P;L7-VRqGV!a3Psu(1c{G1ub975j3AO6_Y810(APaW>BU9d^42Qw{a9{9
zBPmK+%SdEgD;hIS9nG#92u64wQRUjdE#vJOtKCcY6p;z}LLv28Wo9asx*Ry%MQ|>C
zbRHUpX9^UPe;Th;S7nN8g)~XufXI&UyP=<R0x37KVyv~l0p_|#PdK0-HyqF>zJ4SG
zs!HW7rNm*Th{UQSxVr!?ilo(*Cjl;cWDd)lvTj(jr)SK6eMTLgeMIEy=zZQ-eldAA
zGn#Y7dk$@7K>YCDomC_yoKRQIYLV&1KVt*s(6pip)Y+s`sSi|jFW}G7(X?kc`QQQk
z{)EBQcwQ(h;fcgyUwmOroLo^ym^8eh5)~0H-36_AZhCAMxq@|-#>Kwxf8#U8$Zo*z
zfhq~T`6pgl#DrPR4kKfJqH3|$4~1V6G%5>1qs3BUKQ(qaBwWBne<X-a#f?O2#WCu2
zB61gSqBs|yv1lFVJ@6s3*XI#q9Q9C~&&Y-}*L;0o(h;i=54}5k4L7{9JP?HNM5-W0
z_{jm=a>_x8WWgF$-P!ZJg`WY3$AkdNG10MU^VV|M-5(THriMbTaKg|o9RH<02tux4
z`T5j^ycvfj<>w#KCB@Z84#YD>;>Ij@R9VvP6m}ibEijY;GyfXfCeQO)^ZER#p6AU|
z^ol6X9J+lM9y;#}{OG|Cd0|<ms6L#@^r%a-+tBWqjf6_02RAZ(NeffvuP=JJ;cu?~
z%Tjh4P|q%d8>6o`h{%L|K0hX%PPcuU%oLFy0>?yN=BjmV{P5vfft{10twfa_I;FYz
z=)v^pQXQ++JGbr3k0;FFiTSO8sd9uFps_a1p2NErL4?Y{z($ov0!K=x)4nn0DwNZK
zOmw_=w_0vH`wN^tq9Ifxj%`3uYs)-oARpq0@m#7>hAWO6Lf@KHi8~(r`l5+*S+OR;
zw|zX%yYf?3uX_*xDJV+8x7<EuF4NcL14f1_FrvlJj|&*-uCZ?Q)%@)Ak$iWT#@H4X
zZK>-vmceu#LDzB>^O?pozXv@Sh>MHrYg1f#!f>wMueW2cwY{r-6vBabhqkym7L3Lk
zZW+4+BBlg{Q0BGdxbd-B<O_+DUg7)x!Jnd?oP<c6pMC0;CEPQ8O=#n!$PlYsvtJ*+
zxMO2QCe&7W{NUIj+%TpO7*k|mWfEpU7XizG^#W}KuWa~#E__ADGr$||CZ~<@UIF$3
z-ijud_JlJI9mIWO2T|q1dgZgZ-WYS9G3HzmIYgD=!0hP5y+(BB^1Zi7cyN(_G<oiN
z9{Jm%L^L2G_xrxzYs)gy_fYP^$@)*9zmD%cvp9$e9kfeT`RewaIPt&%?)u88>UV(O
z0#*Re2qzvifcwV|qS`Z#^O(?63S1~614N{+h%_S7RYV#j_`j<_BhV-!4T3ZZboD&%
z+6`737-N<J2Lg`}TT2-8#oj!5&PaCboDO0hQ+AqFj=fROGfRLIBh@XyX<r?{!P|B!
z8h0%!m#hE!5%0}za?jUSL~bt>3T6vh%1e-94tI5Pj*BPGcD&J|1b0q*Ts3wGHAOT_
zfr~xQyGumQ2Y#XfT7n?#Ke{K6pEZmDozjT$5|Bzb7K?}tUj-3q6OpWl<V2)RjA=E-
zw2DYpjAX=^JZwVQh%siJh<ppUI)rZk7~a1t51sb~jvUZ{Z?$xB7Al<QP2lo~3bj=p
z*BrMaojv0~ez9l9WslCGX?@<c!rv5;YciQkUA8S-+t$`ro6TlBXS3P*OeRyCZELG-
zYip~|WU_UcOr|QE&34XYGIg13E}h9_YO~pFZ8n>&%49OtnM|fGo6T0Ywr11WY_?N2
zo2_rl<!Y?8rnR+IeBb{%aJ?H(-ZFU()7NGbbBzAodSpNP^{jJm_h}KiGZJQF%yk4+
z29XEJhyh(0KW-%Z_N+p!B|$;myySj|pnB{3$AjF95YN1&&F9e<7jf!A17gTY;aFqL
z<T8|BRaEtH;Hc=>pWj)=nUm%g0f$h1iwLI-?ZQ<j4kK+$bhD~TRwT|+c;P)n!jlRy
z-U3h+3SSOLJNU1JLhOg1S3Bp(0PBI?;kf}A|NMNe`14YXB-f->%XfC}!4=03jWZvL
zt^js5#w@O2gLeZax=`S{);tfqu!!#-J}8dXP>wL3dHNG&W*BpQSwtQKdPZu)mIlIb
zk}+m{J5I&+p&jlS`VHLr=nQUuXEi1UM}j|8Ew>%fpCk6_lW^Ok8l=sY-j4k8%@0@c
z%?IZoejyaLU|t9e>r%z|^GDIxxyn_q->f9a&i(fX{s;_<k13^L-O<LFCpvm>9kxN9
z=e?||`vKER!rO%NwgI)h2sk&QsS!Bmh#lCgM-5gr&N-;{QG_2nHIGFrGchxT&1Yl>
zU4627%hiv~LafDjrkF%F236(8v4dSk0{nVIj12F80q_;zrTCcqThrY9mFcX|dJ%aL
z_<Dtp&osu|w-LAhE+`iD&0MsOL+|_`s4JqFc|UL09{k`NgGqV8YHiE=tXQ4Jx0X1i
zEA6NLIzj{yp`pHt`r1^Sz5B<UH5_x_3{Z=T39`+=^<%c<lrh_3BsKy61okq<WHvGE
zsRteejx6DWq8w;E^Or5gOb7~?QmNF>fbW;A^0SOF_ijWO8bst3U_^B6@s}6#{izEu
z;-NslT6prJU1{iCg|(KqXEbrm6Z83?IgcPjr85a+Sd%&2#BEA(WvgmYrHA;j0G-k)
zt{u~dqxb0(2oP}3ALsCs7ng$saOOdMYq|aGov2BBk=kxn)qOnAd%r_k!uL}uauY%Q
zkPDQKF~<D$6IZkDsH&>U<@5PVRdre^pEp5WuK`X#i%8RvdvD7LLmPvHt|;g2yDeSo
zQlQGTd22cL{uxYP+ZK9~7S-UDNbkhCz7XJ#k_6%RtVX|!!2e>FLlv5H1ulMOA>*H)
z7pwEb_ShEdrBUlsYlLgY4xuLPx$ye;JIY7^@w`HzP`FQ3ZOKQQ)e-P-G1FSVDxFUM
zMnt|)`q3s`+?anNTo<jUlqXzt)F8I237pi?gSv(e2i*1i62!^aMEO$DAU7&e4p2xY
zcOxv+Wp-$%+{{mL+7=P`@#||?-5i8Qy&9|8qtOEqZatzO+i#O_2_}iieVaqSLZQ$r
zl}g<uB3_BMtl6T>wAS_nc^3Fir5tVtZs=Cv+30=G#u{!uZU|PPu|5q7nY_;v^P3Z@
z(@h4egQSR?o{Je-L|DpEP;rF7V8kFOg?x^AA2r9e^o!fq^X<{SIC!_-?vLL`b=>Ck
zqFQSQ8j-(*C|j8o+G5PK)(#83vHjcmN~aE}>H=`Giv#aHyc-wo-i_)i4}<`e2vcQc
zH5Cbg7B{~eFUImLh*OFoC6yB)R3{?%e(|#&ojuO`+V)PGiWcBh<9SV+;XLjQye1;U
z+xg0tS((<_uL7?CL!x7?ZT`PC8Dq?<5bleSqq7d(ftspRTnrW4ICYc2PRh3|6G5`p
z#zk(FvMNz62RIVvI_@j|=-#C&3Xv4mTZ}R9ZU+5M5RpFvy`o99WdAcY;G4|MTrOv<
zwLc`N;_DV2U$ipA<-eanM;)LF41E>2BhJ#)c+{jrw_nP`FLhFIk-ZbNn4)vzUrl~r
ztwp2O3N-0RDU>a5prI~RRPXQ#B0uYp=c;O~wU-i9E7V3Y$l{MPTzKEi(#z#HhncBO
zR10+?ayLQweLUWqy_#_o=22gMmcr(#Z@t_Y83i1m72_vCvHbXeJ`C8VE>TD<0=|V`
zKDU^EtZAcI*XYz_prl3l@2?M_zSb+2f`;c=vp&a#e^`uQK}_Yc0BA<_Y~y*^4y?u+
zRsCP!lqCI{IB&un)|WR*n@@z9zVB}%B98+5x$x5;-~5PkAD@R+7~VBq`m_4YnoP>e
zT5FFB1MohT{dvP~L%K7vf0v3M5ANHE)9?O}xh;i6jgkTe;ddwP$X+E`{V1EYa!nR_
zW*O=i+6%xHxXyUqhaF(#w!j2nU-u+aUt7xgPcFn4p<BAFPIlmboSD|z;lPu?;8=ea
zEO$LUkDFdw9wW0A#?{u^lS6eIeW41a3L%S<Md%WO*#%WvBsfu3=*e|&4@+$imyPO{
z`t|C}J!cN*#5<?4w5<@Vuuz@ed;AXUJ)%bi73lmOHbj+&e(^ZRT6-8lqPPn1P?{0^
za7C%Ab`}vEzTX4r8vVE}Z@K50x!m~r$01N*LCY56b=KNbLg2qzl^TJzkQlXbrDPzG
z7S&mZ{4livMji*;iPOcqwk6MvlV&k~=DIkiC!U9RWvA%^>|Du<)Dn+GHiAPXoft)}
zR@8oO3Ta@UPTY0c5RSd)Loyb`OL52HeK=rr&x!&N5k^c9ngooLGOtL2uy%;+{KW$1
z7Quw&rlmr-x;e*xO`O5RS?hwZ$w+`?iAPC;W<6mWr8?nQ)T81sGWuXR@UJp1<nx8J
z=b4`Xmk45_NiJTQ;nD|Z@bZdGFcB%XDOk11dRS-mM1QxpqBbQ!6Gs<{5&k)^nKkR$
zKm<<$(0fR~db)S1j<2)Rzy=;VWhi5RH<Pn=>cruDZI@tTCRgCynN5NEHDE2QY0U@a
zjn*PX%ypyL7G>l2HFxPcE}JlizkeL&M2&+hw{zx79=14b4e@tG1Z(@HO6+5o(Azo^
zkmw@s&T8Vk@w0;Fp-@yL#<G-xue9cD5)-Xh+oHJrPPzfG*a&gvK6WlcZFI$-7GrHO
zdx0wZ_vy^9&KOE#eKCu%+t5btKW-qWKDLB|K3K(`Bf295AjHoenZ<q6nu1y+BQfL`
z2&lwZZ8WQbY8>xs(W{N|U@5PRjPsxG&RE5`iE~(;^J9d{C6rZ5OU@$F4vpGrtFB53
zDI<{wm={N_4kp+<VPvF!tim5&Tf+CAUX1nqguZkyCL-9-dn_#%lqf8aq>Yk<REL&V
zH7xW}4(wUQ{omUqa38Y;hF|w)F!8eZFai_|2lcJx=2M5!tv->K;@LNsarUISOg?i6
zBL+5d(<3vvf5v*SzC$TZAVP{V@ub1*HF6sOo_ci&<DOa+s78rm-!O9%AJbx?n*-__
z0WJ7R@IOIAA?oN6r=KU*2wK#F8ZIUk_~Tha7&#!eg8!WgSLANMAA&$OxRGqma@RBS
zxcT)JB)c)oTlInoYgmG<<@KMEY-@0(%|z+0IQkEPaI{P!UE3L@y^1Q>^8AukE`8tw
zZaHHFT{{&$>_c|%%`dZgPMx@jgL^M!@`6mz%v98KxNQKof?8F;i&VX8Lb;07L@iS>
zBU6lyqHDP;*gd<6n{74O78%)d$CRnHVMAA9WQ?_TClPr*Vk893Fqho>FK&K)MWR?a
zD(i5;Y*(#1eP=~XRGp?6iZvUF-^ai=anp<ulc?lQkhLVJFSZL>p8F`v6%Wl~eWs8Q
zfTQ=_p6kD|4U^}sN8C(Hgw|68<fGM5Dz=)akxh2G2_==TW!QcahLmJxF4hL>Bm;^K
zM5QOw(55Fw+Jxar!gl5hmey=O%o=G)#!wT@Ev3fMZF8Zl8%itwogkNh7%y!6D|G;@
zW3!48WRbwaX+yhE@Zs7Ar?WnrWazP9*^V0y+&00-GOtxO<cMiJ$1*3yff|jt9%w0g
zoFu0@rlPcKE=g~VZE8aJU1l0%-UE&X;@-O6-D<dP+-SbDa|6Xru9BK()e_6BMV;<Q
zP*nNuvQ9~SoDdKRRi@&okrEpMpdzSB)Gv%6oIav~D~=z+jVJBE$1MeJdSnK<e9<v8
z0w*5Wk8Ahq9XL-os|I(WR_^{LYMgaF_gI*03_T{osS@BqE10R$erlzRtS*!oJ7}fJ
zjZ}z>{>fUqX8;iBa6#x)lj8E@htaRc0<Qh*vOrG@@#YGy+u(^ZtZNm<6hZOQa*nvR
zR&@grrNj<IuP*5#G~*K2wN0kje01{AE?jop5bCNu>Z(0%K79n^9+<-|kImwTV~0@X
z1?TpRaK_gLlDEoDudOH&MI;3Et>aG?=USB(Ms=$RZM;qNJx6e2yn~M8%?t2;Q=Woq
z**PO38DOV|bZow?CjAkVvZ@L(hE&Q+BsWqH&^_B){{WCl8bVKLPdM$60rcxx%Xc1`
zOU~LNgJN!326w6AsY`Z6O3H&vLzL2tm1>2oM&h^Xc+4j73a!ttzcG;E{kkOL+TPu2
zsIBtiICGn>)f_dVGgrT`g!)bk7<X8IQeMC?&nRafI*@&ab&D(QKxkT@<BUh<6eZuG
z`&W1G!&i6fQ&A&pC8WwRL;sxJ#CIQ_%c9nN$oOzih_ExaYue+9OLh$kyR@h<O5BP>
zOe>Bv6_RpQDw(<PmRsu|400E6vWSSPa=_?bOlhd${NK%BZl;ikF%h9Em5O7k@Foht
zBA^MOT7tUOTA*{79!rPLp$JkIoL2@70*O_HfxSDiL!ZuNNKTwh0si#%a<2K?auAQ7
zzq*WS<8#(wI|N>LSk<ue;D%zDfwH103z7=%!1^T+e`1RU$}_3upG6cIy<;~X9#_Mq
zznji0D}y9}hVxKMxVck&pG$$)4YC->C|VQ3o^3!%kcJRm9ULNUDTSpXG9^`>it^fW
zx!mcgRO&rdy(w~zMhxi6gzt{x%JDOJeo3oi!z3nPctaMrPDFkKv^w{d25MEc0oWec
z2^g$s&yc~L35t&ggp4m*%CK}q1xQp_lp`<-y!!qs&VGCWgwUU&{N&Y-=~`dQH}~y>
zarWSGZI2j1JP-BrC7w!I>eI%io3egpah>+)x7%$~$8X2&9KfM7);P|Ni3KVQx9<><
z--gL=UqYD1nT!c*gc^aKs#*;!1eT@R$^Kj5R%`8S;GvMvfn)UTk=**&Ebf`s6rR_j
zHj!npz!M@;nt{&}bc3w`W~%B7&P{vat4dW*1#Sr?t^^H_5R)W6>E7+%r>*4ViSvuQ
zdxRmCis6UPE~d(ZqxR{Gh$hT;9RFEA^b1U-RcHwcn12ea1KKnI+w(wPz|%nZt3qOr
zLiJ)q1^{&Jl;*mVhOzzAbGY%f6|o<o*1EfQya}u=DMitel9JZ&wPcgCCdQa2ec%6D
zxPM+hfKD|jt~g;BLtb3MWzQ}IEU8qwG#BS>6mJz#N6HJ~D#-$)%I4+9ucC~9X(_$_
z@o})<PI#*(gyeqvPE(M=5^-WViS!v4PF=`~b!~L3uZnkKh=gLz`Zh#;XVa>R$^6m4
za%0TgO@NhOwAMZXOhnlqf$Fqj+}C%cU(Zfl@P`FK@NZJ?`8Rue*Nx^gJ<of^TKh$U
zg59qHq>OO<{@c-Sn`$n6Yykyd-IXF8sR1ehl1~9nF9o(;r^pzOhi9xSLy|;;-j5g#
z6Bn2(c5aCXKYeLgVB^D=yQ_zUz<mXTB^rH!r>wPKGRCaggbIoks`@oW?*>keV#Fi%
z?n|F;Rh&C<9{J)vK@tkf(`-gn`zB?y!y26<!?KR}B72YAhDXmC&VYuL3*kv<m^)hJ
z^hMxy30L*H)&hB7%TiXQbzFgG7%XxlZl#?hKx=VuW0L@5wCFxb3`3Npn9Ay$MgaHb
z^Z8Ax)CgPhP6Pf+oify2hxTC7IU^X_IpH(yy(yaQ->LyJ#uP;4g0OTX?u72&s}nyz
zZDd&h+rc8IdJ%aTsE_>e`<`8x2>3;csB;8)MZvub4<`55aex_Tvy|B1kK6exm0+5L
z#hUW!Qa)arXwg5~^Slc;^&UmU8e^^k&U0&g`uFO@o#*WA;uFKz64iNOui->h9pf6`
zPSsv%Xp!!qe!W#-$LQ_r(?90cw^x$M1#nzV+EDKaYKs+faf^XE*pNsmXcBG)kpLfy
zf4LZQgjB`V?UuS?7|us)a@_Rz0`i4K1;RDq_M{ytT)R_Mj|SF8$K0d<(5R}NKXGO{
zcJwXaOTa(cNvLWER^_pXoEiOK<(f7wojea!Vadv%b0KAf^Y`fK)MXWu<H?}JEp&Du
zYIUu!mVw~v%sP6%V||*z+XdFbx0csuH}S~K)l7MHsXP6y!0oE)b&!5jfiDAdDtsKp
z<XeWBp@c0^)vo{#SNOPQ6B*f`py%HNL{onC<XjfC6j1efdD^NN;W>W)ZP~NYbM~7n
zMKz@q&MsP7asQS$0iA@HgJo(&sP%-Kj_DsK$Cs?k^7@*<mR|PU5@s)5?_TjRRlRI8
z==Z*=?o03_h0^Mps?Fiazx^<j*4Ea>>gwtxBH~KZcZ@N2ZRmG}LLnt0&xuI9<MGq4
zFJau2g)zfwJi`m$8^yLgYEfWaOP=T6TF(0m*HW-<j)r!s9MpkzE97CFT%!$9n0`HK
z`P%Ni=^wVWt17>kG=tmTSrvDl?bo}G|2gLiu6fC+>XDx3J=anC<@5QWp65+>7FH{;
zn=$5tEy_%5Z565y5bSy2j*E>kw{GOO=K{Zp-p~K2g+uR{Mr*YBVyHsD+P98d&KyaX
zx>N}yU%s`i3m!;2MPVEItkU??J1aPA@_Z;1icXdhF5jmY=NvxBwfid-_V7G!eg{Ia
zbhyW_TThz<_A$o1y~Wh5TH6(Pv;reHs%EY4?*ZH#ukJRV>n6^krBHCTFAF_YPpM9u
z@=bS(nz5pyt%RL!?6Zn<Efml~p(Np~-1OQ?-U@f*467Zs0q$&TYcre3$X?<84kuTL
z{Wq)bcyk+vc2RgWj6FMaUTbYPL?%SxivssQJD<O-$Ob92;?{pOc$TZj4y8J6{!<T1
z(NgEk-G8tWj(+g&eK~tnH>cPt1W~Q!%E@zC-JEkk4LLZSPM^F9G4-CR`i6)c-i~~I
zGS4-sz>H&n`&?iko44*BI2)2iQPn$ecH4Mk`YLYv`^QenMu@u_!!M2+z;-=iQ(Opf
z;^)IWl63(5wh|zk2rmV)h~xwcsv1>rc_EA#g_!B^;s(_^RozWQt_+haTyW$dUY@s(
z8O{0N^r6<6(VXX3Q|55ZiNm7qFadsPt$o!PGrJu|ek0sIpi@*j*_!jItxC|Z_7i2M
zs(Pw=9dJbvp%50YY~kML7jg9oLpS=66;(YGI6iv6yeZ2?kIoHha&Sm1!dW|Y<)B^r
zxGQRch@2T#ihrV`P$*0lk)FW03N+SNbK}?@IQqVsC3mPiFntYsy|tV}_vjrRZd7>K
z_x=4m&uc9a<V!-3J{>t_%T{Oj>0|S_?c2lMlAzQlre>|RjjH-2a24Q1o9(|hdljeN
zJDXW6GEU)_PzjC-TODqVVuie~+&p;>OWOQ|K~q(RbP{k@F#rGv<Vi$9RH^2?BL=&5
zE^9^P$6JDt0I5_;t+hW2Q%ivI#Ub6f<|}=`>DrEF_k*VvFn?K#8~5%i!CnQ?YV2gK
z-V59)A~8bn!Gg7%cJ~ZkTD-n26#Yb)X?@#2jD-%1CD&U1@cKs_b?;2(tZl*bjJx_!
z)y5J@@21McST(Ei)GLd5WcJ$R7S=&hk)ItiFs^+KiSug_navg)sZ?rBxc6NQ%APo8
zd&cywiy0b~T(()u^^<1PnoTsno$nV47v}Q$5rRA?!s)?J0*K--?=I)aJE!qMQ>IvR
zRHWf%H4e!}R^%9h4yL$Cqb+Z_bLw1f`TL6SnF^Nu`_%Hlg}b<0k*z`G{cvHmqI>}%
z?jN7AFx)04%uG1NAzb<8UYvc{Aa@!stLnjC2U_U<lfznj3vf{!LM?0IklX%2F0rX^
zup+PcQZK%9_@E#oqv1y8K{hFd{c{D&_&+b?+Lu;@)eO)r?eWg_d${z=0`o%KnO4OQ
z8>>WBtrWL`j&`=323)<N#-Wo4wiu1WjMdFKemZd`kI!p~tLTb_P|nSXG=y+fnaDI}
z3S2d54!+uWGouL08Pm6plMm|ePNPLtzx`=35+GkFT$%P#V-Q9I4Cvj7UmZ1&agWa{
zYkIoj)s=j4a09y!?dHJQMZCDVwZMNrF(*juYYBLf#K3ES;Rzsw%HT&hMgnt8B}d0v
zdj~<!NlkRgc^|FkjQ@F`$LFmtw!4KVwyK*HI#`9fo}SMetJ@MmKR~CH;hM2KQd@jZ
zhXOzJJZ}b{;;62w%G#j%A$DdC*}XTX4)0nl7cB<gTsC<=tDAF)v>m{bk273w&ou6N
zzbV9)wOEZ`aR=xQ<2gM|iQC*mRUZx0G~#A4j=gg_?=`iRm)-|BBUXcQjt#wD`o{`>
z`S!<&N8v{4teX$-7ei>_cs%Sj{?tb*<^4-lFO3$FXM`Udvm-+~r^<wQ&iWj;JU*L3
znBj>YPkGXv(|F;d)}jOD)ZTffoL2rO(6eOJx{X5vfoFiBF>|dl`K85N{OsaHGS^8i
z#vRFBsy%Gj;9^7)mF6bYr_F6X1wYyCq$p>P>dqC%4aM=JmVxeKjJJ%>$Y^P4F}1a|
zkKsH=^qpBv9DVN$g1v*BdL&~wXH+A7x}?bDd~SK8iM;P8YbV_&)F9MXnGnS+$pmS#
zl|#c48A15V#iQt27dyufM~{y>h~R;p+r*R47P#Z7x!m#Ys*(wiU}UmXvO<@Sx{nCc
zME4d7BfD1d(D|d>Ry?0zSI4LLjEzE}(8Cz>22Pv$Jx|Z&`WKgl0-Jn%R;0z;t~Zg=
ztU!@T<yiodKXyo{3jexlw>TH7s#A^c`}+e^T}G~4)5gX3ydN@Bi~GPPe79nwOq4$?
z*4c#8q$N)tDrv)0;Adk8CweM@+dqqp48xU=RrM?&AJOBagZgvW_MPG<D!Jw(?f`2a
ziHZL&eb$LMv3D|bBi@s@MAN2>hzy~mGGNK74DYPWfwjTI+Eg8O6=Ap1?kv^vZl&^s
zaPeF>9N3ppJ2bd!`tJn0MSo_8=XrktZj5fVrpn{Wu{+Y$OFlG49De|<)MZk-B$JI)
zs;((=lI-n!nkkdZ<?coKwfnWvJ2Wuq+!5^BtqQjbiMR%}JOS)p(7lI54_UaMtg3SK
zpw5ilzn@#;zg|_(F~+p<86Vd7Z&B6w;W^v)tmC$^gNoWo)oF}!I-#Y#c6YZa&?$Y<
z^2bjV+a|QExmf_#ty?FZJ9j>Z;0di&iMaCN512f+rI_7!>rq3gs_}$fx2cIcz@o&x
zi7L^<8?*@BYYhjE?7<<s^`fpifm&T@jJbi&$tV;GW5V5<<8;+~vzwUu)-qZ$eoTio
zS)XSXXA@3RSr8(y*EThA-0cd#`<;XuHo|Yu-ia<XK|6(2eNieP`r}>HzAbP0->I|t
z#ot#IRjc#(KSlX+uNv<E?&$Uc+VcEi`PZiUzJGK&ozC+)8rJu}g~&sINjwMB=>W5;
zOnGH7KX_(w;!#tsV(Xgrc>CHtIviP=#MT1(qA9TlPpInt1Wi9d(401$f7B4}_<Fyf
zkwnWkX%K>N#0X_CujGA&XO6#x>S>=hMgpvBZk`BS1{AbJSfhLOjBw1p+cW9ZA@rz9
zl{ETB+EUu3*M?rD%EDAI@NcN<o&=j6#u9ME-rF+y%whDZ4mR^u>l*8dE}Oe;Vd)1J
zSb^%T*4jgi=dI#%I2sxn)EM&%g6C<z!v^-*-D6mHCY>{!ox7&vLhB-NY=USNJfaP|
zKEYTh8?XsA#+Y9c>?a$4Z{dm-F8Te3yzy~c=m;ra?p4e0zqgCa&({dr89a)Qnus1h
z(FD8)Of$x0`F}FnG8vPuuHK2DB7G20uc`w@<X|_YwQ60CA5Zv@Df3(6xUI3u<DKjF
z3>$f|z!ZWO1xrwo(KV!99;gdxng!}ntwCgosy@6?HEpfE0QiMKRU{f~Tk_oa$P6aT
zTnl2@w|6bSyI{0y3okUr+|Jg4_3bwh9>A^4$oc$w%4}|bCs0V;syyDge$Qwz_`t!&
zbbQ18O?l$b?W+29bt<qMI;FY(lo4FMPcIO``nFWfrnj;&q@QP=2<v0xd~8klkhhx;
z*%pjfNq@F(*0nY<P=3~0dniGU4JCMd;yFhS=FV^Q51#pvoKf{wHYVuz&#++p_4t?(
zjys?~<4+hwwW0L+leM4tq<r7+ZmoUJTC47B_R?l8Id;`n7FP5_YOS^R+hD}>nz=YZ
zKWnW$WQ$D5_x-fB_GW8s-kp#-fBU|_m6`3qv3V71?UmMAzjRTAFW*|b-<CD()}CRl
z%~hI^@B5c-W!pySce1rMQ-OZgT080!vzhHUM)#@e!Ne782{a<Rm0cU9--D`pB+h19
z&S?2mCguD7Kx^%Lj${>bZEc5aW!EO#(V^Db=??wo<#M^rYPOaC#Dwzse7%T#n_v@*
z=d87V3ZGZ9b!-|#8wB~5qMcRs(R4aJe{;_Be=X-L_U%}Q%m4rY07*qoM6N<$g3Xff
AF#rGn

literal 0
HcmV?d00001

diff --git a/Lite/Services/PlanIconMapper.cs b/Lite/Services/PlanIconMapper.cs
index f187eda1..509c0e53 100644
--- a/Lite/Services/PlanIconMapper.cs
+++ b/Lite/Services/PlanIconMapper.cs
@@ -175,8 +175,44 @@ public static class PlanIconMapper
         ["Language Construct Catch All"] = "language_construct_catch_all",
     };
 
-    public static string GetIconName(string physicalOp)
+    public static string GetIconName(string physicalOp, string? storageType = null, string? logicalOp = null)
     {
+        // Parallelism subtypes: PhysicalOp="Parallelism" + LogicalOp identifies which.
+        if (string.Equals(physicalOp, "Parallelism", StringComparison.Ordinal) && logicalOp != null)
+        {
+            switch (logicalOp)
+            {
+                case "Repartition Streams": return "parallelism_repartition_streams";
+                case "Distribute Streams":  return "parallelism_distribute_streams";
+                case "Gather Streams":      return "parallelism_gather_streams";
+            }
+        }
+
+        // Columnstore scans surface as PhysicalOp="Clustered Index Scan" / "Index Scan"
+        // with Storage="ColumnStore" on the Object element. Route to the columnstore icon.
+        if (string.Equals(storageType, "ColumnStore", StringComparison.OrdinalIgnoreCase))
+        {
+            switch (physicalOp)
+            {
+                case "Clustered Index Scan":
+                case "Index Scan":
+                case "Columnstore Index Scan":
+                    return "columnstore_index_scan";
+                case "Clustered Index Delete":
+                case "Index Delete":
+                    return "columnstore_index_delete";
+                case "Clustered Index Insert":
+                case "Index Insert":
+                    return "columnstore_index_insert";
+                case "Clustered Index Update":
+                case "Index Update":
+                    return "columnstore_index_update";
+                case "Clustered Index Merge":
+                case "Index Merge":
+                    return "columnstore_index_merge";
+            }
+        }
+
         if (IconMap.TryGetValue(physicalOp, out var iconName))
             return iconName;
 
diff --git a/Lite/Services/ShowPlanParser.cs b/Lite/Services/ShowPlanParser.cs
index c9060e5d..24a37f6c 100644
--- a/Lite/Services/ShowPlanParser.cs
+++ b/Lite/Services/ShowPlanParser.cs
@@ -665,8 +665,10 @@ private static PlanNode ParseRelOp(XElement relOpEl)
             node.PhysicalOp = "Lazy " + node.PhysicalOp;
         }
 
-        // Map to icon
-        node.IconName = PlanIconMapper.GetIconName(node.PhysicalOp);
+        // Icon mapping is deferred until after StorageType and LogicalOp are
+        // parsed below, so columnstore scans (Clustered/Index Scan with
+        // Storage="ColumnStore") and Parallelism subtypes route to their
+        // specific icons.
 
         // Handle operator-specific element
         var physicalOpEl = GetOperatorElement(relOpEl);
@@ -1365,6 +1367,11 @@ private static PlanNode ParseRelOp(XElement relOpEl)
             }
         }
 
+        // Map to icon — done here so columnstore scans (Clustered/Index Scan
+        // with Storage="ColumnStore") and Parallelism subtypes (which depend on
+        // LogicalOp) can be routed to their specific icons.
+        node.IconName = PlanIconMapper.GetIconName(node.PhysicalOp, node.StorageType, node.LogicalOp);
+
         // Recurse into child RelOps
         foreach (var childRelOp in FindChildRelOps(relOpEl))
         {

From 62cc4f26cd40dc3924ceddf411458556a2924ff6 Mon Sep 17 00:00:00 2001
From: Erik Darling <2136037+erikdarlingdata@users.noreply.github.com>
Date: Mon, 27 Apr 2026 21:28:07 -0400
Subject: [PATCH 45/49] Skip historical sweep when collectors resume after a
 gap (#892)

When the Off preset, an Agent stoppage, or a server reboot pauses
collection for hours, the next run of query_stats / procedure_stats /
query_store would dump everything that accumulated during the gap into
their delta tables in one go. On query_stats specifically (issue #885),
that was enough to blow tempdb overnight.

Each of the three procs now reads MAX(config.collection_log.collection_time)
for its own collector_name (where status = SUCCESS) right after computing
the normal cutoff. If the gap to now exceeds 5x the configured frequency
(or 30 minutes, whichever is larger), it clamps the cutoff to SYSDATETIME()
so only forward-going data is collected on the resume run. NULL/0
frequency_minutes safely floors to 30 minutes.

XE-backed collectors (blocked_process_xml, deadlock_xml, system_health,
default_trace, trace_analysis) are bounded by their own @minutes_back /
@hours_back parameters and don't have the catch-up problem, so they're
left alone. Snapshot collectors (wait_stats, file_io_stats, etc) insert
one row per run regardless of gap and were never at risk.

Verified on sql2016/2017/2019/2022/2025: all three procs deploy cleanly,
heuristic fires on a 3-hour synthetic gap, stays quiet on normal runs.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
---
 install/08_collect_query_stats.sql     | 36 ++++++++++++++++++++++++
 install/09_collect_query_store.sql     | 38 ++++++++++++++++++++++++++
 install/10_collect_procedure_stats.sql | 36 ++++++++++++++++++++++++
 3 files changed, 110 insertions(+)

diff --git a/install/08_collect_query_stats.sql b/install/08_collect_query_stats.sql
index f866749b..2092d557 100644
--- a/install/08_collect_query_stats.sql
+++ b/install/08_collect_query_stats.sql
@@ -158,6 +158,42 @@ BEGIN
                         @last_collection_time,
                         DATEADD(MINUTE, -ISNULL(@frequency_minutes, 15), SYSDATETIME())
                     );
+
+            /*
+            Resume detection: if this collector hasn't successfully run in a long time
+            (Off preset, Agent stoppage, server reboot, manual disable), skip the
+            historical sweep so we don't dump the entire plan cache into our deltas.
+            Threshold: 5x the configured frequency, floored at 30 minutes.
+            */
+            DECLARE
+                @last_successful_run_time datetime2(7),
+                @resume_threshold_minutes integer;
+
+            SELECT
+                @last_successful_run_time = MAX(cl.collection_time)
+            FROM config.collection_log AS cl
+            WHERE cl.collector_name = N'query_stats_collector'
+            AND   cl.collection_status = N'SUCCESS';
+
+            SET @resume_threshold_minutes =
+                CASE
+                    WHEN ISNULL(@frequency_minutes, 0) <= 0 THEN 30
+                    WHEN @frequency_minutes * 5 > 30 THEN @frequency_minutes * 5
+                    ELSE 30
+                END;
+
+            IF @last_successful_run_time IS NOT NULL
+            AND DATEDIFF(MINUTE, @last_successful_run_time, SYSDATETIME()) > @resume_threshold_minutes
+            BEGIN
+                IF @debug = 1
+                BEGIN
+                    DECLARE @gap_minutes integer = DATEDIFF(MINUTE, @last_successful_run_time, SYSDATETIME());
+                    RAISERROR(N'Resume detected: %d-minute gap exceeds %d-minute threshold. Skipping historical sweep.', 0, 1,
+                              @gap_minutes, @resume_threshold_minutes) WITH NOWAIT;
+                END;
+
+                SET @cutoff_time = SYSDATETIME();
+            END;
         END;
 
         IF @debug = 1
diff --git a/install/09_collect_query_store.sql b/install/09_collect_query_store.sql
index df1643d8..d13df2a7 100644
--- a/install/09_collect_query_store.sql
+++ b/install/09_collect_query_store.sql
@@ -192,6 +192,44 @@ BEGIN
                         ),
                         0
                     );
+
+            /*
+            Resume detection: if this collector hasn't successfully run in a long time
+            (Off preset, Agent stoppage, server reboot, manual disable), skip the
+            historical sweep so we don't dump the entire Query Store window into our deltas.
+            Note: @last_collection_time above tracks the latest captured query execution time,
+            not the collector's run time, so we need a separate lookup against config.collection_log.
+            Threshold: 5x the configured frequency, floored at 30 minutes.
+            */
+            DECLARE
+                @last_successful_run_time datetime2(7),
+                @resume_threshold_minutes integer;
+
+            SELECT
+                @last_successful_run_time = MAX(cl.collection_time)
+            FROM config.collection_log AS cl
+            WHERE cl.collector_name = N'query_store_collector'
+            AND   cl.collection_status = N'SUCCESS';
+
+            SET @resume_threshold_minutes =
+                CASE
+                    WHEN ISNULL(@collection_interval_minutes, 0) <= 0 THEN 30
+                    WHEN @collection_interval_minutes * 5 > 30 THEN @collection_interval_minutes * 5
+                    ELSE 30
+                END;
+
+            IF @last_successful_run_time IS NOT NULL
+            AND DATEDIFF(MINUTE, @last_successful_run_time, SYSDATETIME()) > @resume_threshold_minutes
+            BEGIN
+                IF @debug = 1
+                BEGIN
+                    DECLARE @gap_minutes integer = DATEDIFF(MINUTE, @last_successful_run_time, SYSDATETIME());
+                    RAISERROR(N'Resume detected: %d-minute gap exceeds %d-minute threshold. Skipping historical sweep.', 0, 1,
+                              @gap_minutes, @resume_threshold_minutes) WITH NOWAIT;
+                END;
+
+                SET @cutoff_time = TODATETIMEOFFSET(SYSUTCDATETIME(), 0);
+            END;
         END;
 
         IF @debug = 1
diff --git a/install/10_collect_procedure_stats.sql b/install/10_collect_procedure_stats.sql
index ad36e2f5..abe44e9a 100644
--- a/install/10_collect_procedure_stats.sql
+++ b/install/10_collect_procedure_stats.sql
@@ -157,6 +157,42 @@ BEGIN
             SELECT
                 @cutoff_time = ISNULL(@last_collection_time,
                     DATEADD(MINUTE, -ISNULL(@frequency_minutes, 15), SYSDATETIME()));
+
+            /*
+            Resume detection: if this collector hasn't successfully run in a long time
+            (Off preset, Agent stoppage, server reboot, manual disable), skip the
+            historical sweep so we don't dump cumulative procedure stats into our deltas.
+            Threshold: 5x the configured frequency, floored at 30 minutes.
+            */
+            DECLARE
+                @last_successful_run_time datetime2(7),
+                @resume_threshold_minutes integer;
+
+            SELECT
+                @last_successful_run_time = MAX(cl.collection_time)
+            FROM config.collection_log AS cl
+            WHERE cl.collector_name = N'procedure_stats_collector'
+            AND   cl.collection_status = N'SUCCESS';
+
+            SET @resume_threshold_minutes =
+                CASE
+                    WHEN ISNULL(@frequency_minutes, 0) <= 0 THEN 30
+                    WHEN @frequency_minutes * 5 > 30 THEN @frequency_minutes * 5
+                    ELSE 30
+                END;
+
+            IF @last_successful_run_time IS NOT NULL
+            AND DATEDIFF(MINUTE, @last_successful_run_time, SYSDATETIME()) > @resume_threshold_minutes
+            BEGIN
+                IF @debug = 1
+                BEGIN
+                    DECLARE @gap_minutes integer = DATEDIFF(MINUTE, @last_successful_run_time, SYSDATETIME());
+                    RAISERROR(N'Resume detected: %d-minute gap exceeds %d-minute threshold. Skipping historical sweep.', 0, 1,
+                              @gap_minutes, @resume_threshold_minutes) WITH NOWAIT;
+                END;
+
+                SET @cutoff_time = SYSDATETIME();
+            END;
         END;
 
         IF @debug = 1

From c1dcfc27170faf48dbfe1f23db5731fa6c8e4257 Mon Sep 17 00:00:00 2001
From: Erik Darling <2136037+erikdarlingdata@users.noreply.github.com>
Date: Mon, 27 Apr 2026 22:29:34 -0400
Subject: [PATCH 46/49] Add per-database exclusions for collectors (Dashboard,
 #887)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

New config.collector_database_exclusions table holds a per-server list of
user databases to skip in per-database collectors. The eight collectors
that iterate sys.databases now honor it via a NOT EXISTS filter:
query_stats, query_store, procedure_stats, file_io_stats, waiting_tasks,
database_configuration, database_size_stats, server_properties.

System databases (master/tempdb/model/msdb) and the PerformanceMonitor
database itself remain hardcoded skips in the collectors and are not
represented in the exclusions list.

Dashboard side:
- Manage Servers window gets a new "Excluded Databases" button (and matching
  context menu entry) between Check Server Version and Purge Now.
- Default window width bumped 780 → 960 so all per-row buttons fit on first
  open without resizing.
- New ExcludedDatabasesDialog modal: live-queries sys.databases on the
  target, pre-checks current exclusions, hides system DBs, shows stale
  entries (in list but not on server) greyed and disabled with "(missing)".
  Save replaces the table contents transactionally.
- ServerManager.GetUserDatabasesAsync, GetCollectorDatabaseExclusionsAsync,
  and SaveCollectorDatabaseExclusionsAsync handle the connection plumbing.

Schema is added in install/01 (initial install) and mirrored in install/03
inside config.ensure_config_tables (resilient re-creation). No upgrade
folder needed — installer re-runs install/01 on existing installs and the
IF OBJECT_ID guard fires.

Verified end-to-end by running the CLI installer against sql2019, then
excluding hammerdb_tpcc and confirming database_size_stats_collector
skipped it (0 rows) while StackOverflow2010 was still collected.

Lite side will follow in a separate PR (different storage model — Lite
keeps the exclusion list in servers.json since it doesn't install on
targets).

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
---
 Dashboard/ExcludedDatabasesDialog.xaml        |  49 ++++++
 Dashboard/ExcludedDatabasesDialog.xaml.cs     | 150 ++++++++++++++++++
 Dashboard/ManageServersWindow.xaml            |   4 +-
 Dashboard/ManageServersWindow.xaml.cs         |  19 +++
 Dashboard/Services/ServerManager.cs           | 109 +++++++++++++
 install/01_install_database.sql               |  26 +++
 install/03_create_config_tables.sql           |  39 +++++
 install/08_collect_query_stats.sql            |   7 +
 install/09_collect_query_store.sql            |   7 +
 install/10_collect_procedure_stats.sql        |  14 ++
 install/20_collect_file_io_stats.sql          |   7 +
 install/37_collect_waiting_tasks.sql          |   7 +
 install/39_collect_database_configuration.sql |  14 ++
 install/52_collect_database_size_stats.sql    |   7 +
 install/53_collect_server_properties.sql      |   7 +
 15 files changed, 465 insertions(+), 1 deletion(-)
 create mode 100644 Dashboard/ExcludedDatabasesDialog.xaml
 create mode 100644 Dashboard/ExcludedDatabasesDialog.xaml.cs

diff --git a/Dashboard/ExcludedDatabasesDialog.xaml b/Dashboard/ExcludedDatabasesDialog.xaml
new file mode 100644
index 00000000..00789a61
--- /dev/null
+++ b/Dashboard/ExcludedDatabasesDialog.xaml
@@ -0,0 +1,49 @@
+<Window x:Class="PerformanceMonitorDashboard.ExcludedDatabasesDialog"
+        xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
+        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
+        Title="Excluded Databases"
+        Height="500" Width="500"
+        WindowStartupLocation="CenterOwner"
+        ResizeMode="CanResizeWithGrip"
+        Background="{DynamicResource BackgroundBrush}">
+    <Grid Margin="16">
+        <Grid.RowDefinitions>
+            <RowDefinition Height="Auto"/>
+            <RowDefinition Height="Auto"/>
+            <RowDefinition Height="*"/>
+            <RowDefinition Height="Auto"/>
+            <RowDefinition Height="Auto"/>
+        </Grid.RowDefinitions>
+
+        <TextBlock Grid.Row="0" x:Name="HeaderText" FontWeight="Bold" FontSize="14"
+                   Foreground="{DynamicResource ForegroundBrush}" Margin="0,0,0,8"/>
+
+        <TextBlock Grid.Row="1" TextWrapping="Wrap" FontSize="11"
+                   Foreground="{DynamicResource ForegroundMutedBrush}" Margin="0,0,0,12"
+                   Text="Databases marked here are skipped by per-database collectors (query_store, file_io_stats, etc.) on this server. System databases (master/tempdb/model/msdb) are always excluded."/>
+
+        <Border Grid.Row="2" BorderBrush="{DynamicResource BorderBrush}" BorderThickness="1" CornerRadius="4">
+            <ScrollViewer VerticalScrollBarVisibility="Auto" Padding="8">
+                <ItemsControl x:Name="DatabasesItemsControl">
+                    <ItemsControl.ItemTemplate>
+                        <DataTemplate>
+                            <CheckBox Content="{Binding DisplayName}"
+                                      IsChecked="{Binding IsExcluded, Mode=TwoWay}"
+                                      IsEnabled="{Binding IsEnabled}"
+                                      Foreground="{Binding ForegroundBrush}"
+                                      Margin="2,3"/>
+                        </DataTemplate>
+                    </ItemsControl.ItemTemplate>
+                </ItemsControl>
+            </ScrollViewer>
+        </Border>
+
+        <TextBlock Grid.Row="3" x:Name="StatusText" FontSize="10" FontStyle="Italic"
+                   Foreground="{DynamicResource ForegroundMutedBrush}" Margin="0,8,0,0"/>
+
+        <StackPanel Grid.Row="4" Orientation="Horizontal" HorizontalAlignment="Right" Margin="0,12,0,0">
+            <Button Content="Save" Width="80" Height="28" Margin="0,0,8,0" Click="Save_Click"/>
+            <Button Content="Cancel" Width="80" Height="28" Click="Cancel_Click" IsCancel="True"/>
+        </StackPanel>
+    </Grid>
+</Window>
diff --git a/Dashboard/ExcludedDatabasesDialog.xaml.cs b/Dashboard/ExcludedDatabasesDialog.xaml.cs
new file mode 100644
index 00000000..6b6bf989
--- /dev/null
+++ b/Dashboard/ExcludedDatabasesDialog.xaml.cs
@@ -0,0 +1,150 @@
+/*
+ * Copyright (c) 2026 Erik Darling, Darling Data LLC
+ *
+ * This file is part of the SQL Server Performance Monitor.
+ *
+ * Licensed under the MIT License. See LICENSE file in the project root for full license information.
+ */
+
+using System;
+using System.Collections.Generic;
+using System.Collections.ObjectModel;
+using System.ComponentModel;
+using System.Linq;
+using System.Windows;
+using System.Windows.Media;
+using PerformanceMonitorDashboard.Models;
+using PerformanceMonitorDashboard.Services;
+
+namespace PerformanceMonitorDashboard
+{
+    public partial class ExcludedDatabasesDialog : Window
+    {
+        private readonly ServerManager _serverManager;
+        private readonly ServerConnection _server;
+        private ObservableCollection<DatabaseExclusionItem> _items = new();
+
+        public bool ExclusionsModified { get; private set; }
+
+        public ExcludedDatabasesDialog(ServerManager serverManager, ServerConnection server)
+        {
+            InitializeComponent();
+            _serverManager = serverManager;
+            _server = server;
+            HeaderText.Text = $"Excluded Databases — {server.DisplayNameWithIntent}";
+            Loaded += async (_, _) => await LoadAsync();
+        }
+
+        private async System.Threading.Tasks.Task LoadAsync()
+        {
+            StatusText.Text = "Loading databases…";
+            DatabasesItemsControl.ItemsSource = null;
+
+            try
+            {
+                var liveDatabases = await _serverManager.GetUserDatabasesAsync(_server);
+                var existingExclusions = await _serverManager.GetCollectorDatabaseExclusionsAsync(_server);
+
+                var liveSet = new HashSet<string>(liveDatabases, StringComparer.OrdinalIgnoreCase);
+
+                _items = new ObservableCollection<DatabaseExclusionItem>();
+
+                /* Live databases: sortable, checkable */
+                foreach (var name in liveDatabases.OrderBy(n => n, StringComparer.OrdinalIgnoreCase))
+                {
+                    _items.Add(new DatabaseExclusionItem
+                    {
+                        Name = name,
+                        DisplayName = name,
+                        IsExcluded = existingExclusions.Contains(name, StringComparer.OrdinalIgnoreCase),
+                        IsEnabled = true,
+                        IsStale = false
+                    });
+                }
+
+                /* Stale entries: in exclusion list but not present on the server. Show greyed, disabled, pre-checked. */
+                foreach (var name in existingExclusions
+                             .Where(n => !liveSet.Contains(n))
+                             .OrderBy(n => n, StringComparer.OrdinalIgnoreCase))
+                {
+                    _items.Add(new DatabaseExclusionItem
+                    {
+                        Name = name,
+                        DisplayName = $"{name}  (missing)",
+                        IsExcluded = true,
+                        IsEnabled = false,
+                        IsStale = true
+                    });
+                }
+
+                DatabasesItemsControl.ItemsSource = _items;
+                StatusText.Text = $"{liveDatabases.Count} database(s) on this server, {existingExclusions.Count} currently excluded.";
+            }
+            catch (Exception ex)
+            {
+                StatusText.Text = $"Failed to load: {ex.Message}";
+                MessageBox.Show(this,
+                    $"Could not read database list from '{_server.DisplayNameWithIntent}':\n\n{ex.Message}",
+                    "Load Failed",
+                    MessageBoxButton.OK,
+                    MessageBoxImage.Error);
+            }
+        }
+
+        private async void Save_Click(object sender, RoutedEventArgs e)
+        {
+            /* Collect every checked item (live + stale). Stale ones can't be unchecked, so they stay if they were excluded. */
+            var checkedNames = _items
+                .Where(i => i.IsExcluded)
+                .Select(i => i.Name)
+                .ToList();
+
+            Cursor = System.Windows.Input.Cursors.Wait;
+            try
+            {
+                await _serverManager.SaveCollectorDatabaseExclusionsAsync(_server, checkedNames);
+                ExclusionsModified = true;
+                DialogResult = true;
+            }
+            catch (Exception ex)
+            {
+                MessageBox.Show(this,
+                    $"Failed to save exclusions on '{_server.DisplayNameWithIntent}':\n\n{ex.Message}",
+                    "Save Failed",
+                    MessageBoxButton.OK,
+                    MessageBoxImage.Error);
+            }
+            finally
+            {
+                Cursor = null;
+            }
+        }
+
+        private void Cancel_Click(object sender, RoutedEventArgs e)
+        {
+            DialogResult = false;
+        }
+    }
+
+    public class DatabaseExclusionItem : INotifyPropertyChanged
+    {
+        public string Name { get; set; } = "";
+        public string DisplayName { get; set; } = "";
+        private bool _isExcluded;
+        public bool IsExcluded
+        {
+            get => _isExcluded;
+            set { _isExcluded = value; OnPropertyChanged(nameof(IsExcluded)); }
+        }
+        public bool IsEnabled { get; set; } = true;
+        public bool IsStale { get; set; }
+
+        public Brush ForegroundBrush => IsStale
+            ? (Brush)Application.Current.FindResource("ForegroundMutedBrush")
+            : (Brush)Application.Current.FindResource("ForegroundBrush");
+
+        public event PropertyChangedEventHandler? PropertyChanged;
+        private void OnPropertyChanged(string propertyName)
+            => PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(propertyName));
+    }
+}
diff --git a/Dashboard/ManageServersWindow.xaml b/Dashboard/ManageServersWindow.xaml
index c96e9863..33892881 100644
--- a/Dashboard/ManageServersWindow.xaml
+++ b/Dashboard/ManageServersWindow.xaml
@@ -2,7 +2,7 @@
         xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
         xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
         Title="Manage Servers"
-        Height="450" Width="780"
+        Height="450" Width="960"
         WindowStartupLocation="CenterOwner"
         ResizeMode="CanResizeWithGrip"
         Background="{DynamicResource BackgroundBrush}">
@@ -12,6 +12,7 @@
             <MenuItem Header="Edit..." Click="EditServer_Click"/>
             <MenuItem Header="Toggle Favorite" Click="ToggleFavorite_Click"/>
             <MenuItem Header="Check Server Version" Click="CheckForUpdates_Click"/>
+            <MenuItem Header="Excluded Databases" Click="ExcludedDatabases_Click"/>
             <MenuItem Header="Purge Now" Click="PurgeNow_Click"/>
             <MenuItem Header="Remove" Click="RemoveServer_Click"
                       Foreground="{DynamicResource ErrorBrush}"/>
@@ -98,6 +99,7 @@
                 <Button Content="Edit..." Width="80" Height="30" Margin="0,0,8,0" Click="EditServer_Click"/>
                 <Button x:Name="ToggleFavoriteButton" Content="Toggle Favorite" Width="110" Height="30" Margin="0,0,8,0" Click="ToggleFavorite_Click"/>
                 <Button x:Name="CheckUpdatesButton" Content="Check Server Version" Width="140" Height="30" Margin="0,0,8,0" Click="CheckForUpdates_Click"/>
+                <Button Content="Excluded Databases" Width="140" Height="30" Margin="0,0,8,0" Click="ExcludedDatabases_Click"/>
                 <Button Content="Purge Now" Width="100" Height="30" Margin="0,0,8,0" Click="PurgeNow_Click"/>
                 <Button Content="Remove" Width="80" Height="30" Margin="0,0,8,0" Click="RemoveServer_Click"
                         Foreground="{DynamicResource ErrorBrush}"/>
diff --git a/Dashboard/ManageServersWindow.xaml.cs b/Dashboard/ManageServersWindow.xaml.cs
index c2ad284c..633de304 100644
--- a/Dashboard/ManageServersWindow.xaml.cs
+++ b/Dashboard/ManageServersWindow.xaml.cs
@@ -297,6 +297,25 @@ string Normalize(string v)
             }
         }
 
+        private void ExcludedDatabases_Click(object sender, RoutedEventArgs e)
+        {
+            if (ServersDataGrid.SelectedItem is not ServerConnection server)
+            {
+                MessageBox.Show(
+                    "Please select a server to configure excluded databases.",
+                    "No Server Selected",
+                    MessageBoxButton.OK,
+                    MessageBoxImage.Information);
+                return;
+            }
+
+            var dialog = new ExcludedDatabasesDialog(_serverManager, server) { Owner = this };
+            if (dialog.ShowDialog() == true && dialog.ExclusionsModified)
+            {
+                ServersModified = true;
+            }
+        }
+
         private async void PurgeNow_Click(object sender, RoutedEventArgs e)
         {
             if (ServersDataGrid.SelectedItem is not ServerConnection server)
diff --git a/Dashboard/Services/ServerManager.cs b/Dashboard/Services/ServerManager.cs
index 29ce934f..433a4fde 100644
--- a/Dashboard/Services/ServerManager.cs
+++ b/Dashboard/Services/ServerManager.cs
@@ -284,6 +284,115 @@ FROM config.collection_log AS cl
             return result;
         }
 
+        /// <summary>
+        /// Returns user database names (excluding system DBs and PerformanceMonitor) on the target server,
+        /// for use in the Excluded Databases dialog.
+        /// </summary>
+        public async Task<List<string>> GetUserDatabasesAsync(ServerConnection server)
+        {
+            var connectionString = server.GetConnectionString(_credentialService);
+            var builder = new SqlConnectionStringBuilder(connectionString)
+            {
+                InitialCatalog = "master",
+                ConnectTimeout = 10
+            };
+
+            using var connection = new SqlConnection(builder.ConnectionString);
+            await connection.OpenAsync();
+
+            using var cmd = new SqlCommand(@"
+SELECT d.name
+FROM sys.databases AS d
+WHERE d.database_id > 4
+AND   d.state_desc = N'ONLINE'
+AND   d.name <> N'PerformanceMonitor'
+AND   d.database_id < 32761 /*exclude contained AG system databases*/
+ORDER BY d.name;", connection);
+            cmd.CommandTimeout = 30;
+
+            var names = new List<string>();
+            using var reader = await cmd.ExecuteReaderAsync();
+            while (await reader.ReadAsync())
+            {
+                names.Add(reader.GetString(0));
+            }
+            return names;
+        }
+
+        /// <summary>
+        /// Returns the current per-database exclusion list from config.collector_database_exclusions on the target.
+        /// </summary>
+        public async Task<List<string>> GetCollectorDatabaseExclusionsAsync(ServerConnection server)
+        {
+            var connectionString = server.GetConnectionString(_credentialService);
+            var builder = new SqlConnectionStringBuilder(connectionString)
+            {
+                InitialCatalog = "PerformanceMonitor",
+                ConnectTimeout = 10
+            };
+
+            using var connection = new SqlConnection(builder.ConnectionString);
+            await connection.OpenAsync();
+
+            using var cmd = new SqlCommand(@"
+SELECT e.database_name
+FROM config.collector_database_exclusions AS e
+ORDER BY e.database_name;", connection);
+            cmd.CommandTimeout = 30;
+
+            var names = new List<string>();
+            using var reader = await cmd.ExecuteReaderAsync();
+            while (await reader.ReadAsync())
+            {
+                names.Add(reader.GetString(0));
+            }
+            return names;
+        }
+
+        /// <summary>
+        /// Replaces the contents of config.collector_database_exclusions with the supplied list, transactionally.
+        /// </summary>
+        public async Task SaveCollectorDatabaseExclusionsAsync(ServerConnection server, IEnumerable<string> databaseNames)
+        {
+            var connectionString = server.GetConnectionString(_credentialService);
+            var builder = new SqlConnectionStringBuilder(connectionString)
+            {
+                InitialCatalog = "PerformanceMonitor",
+                ConnectTimeout = 10
+            };
+
+            using var connection = new SqlConnection(builder.ConnectionString);
+            await connection.OpenAsync();
+
+            using var transaction = connection.BeginTransaction();
+            try
+            {
+                using (var deleteCmd = new SqlCommand("DELETE FROM config.collector_database_exclusions;", connection, transaction))
+                {
+                    deleteCmd.CommandTimeout = 30;
+                    await deleteCmd.ExecuteNonQueryAsync();
+                }
+
+                foreach (var name in databaseNames.Distinct(StringComparer.OrdinalIgnoreCase))
+                {
+                    using var insertCmd = new SqlCommand(
+                        "INSERT INTO config.collector_database_exclusions (database_name) VALUES (@name);",
+                        connection, transaction);
+                    insertCmd.CommandTimeout = 30;
+                    insertCmd.Parameters.Add(new SqlParameter("@name", System.Data.SqlDbType.NVarChar, 128) { Value = name });
+                    await insertCmd.ExecuteNonQueryAsync();
+                }
+
+                transaction.Commit();
+                Logger.Info($"Saved collector database exclusions on '{server.DisplayName}'");
+            }
+            catch
+            {
+                transaction.Rollback();
+                throw;
+            }
+        }
+
         public void UpdateLastConnected(string id)
         {
             lock (_serversLock)
diff --git a/install/01_install_database.sql b/install/01_install_database.sql
index 0559e3ac..5b4b293c 100644
--- a/install/01_install_database.sql
+++ b/install/01_install_database.sql
@@ -734,6 +734,32 @@ BEGIN
 END;
 GO
 
+/*
+Create per-database exclusions table
+User-configurable list of databases to skip in per-database collectors
+(query_store, file_io_stats, database_size_stats, etc.). System databases
+are always skipped by the collectors themselves and are not represented here.
+*/
+IF OBJECT_ID(N'config.collector_database_exclusions', N'U') IS NULL
+BEGIN
+    CREATE TABLE
+        config.collector_database_exclusions
+    (
+        database_name sysname NOT NULL,
+        excluded_at datetime2(7) NOT NULL DEFAULT SYSDATETIME(),
+        excluded_by sysname NULL DEFAULT SUSER_SNAME(),
+        CONSTRAINT
+            PK_collector_database_exclusions
+        PRIMARY KEY CLUSTERED
+            (database_name)
+        WITH
+            (DATA_COMPRESSION = PAGE)
+    );
+
+    PRINT 'Created config.collector_database_exclusions table';
+END;
+GO
+
 /*
 Create installation history table
 */
diff --git a/install/03_create_config_tables.sql b/install/03_create_config_tables.sql
index f81960ec..b0f65dd7 100644
--- a/install/03_create_config_tables.sql
+++ b/install/03_create_config_tables.sql
@@ -629,6 +629,45 @@ BEGIN
               );
           END;
 
+          /*
+          Create config.collector_database_exclusions
+          User-configurable list of databases to skip in per-database collectors.
+          System databases (master/tempdb/model/msdb) are filtered by the collectors
+          themselves and aren't represented here.
+          */
+          IF OBJECT_ID(N'config.collector_database_exclusions', N'U') IS NULL
+          BEGIN
+              IF @debug = 1
+              BEGIN
+                  RAISERROR(N'Creating config.collector_database_exclusions table', 0, 1) WITH NOWAIT;
+              END;
+
+              CREATE TABLE
+                  config.collector_database_exclusions
+              (
+                  database_name sysname NOT NULL,
+                  excluded_at datetime2(7) NOT NULL DEFAULT SYSDATETIME(),
+                  excluded_by sysname NULL DEFAULT SUSER_SNAME(),
+                  CONSTRAINT PK_collector_database_exclusions PRIMARY KEY CLUSTERED (database_name) WITH (DATA_COMPRESSION = PAGE)
+              );
+
+              SET @tables_created = @tables_created + 1;
+
+              INSERT INTO
+                  config.collection_log
+              (
+                  collector_name,
+                  collection_status,
+                  error_message
+              )
+              VALUES
+              (
+                  N'ensure_config_tables',
+                  N'TABLE_CREATED',
+                  N'Created config.collector_database_exclusions table'
+              );
+          END;
+
         /*
         Create config.installation_history
         */
diff --git a/install/08_collect_query_stats.sql b/install/08_collect_query_stats.sql
index 2092d557..f01d6cba 100644
--- a/install/08_collect_query_stats.sql
+++ b/install/08_collect_query_stats.sql
@@ -406,6 +406,13 @@ BEGIN
             DB_ID(N'PerformanceMonitor')
         )
         AND   pa.dbid < 32761 /*exclude contained AG system databases*/
+        AND   NOT EXISTS
+        (
+            SELECT
+                1/0
+            FROM config.collector_database_exclusions AS e
+            WHERE e.database_name = d.name
+        )
         OPTION(RECOMPILE);
 
         /*
diff --git a/install/09_collect_query_store.sql b/install/09_collect_query_store.sql
index d13df2a7..1b471d90 100644
--- a/install/09_collect_query_store.sql
+++ b/install/09_collect_query_store.sql
@@ -351,6 +351,13 @@ BEGIN
                 drs.database_id IS NULL          /*not in any AG*/
                 OR drs.is_primary_replica = 1    /*primary replica*/
             )
+            AND NOT EXISTS
+            (
+                SELECT
+                    1/0
+                FROM config.collector_database_exclusions AS e
+                WHERE e.database_name = d.name
+            )
             OPTION(RECOMPILE);
 
         OPEN @db_check_cursor;
diff --git a/install/10_collect_procedure_stats.sql b/install/10_collect_procedure_stats.sql
index abe44e9a..5d99ad33 100644
--- a/install/10_collect_procedure_stats.sql
+++ b/install/10_collect_procedure_stats.sql
@@ -339,6 +339,13 @@ BEGIN
             DB_ID(N'PerformanceMonitor')
         )
         AND   pa.dbid < 32761 /*exclude contained AG system databases*/
+        AND   NOT EXISTS
+        (
+            SELECT
+                1/0
+            FROM config.collector_database_exclusions AS e
+            WHERE e.database_name = d.name
+        )
 
         UNION ALL
 
@@ -508,6 +515,13 @@ BEGIN
             DB_ID(N'PerformanceMonitor')
         )
         AND   pa.dbid < 32761 /*exclude contained AG system databases*/
+        AND   NOT EXISTS
+        (
+            SELECT
+                1/0
+            FROM config.collector_database_exclusions AS e
+            WHERE e.database_name = d.name
+        )
         UNION ALL
 
         SELECT
diff --git a/install/20_collect_file_io_stats.sql b/install/20_collect_file_io_stats.sql
index 44b71021..7d0545fa 100644
--- a/install/20_collect_file_io_stats.sql
+++ b/install/20_collect_file_io_stats.sql
@@ -176,6 +176,13 @@ BEGIN
             DB_ID(N'msdb')     /*4*/
         )
         AND   vfs.database_id < 32761 /*exclude resource database and contained AG system databases*/
+        AND   NOT EXISTS
+        (
+            SELECT
+                1/0
+            FROM config.collector_database_exclusions AS e
+            WHERE e.database_name = d.name
+        )
         OPTION(RECOMPILE);
 
         SET @rows_collected = ROWCOUNT_BIG();
diff --git a/install/37_collect_waiting_tasks.sql b/install/37_collect_waiting_tasks.sql
index e7564d89..1db92c4f 100644
--- a/install/37_collect_waiting_tasks.sql
+++ b/install/37_collect_waiting_tasks.sql
@@ -183,6 +183,13 @@ BEGIN
               WHERE iwt.wait_type = wt.wait_type
               AND   iwt.is_enabled = 1
         )
+        AND   NOT EXISTS
+        (
+              SELECT
+                  1/0
+              FROM config.collector_database_exclusions AS e
+              WHERE e.database_name = d.name
+        )
         OPTION(RECOMPILE);
 
         SET @rows_collected = ROWCOUNT_BIG();
diff --git a/install/39_collect_database_configuration.sql b/install/39_collect_database_configuration.sql
index f6a4202c..8927287a 100644
--- a/install/39_collect_database_configuration.sql
+++ b/install/39_collect_database_configuration.sql
@@ -144,6 +144,13 @@ BEGIN
         AND   d.name != DB_NAME()
         AND   d.state_desc = N'ONLINE'
         AND   d.database_id < 32761 /*exclude contained AG system databases*/
+        AND   NOT EXISTS
+        (
+            SELECT
+                1/0
+            FROM config.collector_database_exclusions AS e
+            WHERE e.database_name = d.name
+        )
         OPTION (RECOMPILE);
 
         IF @debug = 1
@@ -173,6 +180,13 @@ BEGIN
                 drs.database_id IS NULL          /*not in any AG*/
                 OR drs.is_primary_replica = 1    /*primary replica*/
             )
+            AND NOT EXISTS
+            (
+                SELECT
+                    1/0
+                FROM config.collector_database_exclusions AS e
+                WHERE e.database_name = d.name
+            )
             ORDER BY
                 d.name
             OPTION (RECOMPILE);
diff --git a/install/52_collect_database_size_stats.sql b/install/52_collect_database_size_stats.sql
index 11e71e08..57c6f14c 100644
--- a/install/52_collect_database_size_stats.sql
+++ b/install/52_collect_database_size_stats.sql
@@ -195,6 +195,13 @@ BEGIN
                 WHERE d.state = 0 /*ONLINE only — skip RESTORING databases (mirroring/AG secondary)*/
                 AND   d.database_id > 0
                 AND   HAS_DBACCESS(d.name) = 1
+                AND   NOT EXISTS
+                (
+                    SELECT
+                        1/0
+                    FROM config.collector_database_exclusions AS e
+                    WHERE e.database_name = d.name
+                )
                 ORDER BY
                     d.database_id;
 
diff --git a/install/53_collect_server_properties.sql b/install/53_collect_server_properties.sql
index fb1b1c21..c77ceafd 100644
--- a/install/53_collect_server_properties.sql
+++ b/install/53_collect_server_properties.sql
@@ -136,6 +136,13 @@ BEGIN
                 WHERE d.state = 0 /*ONLINE only — skip RESTORING databases (mirroring/AG secondary)*/
                 AND   d.database_id > 4 /*Skip system databases*/
                 AND   HAS_DBACCESS(d.name) = 1
+                AND   NOT EXISTS
+                (
+                    SELECT
+                        1/0
+                    FROM config.collector_database_exclusions AS e
+                    WHERE e.database_name = d.name
+                )
                 ORDER BY
                     d.database_id;
 

From f79c14cfb8ffd7927e3335953a42b7be949304d5 Mon Sep 17 00:00:00 2001
From: Erik Darling <2136037+erikdarlingdata@users.noreply.github.com>
Date: Mon, 27 Apr 2026 22:45:12 -0400
Subject: [PATCH 47/49] Add per-database exclusions for Lite collectors (#887)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Lite-side companion to PR #905 — gives users a per-server way to skip
specific databases in the per-database collectors.

Storage: ExcludedDatabases (List<string>) added to ServerConnection,
persisted via the existing servers.json round-trip. Lite doesn't install
on targets, so the list lives client-side instead of in a remote
config.collector_database_exclusions table the way Dashboard does it.

Wiring: 9 collectors get the filter — query_stats, query_store,
procedure_stats, query_snapshots, file_io_stats, waiting_tasks,
database_configuration, database_scoped_configurations, database_size.
Azure-mode collectors that route through GetAzureDatabaseListAsync get
exclusions automatically since the helper now applies the filter
centrally.

Two SQL helpers on RemoteCollectorService:
- BuildDatabaseExclusionFilter — parameterized AND <col> NOT IN (@excl_db_N).
  Used by every collector whose query is plain (non-dynamic) T-SQL.
  No compatibility-level dependency (avoids OPENJSON / STRING_SPLIT which
  require compat 130+ on the connection database).
- BuildDatabaseExclusionLiteralClause — N'name' literals with single-quote
  escaping (and a forNestedDynamicSql=true mode that doubles the escape).
  Used by procedure_stats which builds @sql then passes to sp_executesql,
  where parameter binding inside the dynamic statement is awkward.
  Names come from a user-picked checklist, so literal interpolation with
  proper escaping is safe.

UI: ManageServersWindow gets a new "Excluded Databases" button between
Edit and Delete. Right-click context menu now mirrors the buttons —
Edit / Excluded Databases / Delete on top, then the existing
Copy/Export items below a separator. New ExcludedDatabasesDialog
mirrors the Dashboard version: live-queries sys.databases, hides system
DBs, pre-checks current exclusions, shows stale entries (in list but not
on server) greyed with "(missing)" tag. Save calls
ServerManager.UpdateServer to persist via servers.json.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
---
 Lite/Models/ServerConnection.cs               |   7 +
 .../RemoteCollectorService.DatabaseSize.cs    |  13 +-
 .../Services/RemoteCollectorService.FileIo.cs |   7 +
 .../RemoteCollectorService.ProcedureStats.cs  |  15 +-
 .../RemoteCollectorService.QuerySnapshots.cs  |  14 ++
 .../RemoteCollectorService.QueryStats.cs      |  11 +-
 .../RemoteCollectorService.QueryStore.cs      |  12 +-
 .../RemoteCollectorService.ServerConfig.cs    |  17 +-
 .../RemoteCollectorService.WaitingTasks.cs    |   8 +-
 Lite/Services/RemoteCollectorService.cs       |  53 +++++-
 Lite/Windows/ExcludedDatabasesDialog.xaml     |  50 +++++
 Lite/Windows/ExcludedDatabasesDialog.xaml.cs  | 174 ++++++++++++++++++
 Lite/Windows/ManageServersWindow.xaml         |   6 +
 Lite/Windows/ManageServersWindow.xaml.cs      |  19 ++
 14 files changed, 397 insertions(+), 9 deletions(-)
 create mode 100644 Lite/Windows/ExcludedDatabasesDialog.xaml
 create mode 100644 Lite/Windows/ExcludedDatabasesDialog.xaml.cs

diff --git a/Lite/Models/ServerConnection.cs b/Lite/Models/ServerConnection.cs
index 5f347a92..539d7c43 100644
--- a/Lite/Models/ServerConnection.cs
+++ b/Lite/Models/ServerConnection.cs
@@ -95,6 +95,13 @@ public bool UseWindowsAuth
     /// </summary>
     public bool MultiSubnetFailover { get; set; } = false;
 
+    /// <summary>
+    /// User databases to skip in per-database collectors (query_store, file_io_stats, etc.).
+    /// System databases (master/tempdb/model/msdb) and the connection database itself are always
+    /// excluded by the collectors and aren't represented here.
+    /// </summary>
+    public System.Collections.Generic.List<string> ExcludedDatabases { get; set; } = new();
+
     /// <summary>
     /// Server name with "(Read-Only)" suffix when ReadOnlyIntent is enabled.
     /// Used for sidebar subtitle and status text.
diff --git a/Lite/Services/RemoteCollectorService.DatabaseSize.cs b/Lite/Services/RemoteCollectorService.DatabaseSize.cs
index ad765fd2..7d9227ac 100644
--- a/Lite/Services/RemoteCollectorService.DatabaseSize.cs
+++ b/Lite/Services/RemoteCollectorService.DatabaseSize.cs
@@ -30,7 +30,7 @@ private async Task<int> CollectDatabaseSizeStatsAsync(ServerConnection server, C
         var serverStatus = _serverManager.GetConnectionStatus(server.Id);
         bool isAzureSqlDb = serverStatus?.SqlEngineEdition == 5;
 
-        const string onPremQuery = @"
+        string onPremQuery = @"
 SET TRANSACTION ISOLATION LEVEL READ UNCOMMITTED;
 SET NOCOUNT ON;
 
@@ -52,6 +52,7 @@ FROM sys.databases AS d
     WHERE d.state_desc = N'ONLINE'
     AND   d.database_id > 0
     AND   HAS_DBACCESS(d.name) = 1
+    /*EXCLUSION_FILTER_CURSOR*/
     ORDER BY
         d.name;
 
@@ -131,11 +132,19 @@ LEFT JOIN #file_space AS fs
   ON  fs.database_id = mf.database_id
   AND fs.file_id = mf.file_id
 WHERE d.state_desc = N'ONLINE'
+/*EXCLUSION_FILTER_OUTER*/
 ORDER BY
     d.name,
     mf.file_id
 OPTION(RECOMPILE);";
 
+        /* Both filter sites (cursor SELECT and final SELECT) are in outer T-SQL, not nested dynamic SQL,
+           so parameter bindings work fine and the same @excl_db_N can be referenced twice. */
+        var (dbSizeExclusionClause, _) = BuildDatabaseExclusionFilter(server.ExcludedDatabases, "d.name");
+        onPremQuery = onPremQuery
+            .Replace("/*EXCLUSION_FILTER_CURSOR*/", dbSizeExclusionClause)
+            .Replace("/*EXCLUSION_FILTER_OUTER*/", dbSizeExclusionClause);
+
         const string azureSqlDbQuery = @"
 SET TRANSACTION ISOLATION LEVEL READ UNCOMMITTED;
 
@@ -231,6 +240,8 @@ ORDER BY
             using var sqlConnection = await CreateConnectionAsync(server, cancellationToken);
             using var command = new SqlCommand(onPremQuery, sqlConnection);
             command.CommandTimeout = CommandTimeoutSeconds;
+            var (_, dbSizeExclusionParams) = BuildDatabaseExclusionFilter(server.ExcludedDatabases, "d.name");
+            foreach (var p in dbSizeExclusionParams) command.Parameters.Add(p);
 
             using var reader = await command.ExecuteReaderAsync(cancellationToken);
             while (await reader.ReadAsync(cancellationToken))
diff --git a/Lite/Services/RemoteCollectorService.FileIo.cs b/Lite/Services/RemoteCollectorService.FileIo.cs
index 203573e4..a1ac8a8e 100644
--- a/Lite/Services/RemoteCollectorService.FileIo.cs
+++ b/Lite/Services/RemoteCollectorService.FileIo.cs
@@ -83,8 +83,13 @@ LEFT JOIN sys.databases AS d
 WHERE (vfs.database_id > 4 OR vfs.database_id = 2)
 AND   vfs.database_id < 32761
 AND   vfs.database_id <> ISNULL(DB_ID(N'PerformanceMonitor'), 0)
+/*EXCLUSION_FILTER*/
 OPTION(RECOMPILE);";
 
+        /* Azure path filters via GetAzureDatabaseListAsync; on-prem path injects here */
+        var (fileIoExclusionClause, _) = BuildDatabaseExclusionFilter(server.ExcludedDatabases, "d.name");
+        query = query.Replace("/*EXCLUSION_FILTER*/", isAzureSqlDb ? string.Empty : fileIoExclusionClause);
+
         var serverId = GetServerId(server);
         var collectionTime = DateTime.UtcNow;
         var rowsCollected = 0;
@@ -125,6 +130,8 @@ AND   vfs.database_id < 32761
         {
             using var sqlConnection = await CreateConnectionAsync(server, cancellationToken);
             using var command = new SqlCommand(query, sqlConnection) { CommandTimeout = CommandTimeoutSeconds };
+            var (_, fileIoExclusionParams) = BuildDatabaseExclusionFilter(server.ExcludedDatabases, "d.name");
+            foreach (var p in fileIoExclusionParams) command.Parameters.Add(p);
             using var reader = await command.ExecuteReaderAsync(cancellationToken);
             while (await reader.ReadAsync(cancellationToken))
                 fileStats.Add(ReadFileIoRow(reader));
diff --git a/Lite/Services/RemoteCollectorService.ProcedureStats.cs b/Lite/Services/RemoteCollectorService.ProcedureStats.cs
index 58a50570..3bd37c31 100644
--- a/Lite/Services/RemoteCollectorService.ProcedureStats.cs
+++ b/Lite/Services/RemoteCollectorService.ProcedureStats.cs
@@ -32,7 +32,7 @@ so the standard NOT IN filter excludes everything. Use a simplified query. */
         /* total_spills/min_spills/max_spills exist in dm_exec_procedure_stats and dm_exec_trigger_stats
            on all supported versions, but do NOT exist in dm_exec_function_stats on any version.
            Use dynamic SQL to handle this. */
-        const string standardQuery = @"
+        string standardQuery = @"
 SET TRANSACTION ISOLATION LEVEL READ UNCOMMITTED;
 
 DECLARE
@@ -81,6 +81,7 @@ INNER JOIN sys.databases AS d
 WHERE d.state = 0
 AND   pa.dbid NOT IN (1, 3, 4, 32761, 32767, ISNULL(DB_ID(N''PerformanceMonitor''), 0))
 AND   s.last_execution_time >= DATEADD(MINUTE, -10, GETDATE())
+/*EXCLUSION_FILTER*/
 
 UNION ALL
 
@@ -136,6 +137,7 @@ INNER JOIN sys.databases AS d
 WHERE d.state = 0
 AND   pa.dbid NOT IN (1, 3, 4, 32761, 32767, ISNULL(DB_ID(N''PerformanceMonitor''), 0))
 AND   s.last_execution_time >= DATEADD(MINUTE, -10, GETDATE())
+/*EXCLUSION_FILTER*/
 
 UNION ALL
 
@@ -178,6 +180,7 @@ INNER JOIN sys.databases AS d
 WHERE d.state = 0
 AND   pa.dbid NOT IN (1, 3, 4, 32761, 32767, ISNULL(DB_ID(N''PerformanceMonitor''), 0))
 AND   s.last_execution_time >= DATEADD(MINUTE, -10, GETDATE())
+/*EXCLUSION_FILTER*/
 ) AS combined
 ORDER BY total_elapsed_time DESC
 OPTION(RECOMPILE);' AS nvarchar(max));
@@ -220,9 +223,19 @@ No trigger stats or function stats — Azure SQL DB scope is single-database. */
 FROM sys.dm_exec_procedure_stats AS s
 WHERE s.database_id = DB_ID()
 AND   s.last_execution_time >= DATEADD(MINUTE, -10, GETDATE())
+/*EXCLUSION_FILTER*/
 ORDER BY s.total_elapsed_time DESC
 OPTION(RECOMPILE);";
 
+        /* Standard query is dynamic SQL (built into @sql then passed to sp_executesql), so the
+           exclusion filter is interpolated as literal N'...' values rather than parameter bindings.
+           Names come from a user-picked checklist of existing DBs, escaped against single-quote
+           injection. forNestedDynamicSql=true doubles the escape because @sql is itself a
+           single-quoted T-SQL string at the outer layer. */
+        string standardExclusionClause = BuildDatabaseExclusionLiteralClause(
+            server.ExcludedDatabases, "d.name", forNestedDynamicSql: true);
+        standardQuery = standardQuery.Replace("/*EXCLUSION_FILTER*/", standardExclusionClause);
+
         string query = isAzureSqlDb ? azureSqlDbQuery : standardQuery;
 
         var serverId = GetServerId(server);
diff --git a/Lite/Services/RemoteCollectorService.QuerySnapshots.cs b/Lite/Services/RemoteCollectorService.QuerySnapshots.cs
index c18523c0..6e1de963 100644
--- a/Lite/Services/RemoteCollectorService.QuerySnapshots.cs
+++ b/Lite/Services/RemoteCollectorService.QuerySnapshots.cs
@@ -232,6 +232,18 @@ private async Task<int> CollectQuerySnapshotsAsync(ServerConnection server, Canc
 
         var query = BuildQuerySnapshotsQuery(supportsLiveQueryPlan, isAzureSqlDatabase);
 
+        /* Append the per-database exclusion filter to the WHERE clause. The base query joins
+           sys.databases AS d, so we filter on d.name. When ExcludedDatabases is empty the
+           clause is "" so nothing changes. */
+        var (qsExclusionClause, _) = BuildDatabaseExclusionFilter(server.ExcludedDatabases, "d.name");
+        if (!string.IsNullOrEmpty(qsExclusionClause))
+        {
+            /* Inject just before the OPTION clause so it lands inside the WHERE. */
+            query = query.Replace(
+                "ORDER BY der.cpu_time DESC",
+                qsExclusionClause + "\nORDER BY der.cpu_time DESC");
+        }
+
         var serverId = GetServerId(server);
         var collectionTime = DateTime.UtcNow;
         var rowsCollected = 0;
@@ -242,6 +254,8 @@ private async Task<int> CollectQuerySnapshotsAsync(ServerConnection server, Canc
         using var sqlConnection = await CreateConnectionAsync(server, cancellationToken);
         using var command = new SqlCommand(query, sqlConnection);
         command.CommandTimeout = CommandTimeoutSeconds;
+        var (_, qsExclusionParams) = BuildDatabaseExclusionFilter(server.ExcludedDatabases, "d.name");
+        foreach (var p in qsExclusionParams) command.Parameters.Add(p);
 
         using var reader = await command.ExecuteReaderAsync(cancellationToken);
         sqlSw.Stop();
diff --git a/Lite/Services/RemoteCollectorService.QueryStats.cs b/Lite/Services/RemoteCollectorService.QueryStats.cs
index b47705a6..4a139c3d 100644
--- a/Lite/Services/RemoteCollectorService.QueryStats.cs
+++ b/Lite/Services/RemoteCollectorService.QueryStats.cs
@@ -31,7 +31,7 @@ Use a simplified query that skips plan_attributes entirely — there's only one
         var serverStatus = _serverManager.GetConnectionStatus(server.Id);
         bool isAzureSqlDb = serverStatus.SqlEngineEdition == 5;
 
-        const string standardQuery = @"
+        string standardQuery = @"
 SET TRANSACTION ISOLATION LEVEL READ UNCOMMITTED;
 
 SELECT /* PerformanceMonitorLite */ TOP (200)
@@ -106,10 +106,14 @@ INNER JOIN sys.databases AS d
 WHERE pa.dbid NOT IN (1, 2, 3, 4, 32761, 32767, ISNULL(DB_ID(N'PerformanceMonitor'), 0))
 AND   st.text NOT LIKE N'%PerformanceMonitorLite%'
 AND   qs.last_execution_time >= DATEADD(MINUTE, -10, GETDATE())
+/*EXCLUSION_FILTER*/
 ORDER BY
     qs.total_elapsed_time DESC
 OPTION(RECOMPILE);";
 
+        var (exclusionClause, _) = BuildDatabaseExclusionFilter(server.ExcludedDatabases, "d.name");
+        standardQuery = standardQuery.Replace("/*EXCLUSION_FILTER*/", exclusionClause);
+
         /* Azure SQL DB: skip plan_attributes, use DB_NAME() for the single database context */
         const string azureSqlDbQuery = @"
 SET TRANSACTION ISOLATION LEVEL READ UNCOMMITTED;
@@ -229,6 +233,11 @@ qs.total_elapsed_time DESC
                 {
                 using var command = new SqlCommand(query, sqlConnection);
                 command.CommandTimeout = CommandTimeoutSeconds;
+                if (!isAzureSqlDb)
+                {
+                    var (_, freshParams) = BuildDatabaseExclusionFilter(server.ExcludedDatabases, "d.name");
+                    foreach (var p in freshParams) command.Parameters.Add(p);
+                }
 
                 using var reader = await command.ExecuteReaderAsync(cancellationToken);
 
diff --git a/Lite/Services/RemoteCollectorService.QueryStore.cs b/Lite/Services/RemoteCollectorService.QueryStore.cs
index 9265c32e..5da8420a 100644
--- a/Lite/Services/RemoteCollectorService.QueryStore.cs
+++ b/Lite/Services/RemoteCollectorService.QueryStore.cs
@@ -32,7 +32,7 @@ Uses sys.database_query_store_options.actual_state instead of
         var serverStatus = _serverManager.GetConnectionStatus(server.Id);
         bool isAzureSqlDb = serverStatus?.SqlEngineEdition == 5;
 
-        const string onPremDbQuery = @"
+        string onPremDbQuery = @"
 SET NOCOUNT ON;
 SET TRANSACTION ISOLATION LEVEL READ UNCOMMITTED;
 
@@ -60,6 +60,7 @@ AND   d.name <> N'PerformanceMonitor'
         drs.database_id IS NULL          /*not in any AG*/
         OR drs.is_primary_replica = 1    /*primary replica*/
     )
+    /*EXCLUSION_FILTER*/
     OPTION(RECOMPILE);
 
 OPEN db_check;
@@ -103,7 +104,7 @@ FROM @result
 ORDER BY
     name;";
 
-        const string azureDbQuery = @"
+        string azureDbQuery = @"
 SET NOCOUNT ON;
 SET TRANSACTION ISOLATION LEVEL READ UNCOMMITTED;
 
@@ -123,6 +124,7 @@ WHERE d.database_id > 4
     AND   d.database_id < 32761
     AND   d.state_desc = N'ONLINE'
     AND   d.name <> N'PerformanceMonitor'
+    /*EXCLUSION_FILTER*/
     OPTION(RECOMPILE);
 
 OPEN db_check;
@@ -166,6 +168,10 @@ FROM @result
 ORDER BY
     name;";
 
+        var (exclusionClause, _) = BuildDatabaseExclusionFilter(server.ExcludedDatabases, "d.name");
+        onPremDbQuery = onPremDbQuery.Replace("/*EXCLUSION_FILTER*/", exclusionClause);
+        azureDbQuery = azureDbQuery.Replace("/*EXCLUSION_FILTER*/", exclusionClause);
+
         string dbQuery = isAzureSqlDb ? azureDbQuery : onPremDbQuery;
 
         var serverId = GetServerId(server);
@@ -187,6 +193,8 @@ ORDER BY
         using (var dbCommand = new SqlCommand(dbQuery, sqlConnection))
         {
             dbCommand.CommandTimeout = CommandTimeoutSeconds;
+            var (_, exclusionParams) = BuildDatabaseExclusionFilter(server.ExcludedDatabases, "d.name");
+            foreach (var p in exclusionParams) dbCommand.Parameters.Add(p);
             using var dbReader = await dbCommand.ExecuteReaderAsync(cancellationToken);
             while (await dbReader.ReadAsync(cancellationToken))
             {
diff --git a/Lite/Services/RemoteCollectorService.ServerConfig.cs b/Lite/Services/RemoteCollectorService.ServerConfig.cs
index 66f4b604..6feecd76 100644
--- a/Lite/Services/RemoteCollectorService.ServerConfig.cs
+++ b/Lite/Services/RemoteCollectorService.ServerConfig.cs
@@ -149,6 +149,8 @@ private async Task<int> CollectDatabaseConfigAsync(ServerConnection server, Canc
     is_optimized_locking_on = d.is_optimized_locking_on";
         }
 
+        var (dbConfigExclusionClause, _) = BuildDatabaseExclusionFilter(server.ExcludedDatabases, "d.name");
+
         var query = $@"
 SET TRANSACTION ISOLATION LEVEL READ UNCOMMITTED;
 
@@ -158,6 +160,7 @@ FROM sys.databases AS d
 WHERE (d.database_id > 4 OR d.database_id = 2)
 AND   d.database_id < 32761
 AND   d.name <> N'PerformanceMonitor'
+{dbConfigExclusionClause}
 ORDER BY d.name
 OPTION(RECOMPILE);";
 
@@ -173,6 +176,8 @@ ORDER BY d.name
         using var sqlConnection = await CreateConnectionAsync(server, cancellationToken);
         using var command = new SqlCommand(query, sqlConnection);
         command.CommandTimeout = CommandTimeoutSeconds;
+        var (_, dbConfigExclusionParams) = BuildDatabaseExclusionFilter(server.ExcludedDatabases, "d.name");
+        foreach (var p in dbConfigExclusionParams) command.Parameters.Add(p);
 
         using var reader = await command.ExecuteReaderAsync(cancellationToken);
         while (await reader.ReadAsync(cancellationToken))
@@ -329,7 +334,7 @@ private async Task<int> CollectDatabaseScopedConfigAsync(ServerConnection server
         var serverStatus = _serverManager.GetConnectionStatus(server.Id);
         bool isAzureSqlDb = serverStatus?.SqlEngineEdition == 5;
 
-        const string onPremDbQuery = @"
+        string onPremDbQuery = @"
 SET TRANSACTION ISOLATION LEVEL READ UNCOMMITTED;
 
 SELECT
@@ -347,10 +352,11 @@ AND   d.name <> N'PerformanceMonitor'
     drs.database_id IS NULL          /*not in any AG*/
     OR drs.is_primary_replica = 1    /*primary replica*/
 )
+/*EXCLUSION_FILTER*/
 ORDER BY d.name
 OPTION(RECOMPILE);";
 
-        const string azureDbQuery = @"
+        string azureDbQuery = @"
 SET TRANSACTION ISOLATION LEVEL READ UNCOMMITTED;
 
 SELECT
@@ -360,9 +366,14 @@ FROM sys.databases AS d
 AND   d.database_id < 32761
 AND   d.name <> N'PerformanceMonitor'
 AND   d.state_desc = N'ONLINE'
+/*EXCLUSION_FILTER*/
 ORDER BY d.name
 OPTION(RECOMPILE);";
 
+        var (scopedExclusionClause, _) = BuildDatabaseExclusionFilter(server.ExcludedDatabases, "d.name");
+        onPremDbQuery = onPremDbQuery.Replace("/*EXCLUSION_FILTER*/", scopedExclusionClause);
+        azureDbQuery = azureDbQuery.Replace("/*EXCLUSION_FILTER*/", scopedExclusionClause);
+
         string dbQuery = isAzureSqlDb ? azureDbQuery : onPremDbQuery;
 
         var serverId = GetServerId(server);
@@ -379,6 +390,8 @@ ORDER BY d.name
         using (var dbCommand = new SqlCommand(dbQuery, sqlConnection))
         {
             dbCommand.CommandTimeout = CommandTimeoutSeconds;
+            var (_, scopedExclusionParams) = BuildDatabaseExclusionFilter(server.ExcludedDatabases, "d.name");
+            foreach (var p in scopedExclusionParams) dbCommand.Parameters.Add(p);
             using var dbReader = await dbCommand.ExecuteReaderAsync(cancellationToken);
             while (await dbReader.ReadAsync(cancellationToken))
             {
diff --git a/Lite/Services/RemoteCollectorService.WaitingTasks.cs b/Lite/Services/RemoteCollectorService.WaitingTasks.cs
index bd9373b1..aaa7d2d0 100644
--- a/Lite/Services/RemoteCollectorService.WaitingTasks.cs
+++ b/Lite/Services/RemoteCollectorService.WaitingTasks.cs
@@ -24,7 +24,7 @@ public partial class RemoteCollectorService
     /// </summary>
     private async Task<int> CollectWaitingTasksAsync(ServerConnection server, CancellationToken cancellationToken)
     {
-        const string query = @"
+        string query = @"
 SET TRANSACTION ISOLATION LEVEL READ UNCOMMITTED;
 
 SELECT /* PerformanceMonitorLite */
@@ -42,8 +42,12 @@ LEFT JOIN sys.databases AS d
 AND   wt.session_id <> @@SPID
 AND   wt.wait_type IS NOT NULL
 AND   er.database_id <> ISNULL(DB_ID(N'PerformanceMonitor'), 0)
+/*EXCLUSION_FILTER*/
 OPTION(RECOMPILE);";
 
+        var (exclusionClause, _) = BuildDatabaseExclusionFilter(server.ExcludedDatabases, "d.name");
+        query = query.Replace("/*EXCLUSION_FILTER*/", exclusionClause);
+
         var serverId = GetServerId(server);
         var collectionTime = DateTime.UtcNow;
         var rowsCollected = 0;
@@ -54,6 +58,8 @@ AND   wt.wait_type IS NOT NULL
         using var sqlConnection = await CreateConnectionAsync(server, cancellationToken);
         using var command = new SqlCommand(query, sqlConnection);
         command.CommandTimeout = CommandTimeoutSeconds;
+        var (_, exclusionParams) = BuildDatabaseExclusionFilter(server.ExcludedDatabases, "d.name");
+        foreach (var p in exclusionParams) command.Parameters.Add(p);
 
         using var reader = await command.ExecuteReaderAsync(cancellationToken);
         sqlSw.Stop();
diff --git a/Lite/Services/RemoteCollectorService.cs b/Lite/Services/RemoteCollectorService.cs
index fdecb7d8..055f3702 100644
--- a/Lite/Services/RemoteCollectorService.cs
+++ b/Lite/Services/RemoteCollectorService.cs
@@ -634,15 +634,18 @@ protected async Task<List<string>> GetAzureDatabaseListAsync(ServerConnection se
             InitialCatalog = "master"
         }.ConnectionString;
 
+        var (exclusionClause, exclusionParams) = BuildDatabaseExclusionFilter(server.ExcludedDatabases, "name");
+
         var databases = new List<string>();
         try
         {
             using var conn = new SqlConnection(connStr);
             await conn.OpenAsync(cancellationToken);
             using var cmd = new SqlCommand(
-                "SELECT name FROM sys.databases WHERE state_desc = N'ONLINE' AND database_id > 0 ORDER BY name;",
+                $"SELECT name FROM sys.databases WHERE state_desc = N'ONLINE' AND database_id > 0 {exclusionClause} ORDER BY name;",
                 conn)
             { CommandTimeout = CommandTimeoutSeconds };
+            foreach (var p in exclusionParams) cmd.Parameters.Add(p);
             using var reader = await cmd.ExecuteReaderAsync(cancellationToken);
             while (await reader.ReadAsync(cancellationToken))
                 databases.Add(reader.GetString(0));
@@ -668,6 +671,54 @@ protected async Task<List<string>> GetAzureDatabaseListAsync(ServerConnection se
         }
     }
 
+    /// <summary>
+    /// Builds a SQL fragment and matching SqlParameters for excluding the supplied database names.
+    /// When the list is empty, returns ("", []) so callers can splice without effect.
+    /// Each name is parameterized — works on every supported SQL Server version (no STRING_SPLIT/OPENJSON
+    /// compatibility-level dependency).
+    /// </summary>
+    /// <param name="excludedDatabaseNames">Names from server.ExcludedDatabases.</param>
+    /// <param name="columnExpression">SQL column to filter, e.g. "d.name".</param>
+    internal static (string Clause, List<SqlParameter> Parameters) BuildDatabaseExclusionFilter(
+        IList<string>? excludedDatabaseNames, string columnExpression)
+    {
+        if (excludedDatabaseNames is null || excludedDatabaseNames.Count == 0)
+            return (string.Empty, new List<SqlParameter>());
+
+        var paramNames = new List<string>(excludedDatabaseNames.Count);
+        var sqlParams = new List<SqlParameter>(excludedDatabaseNames.Count);
+        for (int i = 0; i < excludedDatabaseNames.Count; i++)
+        {
+            string p = $"@excl_db_{i}";
+            paramNames.Add(p);
+            sqlParams.Add(new SqlParameter(p, System.Data.SqlDbType.NVarChar, 128) { Value = excludedDatabaseNames[i] });
+        }
+        return ($"AND {columnExpression} NOT IN ({string.Join(", ", paramNames)})", sqlParams);
+    }
+
+    /// <summary>
+    /// Builds a SQL fragment with database names interpolated as literal N'...' values.
+    /// Use this for dynamic SQL paths where parameter binding is awkward (e.g. inside
+    /// a string passed to sp_executesql). Names come from user-picked checklists of
+    /// existing databases, so literal interpolation with single-quote escaping is safe.
+    /// When forNestedDynamicSql=true, doubles the escape for use inside an outer T-SQL
+    /// string that itself becomes a dynamic-SQL @sql variable.
+    /// </summary>
+    internal static string BuildDatabaseExclusionLiteralClause(
+        IList<string>? excludedDatabaseNames, string columnExpression, bool forNestedDynamicSql = false)
+    {
+        if (excludedDatabaseNames is null || excludedDatabaseNames.Count == 0)
+            return string.Empty;
+
+        string escapedQuote = forNestedDynamicSql ? "''" : "'";
+        string Escape(string s) => forNestedDynamicSql
+            ? s.Replace("'", "''''")
+            : s.Replace("'", "''");
+
+        var quoted = excludedDatabaseNames.Select(n => $"N{escapedQuote}{Escape(n)}{escapedQuote}");
+        return $"AND {columnExpression} NOT IN ({string.Join(", ", quoted)})";
+    }
+
     private static List<string> SingleDbOrEmpty(string? targetDb)
     {
         if (string.IsNullOrEmpty(targetDb) || string.Equals(targetDb, "master", StringComparison.OrdinalIgnoreCase))
diff --git a/Lite/Windows/ExcludedDatabasesDialog.xaml b/Lite/Windows/ExcludedDatabasesDialog.xaml
new file mode 100644
index 00000000..7fbbae24
--- /dev/null
+++ b/Lite/Windows/ExcludedDatabasesDialog.xaml
@@ -0,0 +1,50 @@
+<Window x:Class="PerformanceMonitorLite.Windows.ExcludedDatabasesDialog"
+        xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
+        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
+        Title="Excluded Databases"
+        Height="500" Width="500"
+        WindowStartupLocation="CenterOwner"
+        Icon="/EDD.ico"
+        ResizeMode="CanResizeWithGrip"
+        Background="{DynamicResource BackgroundBrush}">
+    <Grid Margin="16">
+        <Grid.RowDefinitions>
+            <RowDefinition Height="Auto"/>
+            <RowDefinition Height="Auto"/>
+            <RowDefinition Height="*"/>
+            <RowDefinition Height="Auto"/>
+            <RowDefinition Height="Auto"/>
+        </Grid.RowDefinitions>
+
+        <TextBlock Grid.Row="0" x:Name="HeaderText" FontWeight="Bold" FontSize="14"
+                   Foreground="{DynamicResource ForegroundBrush}" Margin="0,0,0,8"/>
+
+        <TextBlock Grid.Row="1" TextWrapping="Wrap" FontSize="11"
+                   Foreground="{DynamicResource ForegroundMutedBrush}" Margin="0,0,0,12"
+                   Text="Databases marked here are skipped by per-database collectors (query_store, file_io_stats, etc.) on this server. System databases (master/tempdb/model/msdb) are always excluded."/>
+
+        <Border Grid.Row="2" BorderBrush="{DynamicResource BorderBrush}" BorderThickness="1" CornerRadius="4">
+            <ScrollViewer VerticalScrollBarVisibility="Auto" Padding="8">
+                <ItemsControl x:Name="DatabasesItemsControl">
+                    <ItemsControl.ItemTemplate>
+                        <DataTemplate>
+                            <CheckBox Content="{Binding DisplayName}"
+                                      IsChecked="{Binding IsExcluded, Mode=TwoWay}"
+                                      IsEnabled="{Binding IsEnabled}"
+                                      Foreground="{Binding ForegroundBrush}"
+                                      Margin="2,3"/>
+                        </DataTemplate>
+                    </ItemsControl.ItemTemplate>
+                </ItemsControl>
+            </ScrollViewer>
+        </Border>
+
+        <TextBlock Grid.Row="3" x:Name="StatusText" FontSize="10" FontStyle="Italic"
+                   Foreground="{DynamicResource ForegroundMutedBrush}" Margin="0,8,0,0"/>
+
+        <StackPanel Grid.Row="4" Orientation="Horizontal" HorizontalAlignment="Right" Margin="0,12,0,0">
+            <Button Content="Save" Width="80" Height="28" Margin="0,0,8,0" Click="Save_Click" Style="{StaticResource AccentButton}"/>
+            <Button Content="Cancel" Width="80" Height="28" Click="Cancel_Click" IsCancel="True"/>
+        </StackPanel>
+    </Grid>
+</Window>
diff --git a/Lite/Windows/ExcludedDatabasesDialog.xaml.cs b/Lite/Windows/ExcludedDatabasesDialog.xaml.cs
new file mode 100644
index 00000000..733fa090
--- /dev/null
+++ b/Lite/Windows/ExcludedDatabasesDialog.xaml.cs
@@ -0,0 +1,174 @@
+/*
+ * Copyright (c) 2026 Erik Darling, Darling Data LLC
+ *
+ * This file is part of the SQL Server Performance Monitor Lite.
+ *
+ * Licensed under the MIT License. See LICENSE file in the project root for full license information.
+ */
+
+using System;
+using System.Collections.Generic;
+using System.Collections.ObjectModel;
+using System.ComponentModel;
+using System.Linq;
+using System.Threading.Tasks;
+using System.Windows;
+using System.Windows.Media;
+using Microsoft.Data.SqlClient;
+using PerformanceMonitorLite.Models;
+using PerformanceMonitorLite.Services;
+
+namespace PerformanceMonitorLite.Windows;
+
+public partial class ExcludedDatabasesDialog : Window
+{
+    private readonly ServerManager _serverManager;
+    private readonly ServerConnection _server;
+    private ObservableCollection<DatabaseExclusionItem> _items = new();
+
+    public bool ExclusionsModified { get; private set; }
+
+    public ExcludedDatabasesDialog(ServerManager serverManager, ServerConnection server)
+    {
+        InitializeComponent();
+        _serverManager = serverManager;
+        _server = server;
+        HeaderText.Text = $"Excluded Databases — {server.DisplayNameWithIntent}";
+        Loaded += async (_, _) => await LoadAsync();
+    }
+
+    private async Task LoadAsync()
+    {
+        StatusText.Text = "Loading databases…";
+        DatabasesItemsControl.ItemsSource = null;
+
+        try
+        {
+            var liveDatabases = await GetUserDatabasesAsync();
+            var existingExclusions = _server.ExcludedDatabases ?? new List<string>();
+
+            var liveSet = new HashSet<string>(liveDatabases, StringComparer.OrdinalIgnoreCase);
+
+            _items = new ObservableCollection<DatabaseExclusionItem>();
+
+            foreach (var name in liveDatabases.OrderBy(n => n, StringComparer.OrdinalIgnoreCase))
+            {
+                _items.Add(new DatabaseExclusionItem
+                {
+                    Name = name,
+                    DisplayName = name,
+                    IsExcluded = existingExclusions.Contains(name, StringComparer.OrdinalIgnoreCase),
+                    IsEnabled = true,
+                    IsStale = false
+                });
+            }
+
+            /* Stale entries: in exclusion list but not present on the server. Greyed, disabled, pre-checked. */
+            foreach (var name in existingExclusions
+                         .Where(n => !liveSet.Contains(n))
+                         .OrderBy(n => n, StringComparer.OrdinalIgnoreCase))
+            {
+                _items.Add(new DatabaseExclusionItem
+                {
+                    Name = name,
+                    DisplayName = $"{name}  (missing)",
+                    IsExcluded = true,
+                    IsEnabled = false,
+                    IsStale = true
+                });
+            }
+
+            DatabasesItemsControl.ItemsSource = _items;
+            StatusText.Text = $"{liveDatabases.Count} database(s) on this server, {existingExclusions.Count} currently excluded.";
+        }
+        catch (Exception ex)
+        {
+            StatusText.Text = $"Failed to load: {ex.Message}";
+            MessageBox.Show(this,
+                $"Could not read database list from '{_server.DisplayNameWithIntent}':\n\n{ex.Message}",
+                "Load Failed",
+                MessageBoxButton.OK,
+                MessageBoxImage.Error);
+        }
+    }
+
+    private async Task<List<string>> GetUserDatabasesAsync()
+    {
+        var connectionString = _server.GetConnectionString(_serverManager.CredentialService);
+        var builder = new SqlConnectionStringBuilder(connectionString)
+        {
+            InitialCatalog = "master",
+            ConnectTimeout = 10
+        };
+
+        using var connection = new SqlConnection(builder.ConnectionString);
+        await connection.OpenAsync();
+
+        using var cmd = new SqlCommand(@"
+SELECT d.name
+FROM sys.databases AS d
+WHERE d.database_id > 4
+AND   d.state_desc = N'ONLINE'
+AND   d.database_id < 32761 /*exclude contained AG system databases*/
+ORDER BY d.name;", connection);
+        cmd.CommandTimeout = 30;
+
+        var names = new List<string>();
+        using var reader = await cmd.ExecuteReaderAsync();
+        while (await reader.ReadAsync())
+        {
+            names.Add(reader.GetString(0));
+        }
+        return names;
+    }
+
+    private void Save_Click(object sender, RoutedEventArgs e)
+    {
+        try
+        {
+            _server.ExcludedDatabases = _items
+                .Where(i => i.IsExcluded)
+                .Select(i => i.Name)
+                .ToList();
+
+            _serverManager.UpdateServer(_server);
+            ExclusionsModified = true;
+            DialogResult = true;
+        }
+        catch (Exception ex)
+        {
+            MessageBox.Show(this,
+                $"Failed to save exclusions:\n\n{ex.Message}",
+                "Save Failed",
+                MessageBoxButton.OK,
+                MessageBoxImage.Error);
+        }
+    }
+
+    private void Cancel_Click(object sender, RoutedEventArgs e)
+    {
+        DialogResult = false;
+    }
+}
+
+public class DatabaseExclusionItem : INotifyPropertyChanged
+{
+    public string Name { get; set; } = "";
+    public string DisplayName { get; set; } = "";
+    private bool _isExcluded;
+    public bool IsExcluded
+    {
+        get => _isExcluded;
+        set { _isExcluded = value; OnPropertyChanged(nameof(IsExcluded)); }
+    }
+    public bool IsEnabled { get; set; } = true;
+    public bool IsStale { get; set; }
+
+    public Brush ForegroundBrush => IsStale
+        ? (Brush)Application.Current.FindResource("ForegroundMutedBrush")
+        : (Brush)Application.Current.FindResource("ForegroundBrush");
+
+    public event PropertyChangedEventHandler? PropertyChanged;
+    private void OnPropertyChanged(string propertyName)
+        => PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(propertyName));
+}
diff --git a/Lite/Windows/ManageServersWindow.xaml b/Lite/Windows/ManageServersWindow.xaml
index 4fd1156e..3f687c65 100644
--- a/Lite/Windows/ManageServersWindow.xaml
+++ b/Lite/Windows/ManageServersWindow.xaml
@@ -9,6 +9,11 @@
     <Window.Resources>
         <ResourceDictionary>
             <ContextMenu x:Key="DataGridContextMenu">
+                <MenuItem Header="Edit" Click="EditMenuItem_Click"/>
+                <MenuItem Header="Excluded Databases" Click="ExcludedDatabases_Click"/>
+                <MenuItem Header="Delete" Click="DeleteMenuItem_Click"
+                          Foreground="{DynamicResource ErrorBrush}"/>
+                <Separator/>
                 <MenuItem Header="Copy Cell" Click="CopyCell_Click">
                     <MenuItem.Icon><TextBlock Text="&#x1F4CB;"/></MenuItem.Icon>
                 </MenuItem>
@@ -66,6 +71,7 @@
         <StackPanel Grid.Row="2" Orientation="Horizontal" HorizontalAlignment="Right" Margin="0,12,0,0">
             <Button Content="Add Server" Click="AddButton_Click" Style="{StaticResource AccentButton}" Margin="0,0,8,0"/>
             <Button Content="Edit" Click="EditButton_Click" Margin="0,0,8,0"/>
+            <Button Content="Excluded Databases" Click="ExcludedDatabases_Click" Margin="0,0,8,0"/>
             <Button Content="Delete" Click="DeleteButton_Click" Margin="0,0,8,0"/>
             <Button Content="Close" Click="CloseButton_Click"/>
         </StackPanel>
diff --git a/Lite/Windows/ManageServersWindow.xaml.cs b/Lite/Windows/ManageServersWindow.xaml.cs
index 03b6b8e8..aae0ccdf 100644
--- a/Lite/Windows/ManageServersWindow.xaml.cs
+++ b/Lite/Windows/ManageServersWindow.xaml.cs
@@ -70,6 +70,25 @@ private void EditSelected()
         }
     }
 
+    private void EditMenuItem_Click(object sender, RoutedEventArgs e) => EditSelected();
+
+    private void DeleteMenuItem_Click(object sender, RoutedEventArgs e) => DeleteButton_Click(sender, e);
+
+    private void ExcludedDatabases_Click(object sender, RoutedEventArgs e)
+    {
+        if (ServersGrid.SelectedItem is not ServerConnection selected)
+        {
+            return;
+        }
+
+        var dialog = new ExcludedDatabasesDialog(_serverManager, selected) { Owner = this };
+        if (dialog.ShowDialog() == true && dialog.ExclusionsModified)
+        {
+            ServersChanged = true;
+            RefreshGrid();
+        }
+    }
+
     private void DeleteButton_Click(object sender, RoutedEventArgs e)
     {
         if (ServersGrid.SelectedItem is not ServerConnection selected)

From c8e36a1def38e8120658f9fdb7f897b1e72ef930 Mon Sep 17 00:00:00 2001
From: Erik Darling <2136037+erikdarlingdata@users.noreply.github.com>
Date: Mon, 27 Apr 2026 22:55:55 -0400
Subject: [PATCH 48/49] Add docs/how-collection-works.md

Architecture overview of the collection pipeline for both Full and
Lite editions: the minute loop, dispatcher, collector shape, schedule
table, retention, Dashboard read path, and where-to-look-next
pointers for new contributors.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
---
 docs/how-collection-works.md | 207 +++++++++++++++++++++++++++++++++++
 1 file changed, 207 insertions(+)
 create mode 100644 docs/how-collection-works.md

diff --git a/docs/how-collection-works.md b/docs/how-collection-works.md
new file mode 100644
index 00000000..d153e635
--- /dev/null
+++ b/docs/how-collection-works.md
@@ -0,0 +1,207 @@
+# How Collection Works
+
+A tour of the collection pipeline for people who know SQL but don't know this codebase. Read this, then read three SQL files, and you'll understand 80% of what Performance Monitor is doing on your server.
+
+This doc covers both editions. Full Edition first (SQL Agent → `PerformanceMonitor` database → Dashboard reads), Lite Edition second (WPF app → DuckDB file → same app reads). The shapes are similar; the surface area is different.
+
+---
+
+## Full Edition
+
+### The minute loop
+
+Everything happens inside one SQL Agent job:
+
+| Job | What it runs |
+| --- | --- |
+| `PerformanceMonitor - Collection` | `EXEC collect.scheduled_master_collector @debug = 0;` on a 1-minute schedule (`Every 1 Minute`) |
+| `PerformanceMonitor - Data Retention` | `EXEC config.data_retention @debug = 1;` once a day |
+| `PerformanceMonitor - Hung Job Monitor` | Kills the Collection job if it's been stuck past its max duration |
+
+When the Collection job fires, it calls the **scheduled master collector** — the dispatcher. The dispatcher is the heartbeat of the whole system. Every minute it wakes up, figures out which collectors are due, and runs them one at a time.
+
+### The dispatcher
+
+**File**: [`install/42_scheduled_master_collector.sql`](../install/42_scheduled_master_collector.sql)
+
+At the core of the dispatcher is a cursor over `config.collection_schedule` that picks up anything due:
+
+```sql
+SELECT
+    cs.schedule_id,
+    cs.collector_name,
+    cs.frequency_minutes,
+    cs.max_duration_minutes
+FROM config.collection_schedule AS cs
+WHERE cs.enabled = 1
+AND   (
+          @force_run_all = 1
+          OR cs.next_run_time <= SYSDATETIME()
+          OR cs.next_run_time IS NULL
+      )
+ORDER BY
+    cs.next_run_time;
+```
+
+For each row, the dispatcher has a big `IF/ELSE IF` block that maps `collector_name` to a specific stored procedure:
+
+```sql
+ELSE IF @collector_name = N'default_trace_collector'
+BEGIN
+    EXECUTE collect.default_trace_collector @debug = @debug;
+END;
+ELSE IF @collector_name = N'blocking_deadlock_analyzer'
+BEGIN
+    EXECUTE collect.blocking_deadlock_analyzer @debug = @debug;
+END;
+-- ...etc
+```
+
+Each collector runs inside its own `BEGIN TRY / BEGIN CATCH` block — a failure in one doesn't stop the rest of the cycle. After each run (success or failure), the dispatcher bumps `last_run_time` and `next_run_time = last_run_time + frequency_minutes` so the next tick knows when that collector is eligible again.
+
+Before any of this, the dispatcher also does two self-heal steps:
+
+- **Ensures config tables exist** (`config.ensure_config_tables`) — lets you recover from an accidentally-dropped table without reinstalling.
+- **Detects server restarts** — if `sqlserver_start_time` has changed since last run, it captures a fresh snapshot of server properties. Config values only change across restarts, so this is the efficient moment to grab them.
+
+### What a collector looks like
+
+Pick any `install/NN_collect_*.sql` file — they all follow the same shape. A minimal example:
+
+**File**: [`install/29_collect_default_trace.sql`](../install/29_collect_default_trace.sql)
+
+```sql
+ALTER PROCEDURE
+    collect.default_trace_collector
+(
+    @hours_back integer = 2,
+    @include_memory_events bit = 1,
+    @include_autogrow_events bit = 1,
+    @include_object_events bit = 1,
+    -- ...more flags
+    @debug bit = 0
+)
+AS
+BEGIN
+    BEGIN TRY
+        -- 1. Validate parameters
+        IF @hours_back <= 0 OR @hours_back > 168
+        BEGIN
+            RAISERROR(N'@hours_back must be between 1 and 168 hours', 16, 1);
+            RETURN;
+        END;
+
+        -- 2. Detect first run (empty target table, no prior success in config.collection_log)
+        IF NOT EXISTS (SELECT 1/0 FROM collect.default_trace_events)
+        AND NOT EXISTS (SELECT 1/0 FROM config.collection_log WHERE collector_name = N'default_trace_collector' AND collection_status = N'SUCCESS')
+        BEGIN
+            SET @cutoff_time = CONVERT(datetime2(7), '19000101'); -- grab everything on first run
+        END;
+
+        -- 3. Query the DMV / system view
+        INSERT INTO collect.default_trace_events (...)
+        SELECT ...
+        FROM sys.fn_trace_gettable(@trace_path, @max_files) AS ft
+        WHERE ft.StartTime >= @cutoff_time
+        AND   <per-collector filters>
+        AND   NOT EXISTS (<dedupe lookup on event_time + event_class + spid + event_sequence>);
+
+        -- 4. Log success to config.collection_log
+        INSERT INTO config.collection_log (...) VALUES (..., 'SUCCESS', @rows_collected, ...);
+    END TRY
+    BEGIN CATCH
+        -- 5. Log failure with error message
+        INSERT INTO config.collection_log (...) VALUES (..., 'ERROR', 0, @error_message);
+        THROW;
+    END CATCH;
+END;
+```
+
+Every collector does exactly these five things: **validate, detect first-run, pull from DMV, insert with dedupe, log**. Once you've read one, you've read all thirty. The differences are the source DMV, the filter conditions, and the shape of the destination table.
+
+### The schedule table
+
+**File**: [`install/03_create_config_tables.sql`](../install/03_create_config_tables.sql) (table definition)
+
+`config.collection_schedule` is the single source of truth for *what runs and when*. It has one row per collector:
+
+| Column | Meaning |
+| --- | --- |
+| `collector_name` | The name the dispatcher's `IF/ELSE` block matches on |
+| `enabled` | Bit flag — off means the dispatcher skips this row entirely |
+| `frequency_minutes` | How often to run. `0` means "on connect / daily / special" (see below) |
+| `last_run_time` | When the collector last started — updated by the dispatcher |
+| `next_run_time` | When the collector is next eligible — `last_run_time + frequency_minutes` |
+| `max_duration_minutes` | Kill switch for the hung-job monitor |
+| `retention_days` | How long to keep data in the target `collect.*` table |
+
+You can edit this table directly, but **don't**. The supported knobs are:
+
+- **`config.apply_collection_preset`** — bulk-sets `frequency_minutes` for all collectors at once (presets: `Aggressive`, `Balanced`, `Low-Impact`).
+- **Individual `UPDATE` statements on `enabled`** — turn specific collectors on or off.
+
+**File**: [`install/41_schedule_management.sql`](../install/41_schedule_management.sql) has the preset procedure and some helper procs for listing / resetting the schedule.
+
+### Where does the data go?
+
+Each collector writes to a table in the `collect` schema — `collect.query_stats`, `collect.default_trace_events`, `collect.wait_stats`, etc. Same shape each time: a `collection_time datetime2` column, plus whatever the DMV gave us, plus whatever we computed.
+
+Some tables use `COMPRESS()` on large text/XML columns (query text, plan XML) — stored as `varbinary(max)` and wrapped in `DECOMPRESS()` on read. That's why query text looks like gibberish if you `SELECT * FROM collect.query_stats` directly — read through `v_query_stats` instead, which handles the decompression.
+
+### The Dashboard read path
+
+The Dashboard is a WPF app. It connects to the `PerformanceMonitor` database and issues SELECT queries. No collection happens in the app — the Dashboard is purely a reader. Every time you pick a time range, change a tab, or hit refresh, the app runs a SQL query against `collect.*` tables or `v_*` views, pulls rows into a `List<T>`, and binds that list to a WPF DataGrid or a ScottPlot chart.
+
+The query layer lives in `Dashboard/Services/DatabaseService.*.cs` — split by concern (`DatabaseService.QueryPerformance.cs`, `DatabaseService.SystemEvents.cs`, etc.). Each file is just SQL in C# strings. If the Dashboard is showing you something, there's a method somewhere in that folder returning it.
+
+### Retention
+
+**File**: [`install/45_create_agent_jobs.sql`](../install/45_create_agent_jobs.sql) (job definition) and wherever `config.data_retention` lives.
+
+Once a day, the `PerformanceMonitor - Data Retention` job runs a `DELETE` loop per `collect.*` table, respecting each row's `retention_days` from `config.collection_schedule`. Targeted batched deletes, not a truncate — history older than the retention window disappears; recent data is untouched.
+
+---
+
+## Lite Edition
+
+### What's different
+
+Lite is a standalone WPF app — **no SQL Agent involved, no PerformanceMonitor database**. The app itself is the collector, and the storage is a local DuckDB file (`%LocalAppData%\PerformanceMonitorLite\pm_lite.duckdb`).
+
+The shape still mirrors Full: a dispatcher picks collectors, each collector pulls from DMVs and writes to a destination table, and a reader service hands data to the UI.
+
+### The two services
+
+**Writer**: [`Lite/Services/RemoteCollectorService.cs`](../Lite/Services/RemoteCollectorService.cs) plus one `RemoteCollectorService.<Name>.cs` partial per collector (19 of them). The service opens a `SqlConnection` to the monitored server, runs DMV queries, and bulk-inserts results into DuckDB.
+
+**Reader**: [`Lite/Services/LocalDataService.*.cs`](../Lite/Services/) — queries DuckDB and returns results to the UI.
+
+Only one connection writes at a time. DuckDB is single-writer, so within a given server the collectors run **sequentially** (not in parallel). Multi-server parallelism still works — each monitored server runs its own serialized collector chain.
+
+### The schedule
+
+**File**: [`Lite/config/collection_schedule.json`](../Lite/config/collection_schedule.json)
+
+A JSON file, not a table. User-editable. The Lite app reads it at startup and at each wake-up tick. Same shape as the Full Edition schedule (name, enabled, frequency_minutes, retention_days) with one convention: `frequency_minutes: 0` means "run once at connect time" — used for server config, database config, trace flags, etc. that don't change between restarts.
+
+### Data retention
+
+Lite runs retention inline as part of each collection cycle — no separate job. Each collector checks its `retention_days` against the max timestamp in its target table and deletes older rows. DuckDB checkpoints after each cycle to flush the WAL.
+
+---
+
+## Where to look next
+
+If you want to **understand a specific feature**, find the code from the UI outward:
+1. Find the grid/chart in the app.
+2. Find its XAML file (`Dashboard/*.xaml` or `Lite/Controls/*.xaml`).
+3. Follow the `Click` handler or `ItemsSource` binding to the `*.xaml.cs` file.
+4. Follow the service call (`_databaseService.GetXxxAsync(...)` in Full, `LocalDataService.GetXxxAsync(...)` in Lite) to the query.
+
+If you want to **understand a specific collector**, read:
+1. `install/NN_collect_<name>.sql` for Full Edition, or
+2. `Lite/Services/RemoteCollectorService.<Name>.cs` for Lite.
+
+If you want to **add a collector or a new data source**, the dispatcher file in Full (`42_scheduled_master_collector.sql`) or `RemoteCollectorService.cs` in Lite is where you wire it up — those are the files that know about every collector.
+
+If something feels genuinely undocumented rather than "read the code," open an issue. Gaps get prioritized based on what comes up.

From ebd458e45a900286820cb344813434ca7a7a1ec9 Mon Sep 17 00:00:00 2001
From: Erik Darling <2136037+erikdarlingdata@users.noreply.github.com>
Date: Tue, 28 Apr 2026 11:18:42 -0400
Subject: [PATCH 49/49] Release v2.9.0: Installed Version column, Lite-style
 indicators in Full, version bumps

- New Installed Version column in Manage Servers for both editions:
  * Full: probes config.installation_history per server in parallel
  * Lite: shows the running app version (mirrors Full's header for consistency)
- Back-ports the Ellipse-with-DataTriggers status dot and right-aligned
  favorite star from Lite's server list to the Full Dashboard
- Bumps Version/AssemblyVersion/FileVersion/InformationalVersion to 2.9.0
  in Dashboard, Lite, Installer, and Installer.Core
- Rewrites CHANGELOG: fixes the 2.8.0 date to 2026-04-22 (was TBD), moves
  Off preset (#888) to 2.9.0 since #891 landed after the v2.8.0 tag, and
  adds the full 2.9.0 entry covering the post-2.8.0 PR set
- Updates README's DuckDB version reference (1.5.0 -> 1.5.2)

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
---
 CHANGELOG.md                                 |  47 ++++++++-
 Dashboard/Dashboard.csproj                   |   8 +-
 Dashboard/MainWindow.xaml                    | 104 ++++++++++++-------
 Dashboard/ManageServersWindow.xaml           |   1 +
 Dashboard/ManageServersWindow.xaml.cs        |  37 ++++++-
 Dashboard/Models/ServerConnection.cs         |  25 ++++-
 Dashboard/Models/ServerListItem.cs           |  15 +++
 Installer.Core/Installer.Core.csproj         |   8 +-
 Installer/PerformanceMonitorInstaller.csproj |   8 +-
 Lite/Models/ServerConnection.cs              |  24 ++++-
 Lite/PerformanceMonitorLite.csproj           |   8 +-
 Lite/Windows/ManageServersWindow.xaml        |   1 +
 Lite/Windows/ManageServersWindow.xaml.cs     |  23 +++-
 README.md                                    |   2 +-
 14 files changed, 249 insertions(+), 62 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index a0b1f540..e9a156bc 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -5,7 +5,50 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
-## [2.8.0] - TBD
+## [2.9.0] - TBD
+
+### Important
+
+- **Breaking change to `config.data_retention`** — the `@truncate_all` parameter has been removed. Pass `@retention_days = 0` for the same behavior. `@retention_days = NULL` (default) respects per-collector retention from `config.collection_schedule` with a 30-day fallback for unscheduled tables; `@retention_days = N > 0` overrides every table to N days. Any existing Agent jobs or scripts calling `data_retention @truncate_all = 1` need to be updated ([#900])
+- **New `config.collector_database_exclusions` table** for per-database collector exclusions. Eight per-database collectors filter against this table; system databases remain hard-skipped by the collectors themselves. Existing installs get the table on the next upgrade — `install/01_install_database.sql` and `config.ensure_config_tables` both create it under an `IF OBJECT_ID … IS NULL` guard ([#887])
+
+### Added
+
+- **Per-database collector exclusions** — exclude noisy or unimportant databases from per-database collectors. Dashboard side adds `config.collector_database_exclusions` and filters 8 collectors (`query_stats`, `query_store`, `procedure_stats`, `file_io_stats`, `waiting_tasks`, `database_configuration`, `database_size_stats`, `server_properties`). Lite side adds an `ExcludedDatabases` list per server in `servers.json` and filters 9 collectors ([#887])
+- **`Off` collection preset** — `EXECUTE config.apply_collection_preset @preset_name = N'Off'` disables every collector in one call. Pair with a second Agent job that applies a non-`Off` preset at the start of your active window for overnight / quiet-hours scoping. Non-`Off` presets now also set `enabled = 1` across the board so the switch from `Off → Balanced` reliably resumes collection ([#888])
+- **Purge Now action** in Manage Servers — confirm dialog with a mode picker (Use configured / 1 / 3 / 7 / Custom / All) drives `config.data_retention`; right-click menu on the Manage Servers grid mirrors every per-row action (Edit, Toggle Favorite, Check Server Version, Purge Now, Remove) ([#900])
+- **Total non-idle CPU on Lite Overview** — headline value shows total CPU with the SQL-only value alongside (e.g. `64% (SQL 60%)`); new `CpuAlertMode` dropdown in Settings → Alerts (Total / SqlOnly) drives both the alert evaluator and headline color; tray notifications and email alerts label the value as "Total CPU" or "SQL CPU" ([#899])
+- **Resume gap detection** — `query_stats`, `procedure_stats`, and `query_store` collectors skip the historical sweep on first run after an Off preset, Agent stoppage, or server reboot. When the last successful run is older than 5× the configured `frequency_minutes` (floored at 30 minutes), the cutoff clamps to `SYSDATETIME()` so only forward-going data is collected on resume — preventing the tempdb blowout that hit the original reporter ([#892])
+- **Right-click View Plan** on Dashboard Blocked Process Reports (View Blocked Plan + View Blocking Plan), Dashboard Deadlocks, and Lite Deadlocks grids. Plan lookup hits `sys.dm_exec_query_stats` + `sys.dm_exec_text_query_plan` on the monitored server, falling back to `executionStack/frame` entries when the process-level `sql_handle` is empty or evicted ([#880])
+- **Open Log Folder** sidebar button in Lite — opens `%LocalAppData%\PerformanceMonitorLite\logs\` in Explorer for grabbing historical logs to attach to bug reports. Sits below View Log, which retains its existing behavior of opening today's log file ([#873])
+- **Installed Version column** in the Manage Servers grid for both Dashboard and Lite. Dashboard shows the PerformanceMonitor database version on each server (probed in parallel via `GetInstalledVersionAsync`, with `Not installed` / `Unavailable` fallbacks). Lite shows the running app's own version on every row, mirroring Full's column header for consistency.
+- **Lite-style server card indicators in Full** — back-ported the Ellipse-with-DataTriggers status dot (Online/Offline/Warning/Unknown) and the right-aligned favorite star from Lite to the Full Dashboard's server list, matching Lite's visual treatment.
+- **Architecture overview** at `docs/how-collection-works.md` covering the minute loop, dispatcher, collector shape, `config.collection_schedule`, retention, and the Dashboard read path
+
+### Changed
+
+- **PlanIconMapper synced** with PerformanceStudio v1.9.0 improvements — columnstore storage type on scan/delete/insert/update/merge operators routes to `columnstore_index_*` icons (covers CCI and NCCI); `Parallelism` operator subtypes (Repartition Streams, Distribute Streams, Gather Streams) get their own icons
+- **`Microsoft.Data.SqlClient` 6.1.4 → 7.0.1** — major-version bump. Azure/Entra dependencies were split out of the core package in 7.0; `Microsoft.Data.SqlClient.Extensions.Azure 1.0.0` added to Dashboard, Lite, and Installer.Core for `ActiveDirectoryInteractive` connections
+- **`ModelContextProtocol` 0.7.0-preview.1 → 1.2.0** — off the preview tag and onto stable 1.x in Dashboard and Lite
+- **`DuckDB.NET` 1.5.0 → 1.5.2** in Lite — fixes unbounded row group growth on indexed tables under repeated load+insert cycles, memory leaks and race conditions in prepared statements, WAL checkpoint marking, and Windows UTF-8/UTF-16 handling
+- **`Microsoft.Extensions.*` 10.0.5 → 10.0.7**, **`System.Text.Json` 10.0.5 → 10.0.7**, **`ScottPlot.WPF` 5.1.57 → 5.1.58** — patch-level bumps with no expected behavioral change
+- **Theme polish** on grids and plan viewer in Dashboard and Lite — thanks [@ClaudioESSilva](https://github.com/ClaudioESSilva) ([#889])
+
+### Fixed
+
+- **Install loop timeout** raised from 5 minutes to 1 hour. `install/98_validate_installation.sql` runs every enabled collector with `@debug = 1` in a single batch; on large databases (reporter had 7.2M rows in `collect.query_stats`, 4.4M in `collect.query_store_data`) this took ~9 minutes and was blowing the 5-minute timeout, failing the install or upgrade ([#884])
+
+[#873]: https://github.com/erikdarlingdata/PerformanceMonitor/issues/873
+[#880]: https://github.com/erikdarlingdata/PerformanceMonitor/issues/880
+[#884]: https://github.com/erikdarlingdata/PerformanceMonitor/issues/884
+[#887]: https://github.com/erikdarlingdata/PerformanceMonitor/issues/887
+[#888]: https://github.com/erikdarlingdata/PerformanceMonitor/issues/888
+[#889]: https://github.com/erikdarlingdata/PerformanceMonitor/issues/889
+[#892]: https://github.com/erikdarlingdata/PerformanceMonitor/issues/892
+[#899]: https://github.com/erikdarlingdata/PerformanceMonitor/issues/899
+[#900]: https://github.com/erikdarlingdata/PerformanceMonitor/issues/900
+
+## [2.8.0] - 2026-04-22
 
 ### Important
 
@@ -15,7 +58,6 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 - **Memory Pressure Events in Lite** — the collector, chart, and `get_memory_pressure_events` MCP tool previously only in the Full Edition are now available in Lite ([#865])
 - **Grid auto-scrolling** in Lite and Dashboard ([#843]) — thanks [@ClaudioESSilva](https://github.com/ClaudioESSilva)
-- **`Off` collection preset** — `config.apply_collection_preset @preset_name = N'Off'` disables every collector in one call. Pair it with a second Agent job that applies a non-`Off` preset at the start of your active window to get overnight / quiet-hours scoping without writing scheduler code. Non-`Off` presets now also set `enabled = 1` across the board so the switch reliably resumes collection ([#888])
 
 ### Changed
 
@@ -48,7 +90,6 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 [#865]: https://github.com/erikdarlingdata/PerformanceMonitor/issues/865
 [#867]: https://github.com/erikdarlingdata/PerformanceMonitor/issues/867
 [#872]: https://github.com/erikdarlingdata/PerformanceMonitor/issues/872
-[#888]: https://github.com/erikdarlingdata/PerformanceMonitor/issues/888
 
 ## [2.7.0] - 2026-04-13
 
diff --git a/Dashboard/Dashboard.csproj b/Dashboard/Dashboard.csproj
index 32a0716d..1d01ed09 100644
--- a/Dashboard/Dashboard.csproj
+++ b/Dashboard/Dashboard.csproj
@@ -7,10 +7,10 @@
     <StartupObject>PerformanceMonitorDashboard.Program</StartupObject>
     <AssemblyName>PerformanceMonitorDashboard</AssemblyName>
     <Product>SQL Server Performance Monitor Dashboard</Product>
-    <Version>2.8.0</Version>
-    <AssemblyVersion>2.8.0.0</AssemblyVersion>
-    <FileVersion>2.8.0.0</FileVersion>
-    <InformationalVersion>2.8.0</InformationalVersion>
+    <Version>2.9.0</Version>
+    <AssemblyVersion>2.9.0.0</AssemblyVersion>
+    <FileVersion>2.9.0.0</FileVersion>
+    <InformationalVersion>2.9.0</InformationalVersion>
     <Company>Darling Data, LLC</Company>
     <Copyright>Copyright © 2026 Darling Data, LLC</Copyright>
     <ApplicationIcon>EDD.ico</ApplicationIcon>
diff --git a/Dashboard/MainWindow.xaml b/Dashboard/MainWindow.xaml
index f279038a..c0282d32 100644
--- a/Dashboard/MainWindow.xaml
+++ b/Dashboard/MainWindow.xaml
@@ -88,47 +88,75 @@
                           BorderThickness="0">
                     <ListView.ItemTemplate>
                         <DataTemplate>
-                            <Border BorderBrush="{DynamicResource BorderBrush}" 
-                                    BorderThickness="1" 
-                                    CornerRadius="4" 
-                                    Padding="8,6" 
+                            <Border BorderBrush="{DynamicResource BorderBrush}"
+                                    BorderThickness="1"
+                                    CornerRadius="4"
+                                    Padding="8,6"
                                     Margin="2">
-                                <StackPanel>
-                                    <!-- Server Name Row with Status Icon -->
-                                    <StackPanel Orientation="Horizontal">
-                                        <TextBlock Text="{Binding StatusIcon}"
+                                <Grid>
+                                    <Grid.ColumnDefinitions>
+                                        <ColumnDefinition Width="Auto"/>
+                                        <ColumnDefinition Width="*"/>
+                                        <ColumnDefinition Width="Auto"/>
+                                    </Grid.ColumnDefinitions>
+
+                                    <!-- Status Indicator (back-ported from Lite: Ellipse + DataTriggers) -->
+                                    <Ellipse Grid.Column="0"
+                                             Width="10" Height="10"
+                                             Margin="0,6,8,0"
+                                             VerticalAlignment="Top"
+                                             ToolTip="{Binding Status.ErrorMessage}">
+                                        <Ellipse.Style>
+                                            <Style TargetType="Ellipse">
+                                                <Setter Property="Fill" Value="{DynamicResource ForegroundMutedBrush}"/>
+                                                <Style.Triggers>
+                                                    <DataTrigger Binding="{Binding DotStatus}" Value="Online">
+                                                        <Setter Property="Fill" Value="{DynamicResource SuccessBrush}"/>
+                                                    </DataTrigger>
+                                                    <DataTrigger Binding="{Binding DotStatus}" Value="Offline">
+                                                        <Setter Property="Fill" Value="{DynamicResource ErrorBrush}"/>
+                                                    </DataTrigger>
+                                                    <DataTrigger Binding="{Binding DotStatus}" Value="Warning">
+                                                        <Setter Property="Fill" Value="{DynamicResource WarningBrush}"/>
+                                                    </DataTrigger>
+                                                </Style.Triggers>
+                                            </Style>
+                                        </Ellipse.Style>
+                                    </Ellipse>
+
+                                    <!-- Server detail stack -->
+                                    <StackPanel Grid.Column="1">
+                                        <TextBlock Text="{Binding DisplayName}" FontWeight="SemiBold" FontSize="13" Foreground="{DynamicResource ForegroundBrush}"/>
+                                        <TextBlock Text="{Binding ServerName}" FontSize="13" Foreground="{DynamicResource AccentBrush}" Margin="0,-2,0,0" />
+                                        <TextBlock Text="{Binding Description}" FontSize="10" Foreground="{DynamicResource ForegroundDimBrush}"
+                                                   TextWrapping="Wrap" Margin="0,-1,0,0"/>
+                                        <!-- Status Duration (Online for X / Offline for X) -->
+                                        <TextBlock Text="{Binding StatusDurationDisplay, Mode=OneWay}"
+                                                   FontSize="13"
+                                                   FontWeight="SemiBold"
                                                    Foreground="{Binding StatusColor}"
-                                                   FontSize="14"
-                                                   FontWeight="Bold"
-                                                   VerticalAlignment="Center"
-                                                   Margin="0,0,4,0"
-                                                   ToolTip="{Binding Status.ErrorMessage}"/>
-                                        <TextBlock Text="&#x2605;" FontSize="13" Foreground="#FFD700" Margin="0,0,4,0"
-                                                   VerticalAlignment="Center"
-                                                   Visibility="{Binding IsFavorite, Converter={StaticResource BoolToVisibilityConverter}}"/>
-                                        <TextBlock Text="{Binding DisplayName}" FontWeight="SemiBold" FontSize="13" Foreground="{DynamicResource ForegroundBrush}" VerticalAlignment="Center"/>
+                                                   Margin="0,-1,0,0"
+                                                   Visibility="{Binding HasBeenChecked, Converter={StaticResource BoolToVisibilityConverter}}"/>
+                                        <!-- Monitor Version -->
+                                        <TextBlock Text="{Binding MonitorVersionDisplay, Mode=OneWay}"
+                                                   FontSize="11"
+                                                   Foreground="{DynamicResource ForegroundMutedBrush}"
+                                                   Margin="0,-1,0,0"
+                                                   Visibility="{Binding HasBeenChecked, Converter={StaticResource BoolToVisibilityConverter}}"/>
+                                        <!-- Last Checked Timestamp -->
+                                        <TextBlock FontSize="12" Foreground="{DynamicResource ForegroundDimBrush}" Margin="0,-1,0,0">
+                                            <Run Text="{Binding LastCheckedDisplay, Mode=OneWay}"/>
+                                        </TextBlock>
                                     </StackPanel>
-                                    <TextBlock Text="{Binding ServerName}" FontSize="13" Foreground="{DynamicResource AccentBrush}" Margin="0,-2,0,0" />
-                                    <TextBlock Text="{Binding Description}" FontSize="10" Foreground="{DynamicResource ForegroundDimBrush}"
-                                               TextWrapping="Wrap" Margin="0,-1,0,0"/>
-                                    <!-- Status Duration (Online for X / Offline for X) -->
-                                    <TextBlock Text="{Binding StatusDurationDisplay, Mode=OneWay}"
-                                               FontSize="13"
-                                               FontWeight="SemiBold"
-                                               Foreground="{Binding StatusColor}"
-                                               Margin="0,-1,0,0"
-                                               Visibility="{Binding HasBeenChecked, Converter={StaticResource BoolToVisibilityConverter}}"/>
-                                    <!-- Monitor Version -->
-                                    <TextBlock Text="{Binding MonitorVersionDisplay, Mode=OneWay}"
-                                               FontSize="11"
-                                               Foreground="{DynamicResource ForegroundMutedBrush}"
-                                               Margin="0,-1,0,0"
-                                               Visibility="{Binding HasBeenChecked, Converter={StaticResource BoolToVisibilityConverter}}"/>
-                                    <!-- Last Checked Timestamp -->
-                                    <TextBlock FontSize="12" Foreground="{DynamicResource ForegroundDimBrush}" Margin="0,-1,0,0">
-                                        <Run Text="{Binding LastCheckedDisplay, Mode=OneWay}"/>
-                                    </TextBlock>
-                                </StackPanel>
+
+                                    <!-- Favorite Star (right-aligned, back-ported from Lite) -->
+                                    <TextBlock Grid.Column="2"
+                                               Text="&#x2605;" FontSize="16"
+                                               VerticalAlignment="Top"
+                                               Foreground="#FFD700"
+                                               Margin="4,2,0,0"
+                                               Visibility="{Binding IsFavorite, Converter={StaticResource BoolToVisibilityConverter}}"/>
+                                </Grid>
                             </Border>
                         </DataTemplate>
                     </ListView.ItemTemplate>
diff --git a/Dashboard/ManageServersWindow.xaml b/Dashboard/ManageServersWindow.xaml
index 33892881..6804564b 100644
--- a/Dashboard/ManageServersWindow.xaml
+++ b/Dashboard/ManageServersWindow.xaml
@@ -74,6 +74,7 @@
                     <DataGridTextColumn Header="Display Name" Binding="{Binding DisplayName}" Width="150"/>
                     <DataGridTextColumn Header="Server" Binding="{Binding ServerName}" Width="180"/>
                     <DataGridTextColumn Header="Authentication" Binding="{Binding AuthenticationDisplay}" Width="120"/>
+                    <DataGridTextColumn Header="Installed Version" Binding="{Binding InstalledVersion}" Width="130"/>
                     <DataGridTextColumn Header="Monthly Cost ($)" Binding="{Binding MonthlyCostUsd, StringFormat='{}{0:N0}'}" Width="120">
                         <DataGridTextColumn.ElementStyle>
                             <Style TargetType="TextBlock">
diff --git a/Dashboard/ManageServersWindow.xaml.cs b/Dashboard/ManageServersWindow.xaml.cs
index 633de304..95d03e72 100644
--- a/Dashboard/ManageServersWindow.xaml.cs
+++ b/Dashboard/ManageServersWindow.xaml.cs
@@ -7,12 +7,13 @@
  */
 
 using System;
+using System.Collections.Generic;
 using System.Linq;
 using System.Reflection;
+using System.Threading.Tasks;
 using System.Windows;
 using System.Windows.Controls;
 using System.Windows.Input;
-using Installer.Core;
 using PerformanceMonitorDashboard.Models;
 using PerformanceMonitorDashboard.Services;
 
@@ -29,6 +30,7 @@ public ManageServersWindow(ServerManager serverManager)
             _serverManager = serverManager;
             ServersModified = false;
             LoadServers();
+            _ = LoadInstalledVersionsAsync();
         }
 
         private void LoadServers()
@@ -36,6 +38,39 @@ private void LoadServers()
             ServersDataGrid.ItemsSource = _serverManager.GetAllServers();
         }
 
+        private async Task LoadInstalledVersionsAsync()
+        {
+            if (ServersDataGrid.ItemsSource is not IEnumerable<ServerConnection> source) return;
+
+            /* Snapshot the list so subsequent LoadServers() calls don't race us. */
+            var servers = source.ToList();
+
+            /* Probe in parallel — each call opens its own SqlConnection to master. */
+            var tasks = servers.Select(async s =>
+            {
+                try
+                {
+                    string? version = await _serverManager.GetInstalledVersionAsync(s);
+                    s.InstalledVersion = string.IsNullOrEmpty(version) ? "Not installed" : NormalizeVersion(version);
+                }
+                catch
+                {
+                    s.InstalledVersion = "Unavailable";
+                }
+            });
+
+            await Task.WhenAll(tasks);
+        }
+
+        private static string NormalizeVersion(string version)
+        {
+            int plusIndex = version.IndexOf('+');
+            string trimmed = plusIndex >= 0 ? version[..plusIndex] : version;
+            return Version.TryParse(trimmed, out var v)
+                ? new Version(v.Major, v.Minor, v.Build).ToString()
+                : trimmed;
+        }
+
         private void ServersDataGrid_MouseDoubleClick(object sender, MouseButtonEventArgs e)
         {
             if (!Helpers.TabHelpers.IsDoubleClickOnRow((DependencyObject)e.OriginalSource)) return;
diff --git a/Dashboard/Models/ServerConnection.cs b/Dashboard/Models/ServerConnection.cs
index ba80d9fa..6d39c28f 100644
--- a/Dashboard/Models/ServerConnection.cs
+++ b/Dashboard/Models/ServerConnection.cs
@@ -7,6 +7,7 @@
  */
 
 using System;
+using System.ComponentModel;
 using System.Text.Json.Serialization;
 using Microsoft.Data.SqlClient;
 using PerformanceMonitorDashboard.Interfaces;
@@ -14,7 +15,7 @@
 
 namespace PerformanceMonitorDashboard.Models
 {
-    public class ServerConnection
+    public class ServerConnection : INotifyPropertyChanged
     {
         public string Id { get; set; } = Guid.NewGuid().ToString();
         public string ServerName { get; set; } = string.Empty;
@@ -88,6 +89,28 @@ public bool UseWindowsAuth
         [JsonIgnore]
         public string DisplayNameWithIntent => ReadOnlyIntent ? $"{DisplayName} (Read-Only)" : DisplayName;
 
+        private string? _installedVersion;
+
+        /// <summary>
+        /// Installed PerformanceMonitor version on this server. Populated asynchronously
+        /// by the Manage Servers window. Not persisted — runtime-only display field.
+        /// Conventional values: null (not yet probed), a 3-part version like "2.9.0",
+        /// "Not installed", or "Unavailable" when the probe fails.
+        /// </summary>
+        [JsonIgnore]
+        public string? InstalledVersion
+        {
+            get => _installedVersion;
+            set
+            {
+                if (_installedVersion == value) return;
+                _installedVersion = value;
+                PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(nameof(InstalledVersion)));
+            }
+        }
+
+        public event PropertyChangedEventHandler? PropertyChanged;
+
         /// <summary>
         /// Display-only property for showing authentication type in UI.
         /// </summary>
diff --git a/Dashboard/Models/ServerListItem.cs b/Dashboard/Models/ServerListItem.cs
index 63a5c80e..8c31201e 100644
--- a/Dashboard/Models/ServerListItem.cs
+++ b/Dashboard/Models/ServerListItem.cs
@@ -44,6 +44,7 @@ public ServerConnectionStatus Status
                     OnPropertyChanged();
                     OnPropertyChanged(nameof(StatusIcon));
                     OnPropertyChanged(nameof(StatusColor));
+                    OnPropertyChanged(nameof(DotStatus));
                     OnPropertyChanged(nameof(LastCheckedDisplay));
                     OnPropertyChanged(nameof(StatusDurationDisplay));
                     OnPropertyChanged(nameof(IsOnline));
@@ -70,6 +71,20 @@ public ServerConnectionStatus Status
         /// </summary>
         public string StatusIcon => _status.StatusIcon;
 
+        /// <summary>
+        /// Symbolic status used by the sidebar Ellipse indicator's DataTriggers.
+        /// Returns "Online", "Offline", or "Unknown".
+        /// </summary>
+        public string DotStatus
+        {
+            get
+            {
+                if (!_status.LastChecked.HasValue)
+                    return "Unknown";
+                return _status.IsOnline == true ? "Online" : "Offline";
+            }
+        }
+
         /// <summary>
         /// Color for the status icon: green for online, red for offline, gray for unknown.
         /// </summary>
diff --git a/Installer.Core/Installer.Core.csproj b/Installer.Core/Installer.Core.csproj
index d37056cb..e86a1521 100644
--- a/Installer.Core/Installer.Core.csproj
+++ b/Installer.Core/Installer.Core.csproj
@@ -7,10 +7,10 @@
     <RootNamespace>Installer.Core</RootNamespace>
     <AssemblyName>Installer.Core</AssemblyName>
     <Product>SQL Server Performance Monitor Installer Core</Product>
-    <Version>2.8.0</Version>
-    <AssemblyVersion>2.8.0.0</AssemblyVersion>
-    <FileVersion>2.8.0.0</FileVersion>
-    <InformationalVersion>2.8.0</InformationalVersion>
+    <Version>2.9.0</Version>
+    <AssemblyVersion>2.9.0.0</AssemblyVersion>
+    <FileVersion>2.9.0.0</FileVersion>
+    <InformationalVersion>2.9.0</InformationalVersion>
     <Company>Darling Data, LLC</Company>
     <Copyright>Copyright (c) 2026 Darling Data, LLC</Copyright>
     <EnableNETAnalyzers>true</EnableNETAnalyzers>
diff --git a/Installer/PerformanceMonitorInstaller.csproj b/Installer/PerformanceMonitorInstaller.csproj
index 222138f1..97d153d8 100644
--- a/Installer/PerformanceMonitorInstaller.csproj
+++ b/Installer/PerformanceMonitorInstaller.csproj
@@ -20,10 +20,10 @@
     <!-- Application metadata -->
     <AssemblyName>PerformanceMonitorInstaller</AssemblyName>
     <Product>SQL Server Performance Monitor Installer</Product>
-    <Version>2.8.0</Version>
-    <AssemblyVersion>2.8.0.0</AssemblyVersion>
-    <FileVersion>2.8.0.0</FileVersion>
-    <InformationalVersion>2.8.0</InformationalVersion>
+    <Version>2.9.0</Version>
+    <AssemblyVersion>2.9.0.0</AssemblyVersion>
+    <FileVersion>2.9.0.0</FileVersion>
+    <InformationalVersion>2.9.0</InformationalVersion>
     <Company>Darling Data, LLC</Company>
     <Copyright>Copyright © 2026 Darling Data, LLC</Copyright>
     <Description>Installation utility for SQL Server Performance Monitor - Supports SQL Server 2016-2025</Description>
diff --git a/Lite/Models/ServerConnection.cs b/Lite/Models/ServerConnection.cs
index 539d7c43..0e139215 100644
--- a/Lite/Models/ServerConnection.cs
+++ b/Lite/Models/ServerConnection.cs
@@ -7,13 +7,14 @@
  */
 
 using System;
+using System.ComponentModel;
 using System.Text.Json.Serialization;
 using Microsoft.Data.SqlClient;
 using PerformanceMonitorLite.Services;
 
 namespace PerformanceMonitorLite.Models;
 
-public class ServerConnection
+public class ServerConnection : INotifyPropertyChanged
 {
     public string Id { get; set; } = Guid.NewGuid().ToString();
     public string ServerName { get; set; } = string.Empty;
@@ -164,6 +165,27 @@ public string DotStatus
     [JsonIgnore]
     public string StatusDisplay => IsEnabled ? "Enabled" : "Disabled";
 
+    private string? _installedVersion;
+
+    /// <summary>
+    /// PerformanceMonitor Lite app version monitoring this server (e.g., "2.9.0").
+    /// Populated by the Manage Servers window. Not persisted — runtime-only display field.
+    /// Same value for every row since one Lite process monitors all servers.
+    /// </summary>
+    [JsonIgnore]
+    public string? InstalledVersion
+    {
+        get => _installedVersion;
+        set
+        {
+            if (_installedVersion == value) return;
+            _installedVersion = value;
+            PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(nameof(InstalledVersion)));
+        }
+    }
+
+    public event PropertyChangedEventHandler? PropertyChanged;
+
     /// <summary>
     /// Builds and returns a connection string for this server.
     /// Credentials are retrieved from Windows Credential Manager if SQL auth is used.
diff --git a/Lite/PerformanceMonitorLite.csproj b/Lite/PerformanceMonitorLite.csproj
index c38cb028..d6b4c84f 100644
--- a/Lite/PerformanceMonitorLite.csproj
+++ b/Lite/PerformanceMonitorLite.csproj
@@ -8,10 +8,10 @@
     <AssemblyName>PerformanceMonitorLite</AssemblyName>
     <RootNamespace>PerformanceMonitorLite</RootNamespace>
     <Product>SQL Server Performance Monitor Lite</Product>
-    <Version>2.8.0</Version>
-    <AssemblyVersion>2.8.0.0</AssemblyVersion>
-    <FileVersion>2.8.0.0</FileVersion>
-    <InformationalVersion>2.8.0</InformationalVersion>
+    <Version>2.9.0</Version>
+    <AssemblyVersion>2.9.0.0</AssemblyVersion>
+    <FileVersion>2.9.0.0</FileVersion>
+    <InformationalVersion>2.9.0</InformationalVersion>
     <Company>Darling Data, LLC</Company>
     <Copyright>Copyright © 2026 Darling Data, LLC</Copyright>
     <Description>Lightweight SQL Server performance monitoring - no installation required on target servers</Description>
diff --git a/Lite/Windows/ManageServersWindow.xaml b/Lite/Windows/ManageServersWindow.xaml
index 3f687c65..2cbf2271 100644
--- a/Lite/Windows/ManageServersWindow.xaml
+++ b/Lite/Windows/ManageServersWindow.xaml
@@ -55,6 +55,7 @@
                 <DataGridTextColumn Header="Display Name" Binding="{Binding DisplayNameWithIntent}" Width="150"/>
                 <DataGridTextColumn Header="Server" Binding="{Binding ServerNameDisplay}" Width="200"/>
                 <DataGridTextColumn Header="Auth" Binding="{Binding AuthenticationDisplay}" Width="100"/>
+                <DataGridTextColumn Header="Installed Version" Binding="{Binding InstalledVersion}" Width="130"/>
                 <DataGridTextColumn Header="Status" Binding="{Binding StatusDisplay}" Width="80"/>
                 <DataGridTextColumn Header="Monthly Cost ($)" Binding="{Binding MonthlyCostUsd, StringFormat='{}{0:N0}'}" Width="120">
                     <DataGridTextColumn.ElementStyle>
diff --git a/Lite/Windows/ManageServersWindow.xaml.cs b/Lite/Windows/ManageServersWindow.xaml.cs
index aae0ccdf..ffb128c5 100644
--- a/Lite/Windows/ManageServersWindow.xaml.cs
+++ b/Lite/Windows/ManageServersWindow.xaml.cs
@@ -6,6 +6,7 @@
  * Licensed under the MIT License. See LICENSE file in the project root for full license information.
  */
 
+using System.Reflection;
 using System.Windows;
 using System.Windows.Input;
 using PerformanceMonitorLite.Models;
@@ -32,7 +33,27 @@ public ManageServersWindow(ServerManager serverManager)
     private void RefreshGrid()
     {
         ServersGrid.ItemsSource = null;
-        ServersGrid.ItemsSource = _serverManager.GetAllServers();
+        var servers = _serverManager.GetAllServers();
+        string appVersion = GetAppVersion();
+        foreach (var s in servers)
+        {
+            s.InstalledVersion = appVersion;
+        }
+        ServersGrid.ItemsSource = servers;
+    }
+
+    private static string GetAppVersion()
+    {
+        string raw = Assembly.GetExecutingAssembly()
+            .GetCustomAttribute<AssemblyInformationalVersionAttribute>()?.InformationalVersion
+            ?? Assembly.GetExecutingAssembly().GetName().Version?.ToString()
+            ?? "0.0.0";
+
+        int plusIndex = raw.IndexOf('+');
+        string trimmed = plusIndex >= 0 ? raw[..plusIndex] : raw;
+        return System.Version.TryParse(trimmed, out var v)
+            ? new System.Version(v.Major, v.Minor, v.Build).ToString()
+            : trimmed;
     }
 
     private void AddButton_Click(object sender, RoutedEventArgs e)
diff --git a/README.md b/README.md
index a3008652..cc65b836 100644
--- a/README.md
+++ b/README.md
@@ -136,7 +136,7 @@ Data starts flowing within 1–5 minutes. That's it. No installation on your ser
 
 All data is stored in `%LOCALAPPDATA%\PerformanceMonitorLite\` — separate from the executable, so auto-updates don't affect your data.
 
-- **Hot data** in DuckDB 1.5.0 — non-blocking checkpoints, free block reuse, stable file size without periodic resets
+- **Hot data** in DuckDB 1.5.2 — non-blocking checkpoints, free block reuse, stable file size without periodic resets
 - **Archive** to Parquet with ZSTD compression (~10x reduction) — automatic monthly compaction keeps file count low (~75 files vs thousands)
 - **Retention**: 3-month calendar-month rolling window
 - Typical size: ~50–200 MB per server per week