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/29] 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/29] 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/29] 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/29] 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/29] 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/29] 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/29] 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/29] 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/29] 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/29] 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/29] 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/29] 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/29] 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/29] 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/29] 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/29] 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/29] 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/29] 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/29] 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/29] 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/29] 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/29] 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/29] 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/29] 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/29] 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/29] 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/29] 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/29] 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/29] 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