From 7601aab9b21615a26fa5d3779b9be97e8827ea0f Mon Sep 17 00:00:00 2001
From: Erik Darling <2136037+erikdarlingdata@users.noreply.github.com>
Date: Tue, 31 Mar 2026 14:29:38 -0400
Subject: [PATCH 01/30] README: add shields.io badge flair (repo + social)

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
---
 README.md | 16 ++++++++++++++++
 1 file changed, 16 insertions(+)

diff --git a/README.md b/README.md
index bdfd3b2..2d3d4d3 100644
--- a/README.md
+++ b/README.md
@@ -1,5 +1,21 @@
 # SQL Server Performance Monitor
 
+<p align="center">
+  <a href="https://github.com/erikdarlingdata/PerformanceMonitor/stargazers"><img src="https://img.shields.io/github/stars/erikdarlingdata/PerformanceMonitor?style=for-the-badge&logo=github&color=gold&logoColor=black" alt="GitHub Stars"></a>
+  <a href="https://github.com/erikdarlingdata/PerformanceMonitor/network/members"><img src="https://img.shields.io/github/forks/erikdarlingdata/PerformanceMonitor?style=for-the-badge&logo=github" alt="GitHub Forks"></a>
+  <a href="https://github.com/erikdarlingdata/PerformanceMonitor/blob/main/LICENSE"><img src="https://img.shields.io/github/license/erikdarlingdata/PerformanceMonitor?style=for-the-badge" alt="License: MIT"></a>
+  <a href="https://github.com/erikdarlingdata/PerformanceMonitor/releases/latest"><img src="https://img.shields.io/github/v/release/erikdarlingdata/PerformanceMonitor?style=for-the-badge" alt="Latest Release"></a>
+  <a href="https://github.com/erikdarlingdata/PerformanceMonitor/issues"><img src="https://img.shields.io/github/issues/erikdarlingdata/PerformanceMonitor?style=for-the-badge" alt="Open Issues"></a>
+  <a href="https://github.com/erikdarlingdata/PerformanceMonitor/commits/main"><img src="https://img.shields.io/github/last-commit/erikdarlingdata/PerformanceMonitor?style=for-the-badge" alt="Last Commit"></a>
+  <a href="https://github.com/erikdarlingdata/PerformanceMonitor/actions/workflows/ci.yml"><img src="https://img.shields.io/github/actions/workflow/status/erikdarlingdata/PerformanceMonitor/ci.yml?style=for-the-badge&label=CI" alt="CI"></a>
+</p>
+<p align="center">
+  <a href="https://x.com/erikdarlingdata"><img src="https://img.shields.io/badge/Follow_%40ErikDarlingData-black?style=for-the-badge&logo=x&logoColor=white" alt="Follow @ErikDarlingData on X"></a>
+  <a href="https://www.youtube.com/@ErikDarlingData"><img src="https://img.shields.io/badge/YouTube-Subscribe-red?style=for-the-badge&logo=youtube&logoColor=white" alt="YouTube Subscribe"></a>
+  <a href="https://www.linkedin.com/in/erik-darling-data/"><img src="https://img.shields.io/badge/LinkedIn-Connect-0077B5?style=for-the-badge&logo=linkedin&logoColor=white" alt="LinkedIn Connect"></a>
+  <a href="https://erikdarling.com"><img src="https://img.shields.io/badge/Blog-erikdarling.com-FF6B35?style=for-the-badge&logo=wordpress&logoColor=white" alt="Blog"></a>
+</p>
+
 **Free, open-source monitoring that replaces the tools charging you thousands per server per year.** 30+ collectors, real-time alerts, built-in MCP server for AI analysis. Nothing phones home. Your data stays on your server and your machine.
 
 **Supported:** SQL Server 2016–2025 | Azure SQL Managed Instance | AWS RDS for SQL Server | Azure SQL Database (Lite only)

From 79d5bc69ca558ed17455ff604b358bd4d1da7282 Mon Sep 17 00:00:00 2001
From: Erik Darling <2136037+erikdarlingdata@users.noreply.github.com>
Date: Wed, 1 Apr 2026 09:40:31 -0400
Subject: [PATCH 02/30] Enable upgrade detection in Edit Server dialog
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Remove the _isEditMode guard so Test Connection calls
DetectDatabaseStatusAsync() in both Add and Edit modes.
Users can now upgrade the PerformanceMonitor database
from Edit Server without re-adding the server.

Closes #771 (partial — Edit Server flow only)

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
---
 Dashboard/AddServerDialog.xaml.cs | 7 ++-----
 1 file changed, 2 insertions(+), 5 deletions(-)

diff --git a/Dashboard/AddServerDialog.xaml.cs b/Dashboard/AddServerDialog.xaml.cs
index cad5489..1ab8bc6 100644
--- a/Dashboard/AddServerDialog.xaml.cs
+++ b/Dashboard/AddServerDialog.xaml.cs
@@ -331,11 +331,8 @@ private async void TestConnection_Click(object sender, RoutedEventArgs e)
                     MessageBoxImage.Information
                 );
 
-                /* After successful connection in Add mode, check database status */
-                if (!_isEditMode)
-                {
-                    await DetectDatabaseStatusAsync();
-                }
+                /* After successful connection, check database status */
+                await DetectDatabaseStatusAsync();
             }
             else if (mfaCancelled)
             {

From c77e970fb9ce92f3a1c3cec2388185858d3bf071 Mon Sep 17 00:00:00 2001
From: Erik Darling <2136037+erikdarlingdata@users.noreply.github.com>
Date: Wed, 1 Apr 2026 16:29:26 -0400
Subject: [PATCH 03/30] Fix embedded resource upgrade discovery and add server
 version UX (#772)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

MSBuild mangles embedded resource names for upgrade folders (e.g.,
"2.2.0-to-2.3.0" becomes "_2._2._0_to_2._3._0"), which caused
EmbeddedResourceScriptProvider to fail parsing all upgrade folders.
Dashboard upgrades silently returned zero results, so upgrade scripts
never ran and schema changes were missing.

Fix: use regex to match mangled names and unmangle back to original
folder names. Also surface installed Monitor version throughout the
Dashboard UX — NOC health cards, sidebar server list, right-click
context menus, Manage Servers, and a new "Check for Updates" button
in the Edit Server dialog. Pin dialog buttons outside the scroll area
so they remain visible during long install/upgrade operations.

Fixes #772

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
---
 Dashboard/AddServerDialog.xaml              |  36 ++++---
 Dashboard/AddServerDialog.xaml.cs           |  18 ++++
 Dashboard/Controls/LandingPage.xaml         |   4 +-
 Dashboard/Controls/LandingPage.xaml.cs      |  79 +++++++++++++++
 Dashboard/Controls/ServerHealthCard.xaml    |  13 +++
 Dashboard/Controls/ServerHealthCard.xaml.cs |  20 ++++
 Dashboard/MainWindow.xaml                   |   9 ++
 Dashboard/MainWindow.xaml.cs                |  71 +++++++++++++
 Dashboard/ManageServersWindow.xaml          |   1 +
 Dashboard/ManageServersWindow.xaml.cs       | 107 ++++++++++++++++++++
 Dashboard/Models/ServerConnectionStatus.cs  |   6 ++
 Dashboard/Models/ServerHealthStatus.cs      |  18 ++++
 Dashboard/Models/ServerListItem.cs          |  17 ++++
 Dashboard/Services/ServerManager.cs         |  42 ++++++++
 Installer.Core/Patterns.cs                  |   8 ++
 Installer.Core/ScriptProvider.cs            |  53 ++++++++--
 Installer.Tests/UpgradeOrderingTests.cs     |  35 +++++++
 17 files changed, 514 insertions(+), 23 deletions(-)

diff --git a/Dashboard/AddServerDialog.xaml b/Dashboard/AddServerDialog.xaml
index bcdb6ca..a4c788f 100644
--- a/Dashboard/AddServerDialog.xaml
+++ b/Dashboard/AddServerDialog.xaml
@@ -2,13 +2,19 @@
         xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
         xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
         Title="Add SQL Server"
-        SizeToContent="Height" Width="500" MaxHeight="1050"
+        Height="750" Width="500"
         WindowStartupLocation="CenterOwner"
-        ResizeMode="NoResize"
+        ResizeMode="CanResizeWithGrip"
         Background="{DynamicResource BackgroundBrush}"
         Foreground="{DynamicResource ForegroundBrush}">
-    <ScrollViewer VerticalScrollBarVisibility="Auto">
-        <Grid Margin="20">
+    <Grid Margin="20">
+        <Grid.RowDefinitions>
+            <RowDefinition Height="*"/>
+            <RowDefinition Height="Auto"/>
+        </Grid.RowDefinitions>
+
+        <ScrollViewer Grid.Row="0" VerticalScrollBarVisibility="Auto">
+        <Grid>
             <Grid.RowDefinitions>
                 <RowDefinition Height="Auto"/>
                 <RowDefinition Height="Auto"/>
@@ -16,7 +22,6 @@
                 <RowDefinition Height="Auto"/>
                 <RowDefinition Height="Auto"/>
                 <RowDefinition Height="Auto"/>
-                <RowDefinition Height="Auto"/>
             </Grid.RowDefinitions>
 
             <!-- Header -->
@@ -217,14 +222,17 @@
                        Foreground="{DynamicResource ForegroundMutedBrush}"
                        TextWrapping="Wrap" Margin="0,8,0,0" Visibility="Collapsed"/>
 
-            <!-- Buttons -->
-            <StackPanel Grid.Row="6" Orientation="Horizontal" HorizontalAlignment="Right" Margin="0,15,0,0">
-                <Button x:Name="ViewReportButton" Content="View Report" Margin="0,0,8,0"
-                        Click="ViewReport_Click" Visibility="Collapsed"/>
-                <Button x:Name="TestConnectionButton" Content="Test Connection" Margin="0,0,8,0" Click="TestConnection_Click"/>
-                <Button x:Name="SaveButton" Content="Save" MinWidth="80" Height="30" Padding="12,0" Margin="0,0,10,0" Click="Save_Click" IsDefault="True" Style="{StaticResource AccentButton}"/>
-                <Button Content="Cancel" Width="80" Height="30" Click="Cancel_Click" IsCancel="True"/>
-            </StackPanel>
         </Grid>
-    </ScrollViewer>
+        </ScrollViewer>
+
+        <!-- Buttons pinned to bottom -->
+        <StackPanel Grid.Row="1" Orientation="Horizontal" HorizontalAlignment="Right" Margin="0,15,0,0">
+            <Button x:Name="ViewReportButton" Content="View Report" Margin="0,0,8,0"
+                    Click="ViewReport_Click" Visibility="Collapsed"/>
+            <Button x:Name="CheckForUpdatesButton" Content="Check for Updates" Margin="0,0,8,0" Click="CheckForUpdates_Click"/>
+            <Button x:Name="TestConnectionButton" Content="Test Connection" Margin="0,0,8,0" Click="TestConnection_Click"/>
+            <Button x:Name="SaveButton" Content="Save" MinWidth="80" Height="30" Padding="12,0" Margin="0,0,10,0" Click="Save_Click" IsDefault="True" Style="{StaticResource AccentButton}"/>
+            <Button Content="Cancel" Width="80" Height="30" Click="Cancel_Click" IsCancel="True"/>
+        </StackPanel>
+    </Grid>
 </Window>
diff --git a/Dashboard/AddServerDialog.xaml.cs b/Dashboard/AddServerDialog.xaml.cs
index 1ab8bc6..7595d75 100644
--- a/Dashboard/AddServerDialog.xaml.cs
+++ b/Dashboard/AddServerDialog.xaml.cs
@@ -313,6 +313,24 @@ happens after the connection test in DetectDatabaseStatusAsync() */
             return (connected, errorMessage, mfaCancelled, serverVersion);
         }
 
+        private async void CheckForUpdates_Click(object sender, RoutedEventArgs e)
+        {
+            if (!ValidateInputs()) return;
+
+            CheckForUpdatesButton.IsEnabled = false;
+            CheckForUpdatesButton.Content = "Checking...";
+
+            try
+            {
+                await DetectDatabaseStatusAsync();
+            }
+            finally
+            {
+                CheckForUpdatesButton.IsEnabled = true;
+                CheckForUpdatesButton.Content = "Check for Updates";
+            }
+        }
+
         private async void TestConnection_Click(object sender, RoutedEventArgs e)
         {
             if (!ValidateInputs()) return;
diff --git a/Dashboard/Controls/LandingPage.xaml b/Dashboard/Controls/LandingPage.xaml
index f55d8c5..a98b29a 100644
--- a/Dashboard/Controls/LandingPage.xaml
+++ b/Dashboard/Controls/LandingPage.xaml
@@ -74,7 +74,9 @@
                     <DataTemplate>
                         <local:ServerHealthCard Width="300"
                                                 Height="220"
-                                                CardClicked="ServerHealthCard_CardClicked"/>
+                                                CardClicked="ServerHealthCard_CardClicked"
+                                                EditServerRequested="ServerHealthCard_EditServerRequested"
+                                                CheckVersionRequested="ServerHealthCard_CheckVersionRequested"/>
                     </DataTemplate>
                 </ItemsControl.ItemTemplate>
             </ItemsControl>
diff --git a/Dashboard/Controls/LandingPage.xaml.cs b/Dashboard/Controls/LandingPage.xaml.cs
index b0816de..d03902e 100644
--- a/Dashboard/Controls/LandingPage.xaml.cs
+++ b/Dashboard/Controls/LandingPage.xaml.cs
@@ -10,6 +10,7 @@
 using System.Collections.Generic;
 using System.Collections.ObjectModel;
 using System.Linq;
+using System.Reflection;
 using System.Threading.Tasks;
 using System.Windows;
 using System.Windows.Controls;
@@ -168,6 +169,10 @@ private async Task RefreshServerAsync(ServerHealthStatus status)
                 // and the UI updates automatically via data binding
                 await databaseService.RefreshNocHealthStatusAsync(status);
 
+                // Populate installed monitor version from connectivity check
+                var connStatus = _serverManager.GetConnectionStatus(server.Id);
+                status.MonitorVersion = connStatus.InstalledMonitorVersion;
+
                 // Update tab badges in MainWindow
                 UpdateTabBadges(status);
             }
@@ -221,6 +226,80 @@ private void ServerHealthCard_CardClicked(object? sender, ServerHealthStatus sta
             ServerCardClicked?.Invoke(this, status.Server);
         }
 
+        private void ServerHealthCard_EditServerRequested(object? sender, ServerHealthStatus status)
+        {
+            var server = status.Server;
+            var dialog = new AddServerDialog(server);
+            dialog.Owner = Window.GetWindow(this);
+
+            if (dialog.ShowDialog() == true)
+            {
+                try
+                {
+                    _serverManager.UpdateServer(dialog.ServerConnection, dialog.Username, dialog.Password);
+                    _ = ReloadServersAsync();
+                }
+                catch (Exception ex)
+                {
+                    MessageBox.Show($"Failed to update server:\n\n{ex.Message}", "Error", MessageBoxButton.OK, MessageBoxImage.Error);
+                }
+            }
+        }
+
+        private async void ServerHealthCard_CheckVersionRequested(object? sender, ServerHealthStatus status)
+        {
+            var server = status.Server;
+
+            try
+            {
+                string? installedVersion = await _serverManager.GetInstalledVersionAsync(server);
+
+                if (installedVersion == null)
+                {
+                    MessageBox.Show(
+                        $"No PerformanceMonitor installation found on '{server.DisplayNameWithIntent}'.",
+                        "Not Installed", MessageBoxButton.OK, MessageBoxImage.Information);
+                    return;
+                }
+
+                string appVersion = Assembly.GetExecutingAssembly()
+                    .GetCustomAttribute<AssemblyInformationalVersionAttribute>()?.InformationalVersion
+                    ?? Assembly.GetExecutingAssembly().GetName().Version?.ToString() ?? "0.0.0";
+                int plusIndex = appVersion.IndexOf('+');
+                if (plusIndex >= 0) appVersion = appVersion[..plusIndex];
+
+                static string Normalize(string v) =>
+                    Version.TryParse(v, out var p) ? new Version(p.Major, p.Minor, p.Build).ToString() : v;
+
+                string normalizedInstalled = Normalize(installedVersion);
+                string normalizedApp = Normalize(appVersion);
+
+                if (Version.TryParse(normalizedInstalled, out var installed) &&
+                    Version.TryParse(normalizedApp, out var app) &&
+                    installed < app)
+                {
+                    var result = MessageBox.Show(
+                        $"'{server.DisplayNameWithIntent}' has v{normalizedInstalled} installed.\n\nv{normalizedApp} is available. Open the server editor to upgrade?",
+                        "Update Available", MessageBoxButton.YesNo, MessageBoxImage.Information);
+
+                    if (result == MessageBoxResult.Yes)
+                    {
+                        ServerHealthCard_EditServerRequested(sender, status);
+                    }
+                }
+                else
+                {
+                    MessageBox.Show(
+                        $"'{server.DisplayNameWithIntent}' is up to date (v{normalizedInstalled}).",
+                        "No Updates", MessageBoxButton.OK, MessageBoxImage.Information);
+                }
+            }
+            catch (Exception ex)
+            {
+                MessageBox.Show($"Failed to check version:\n\n{ex.Message}", "Connection Error", MessageBoxButton.OK, MessageBoxImage.Error);
+            }
+        }
+
         /// <summary>
         /// Reloads the server list (call when servers are added/removed).
         /// </summary>
diff --git a/Dashboard/Controls/ServerHealthCard.xaml b/Dashboard/Controls/ServerHealthCard.xaml
index edca040..50b7a61 100644
--- a/Dashboard/Controls/ServerHealthCard.xaml
+++ b/Dashboard/Controls/ServerHealthCard.xaml
@@ -8,6 +8,19 @@
              Background="Transparent"
              MouseLeftButtonDown="Card_MouseLeftButtonDown"
              Cursor="Hand">
+    <UserControl.ContextMenu>
+        <ContextMenu>
+            <MenuItem Header="Open in New Tab" Click="OpenInNewTab_Click">
+                <MenuItem.Icon><TextBlock Text="&#x1F5C2;"/></MenuItem.Icon>
+            </MenuItem>
+            <MenuItem Header="Edit Server..." Click="EditServer_Click">
+                <MenuItem.Icon><TextBlock Text="&#x270F;"/></MenuItem.Icon>
+            </MenuItem>
+            <MenuItem Header="Check Server Version" Click="CheckVersion_Click">
+                <MenuItem.Icon><TextBlock Text="&#x1F504;"/></MenuItem.Icon>
+            </MenuItem>
+        </ContextMenu>
+    </UserControl.ContextMenu>
     <UserControl.Resources>
         <ResourceDictionary>
             <!-- Severity to color converter -->
diff --git a/Dashboard/Controls/ServerHealthCard.xaml.cs b/Dashboard/Controls/ServerHealthCard.xaml.cs
index ef26523..fe5f6ac 100644
--- a/Dashboard/Controls/ServerHealthCard.xaml.cs
+++ b/Dashboard/Controls/ServerHealthCard.xaml.cs
@@ -25,6 +25,8 @@ public partial class ServerHealthCard : UserControl
         private static readonly SolidColorBrush UnknownBrush = new(Color.FromRgb(0x88, 0x88, 0x88));   // Gray
 
         public event EventHandler<ServerHealthStatus>? CardClicked;
+        public event EventHandler<ServerHealthStatus>? EditServerRequested;
+        public event EventHandler<ServerHealthStatus>? CheckVersionRequested;
 
         public ServerHealthCard()
         {
@@ -167,5 +169,23 @@ private void Card_MouseLeftButtonDown(object sender, MouseButtonEventArgs e)
                 CardClicked?.Invoke(this, status);
             }
         }
+
+        private void OpenInNewTab_Click(object sender, RoutedEventArgs e)
+        {
+            if (DataContext is ServerHealthStatus status)
+                CardClicked?.Invoke(this, status);
+        }
+
+        private void EditServer_Click(object sender, RoutedEventArgs e)
+        {
+            if (DataContext is ServerHealthStatus status)
+                EditServerRequested?.Invoke(this, status);
+        }
+
+        private void CheckVersion_Click(object sender, RoutedEventArgs e)
+        {
+            if (DataContext is ServerHealthStatus status)
+                CheckVersionRequested?.Invoke(this, status);
+        }
     }
 }
diff --git a/Dashboard/MainWindow.xaml b/Dashboard/MainWindow.xaml
index 7ac71af..f279038 100644
--- a/Dashboard/MainWindow.xaml
+++ b/Dashboard/MainWindow.xaml
@@ -118,6 +118,12 @@
                                                Foreground="{Binding StatusColor}"
                                                Margin="0,-1,0,0"
                                                Visibility="{Binding HasBeenChecked, Converter={StaticResource BoolToVisibilityConverter}}"/>
+                                    <!-- Monitor Version -->
+                                    <TextBlock Text="{Binding MonitorVersionDisplay, Mode=OneWay}"
+                                               FontSize="11"
+                                               Foreground="{DynamicResource ForegroundMutedBrush}"
+                                               Margin="0,-1,0,0"
+                                               Visibility="{Binding HasBeenChecked, Converter={StaticResource BoolToVisibilityConverter}}"/>
                                     <!-- Last Checked Timestamp -->
                                     <TextBlock FontSize="12" Foreground="{DynamicResource ForegroundDimBrush}" Margin="0,-1,0,0">
                                         <Run Text="{Binding LastCheckedDisplay, Mode=OneWay}"/>
@@ -137,6 +143,9 @@
                             <MenuItem Header="Edit Server..." Click="EditServer_Click">
                                 <MenuItem.Icon><TextBlock Text="&#x270F;"/></MenuItem.Icon>
                             </MenuItem>
+                            <MenuItem Header="Check Server Version" Click="CheckServerVersion_Click">
+                                <MenuItem.Icon><TextBlock Text="&#x1F504;"/></MenuItem.Icon>
+                            </MenuItem>
                             <Separator/>
                             <MenuItem x:Name="ToggleFavoriteMenuItem" Header="Set as Favorite" Click="ToggleFavorite_Click">
                                 <MenuItem.Icon><TextBlock Text="&#x2B50;"/></MenuItem.Icon>
diff --git a/Dashboard/MainWindow.xaml.cs b/Dashboard/MainWindow.xaml.cs
index 9b96a57..151d218 100644
--- a/Dashboard/MainWindow.xaml.cs
+++ b/Dashboard/MainWindow.xaml.cs
@@ -22,6 +22,7 @@
 using System.Threading.Tasks;
 using PerformanceMonitorDashboard.Mcp;
 using PerformanceMonitorDashboard.Models;
+using System.Reflection;
 using PerformanceMonitorDashboard.Controls;
 using PerformanceMonitorDashboard.Helpers;
 using PerformanceMonitorDashboard.Services;
@@ -978,6 +979,76 @@ private async void EditServer_Click(object sender, RoutedEventArgs e)
             }
         }
 
+        private async void CheckServerVersion_Click(object sender, RoutedEventArgs e)
+        {
+            if (ServerListView.SelectedItem is not ServerListItem item) return;
+            var server = item.Server;
+
+            try
+            {
+                string? installedVersion = await _serverManager.GetInstalledVersionAsync(server);
+
+                if (installedVersion == null)
+                {
+                    MessageBox.Show(
+                        $"No PerformanceMonitor installation found on '{server.DisplayNameWithIntent}'.",
+                        "Not Installed",
+                        MessageBoxButton.OK,
+                        MessageBoxImage.Information);
+                    return;
+                }
+
+                string appVersion = Assembly.GetExecutingAssembly()
+                    .GetCustomAttribute<AssemblyInformationalVersionAttribute>()?.InformationalVersion
+                    ?? Assembly.GetExecutingAssembly().GetName().Version?.ToString() ?? "0.0.0";
+                int plusIndex = appVersion.IndexOf('+');
+                if (plusIndex >= 0) appVersion = appVersion[..plusIndex];
+
+                static string Normalize(string v) =>
+                    Version.TryParse(v, out var p) ? new Version(p.Major, p.Minor, p.Build).ToString() : v;
+
+                string normalizedInstalled = Normalize(installedVersion);
+                string normalizedApp = Normalize(appVersion);
+
+                if (Version.TryParse(normalizedInstalled, out var installed) &&
+                    Version.TryParse(normalizedApp, out var app) &&
+                    installed < app)
+                {
+                    var result = MessageBox.Show(
+                        $"'{server.DisplayNameWithIntent}' has v{normalizedInstalled} installed.\n\nv{normalizedApp} is available. Open the server editor to upgrade?",
+                        "Update Available",
+                        MessageBoxButton.YesNo,
+                        MessageBoxImage.Information);
+
+                    if (result == MessageBoxResult.Yes)
+                    {
+                        var dialog = new AddServerDialog(server);
+                        if (dialog.ShowDialog() == true)
+                        {
+                            _serverManager.UpdateServer(dialog.ServerConnection, dialog.Username, dialog.Password);
+                            await LoadServerListAsync();
+                        }
+                    }
+                }
+                else
+                {
+                    MessageBox.Show(
+                        $"'{server.DisplayNameWithIntent}' is up to date (v{normalizedInstalled}).",
+                        "No Updates",
+                        MessageBoxButton.OK,
+                        MessageBoxImage.Information);
+                }
+            }
+            catch (Exception ex)
+            {
+                MessageBox.Show(
+                    $"Failed to check version:\n\n{ex.Message}",
+                    "Connection Error",
+                    MessageBoxButton.OK,
+                    MessageBoxImage.Error);
+            }
+        }
+
         private async void RemoveServer_Click(object sender, RoutedEventArgs e)
         {
             if (ServerListView.SelectedItem is ServerListItem item)
diff --git a/Dashboard/ManageServersWindow.xaml b/Dashboard/ManageServersWindow.xaml
index ffe34e2..99d1650 100644
--- a/Dashboard/ManageServersWindow.xaml
+++ b/Dashboard/ManageServersWindow.xaml
@@ -90,6 +90,7 @@
                 <Button Content="Add Server..." Width="100" Height="30" Margin="0,0,8,0" Click="AddServer_Click"/>
                 <Button Content="Edit..." Width="80" Height="30" Margin="0,0,8,0" Click="EditServer_Click"/>
                 <Button x:Name="ToggleFavoriteButton" Content="Toggle Favorite" Width="110" Height="30" Margin="0,0,8,0" Click="ToggleFavorite_Click"/>
+                <Button x:Name="CheckUpdatesButton" Content="Check Server Version" Width="140" Height="30" Margin="0,0,8,0" Click="CheckForUpdates_Click"/>
                 <Button Content="Remove" Width="80" Height="30" Margin="0,0,8,0" Click="RemoveServer_Click"
                         Foreground="{DynamicResource ErrorBrush}"/>
             </StackPanel>
diff --git a/Dashboard/ManageServersWindow.xaml.cs b/Dashboard/ManageServersWindow.xaml.cs
index 57ed283..bbd2ea7 100644
--- a/Dashboard/ManageServersWindow.xaml.cs
+++ b/Dashboard/ManageServersWindow.xaml.cs
@@ -8,9 +8,11 @@
 
 using System;
 using System.Linq;
+using System.Reflection;
 using System.Windows;
 using System.Windows.Controls;
 using System.Windows.Input;
+using Installer.Core;
 using PerformanceMonitorDashboard.Models;
 using PerformanceMonitorDashboard.Services;
 
@@ -190,6 +192,111 @@ private async void RemoveServer_Click(object sender, RoutedEventArgs e)
             }
         }
 
+        private async void CheckForUpdates_Click(object sender, RoutedEventArgs e)
+        {
+            if (ServersDataGrid.SelectedItem is not ServerConnection server)
+            {
+                MessageBox.Show(
+                    "Please select a server to check for updates.",
+                    "No Server Selected",
+                    MessageBoxButton.OK,
+                    MessageBoxImage.Information);
+                return;
+            }
+
+            CheckUpdatesButton.IsEnabled = false;
+            CheckUpdatesButton.Content = "Checking...";
+
+            try
+            {
+                string? installedVersion = await _serverManager.GetInstalledVersionAsync(server);
+
+                if (installedVersion == null)
+                {
+                    MessageBox.Show(
+                        $"No PerformanceMonitor installation found on '{server.DisplayNameWithIntent}'.\n\nUse Edit to install.",
+                        "Not Installed",
+                        MessageBoxButton.OK,
+                        MessageBoxImage.Information);
+                    return;
+                }
+
+                string appVersion = Assembly.GetExecutingAssembly()
+                    .GetCustomAttribute<AssemblyInformationalVersionAttribute>()?.InformationalVersion
+                    ?? Assembly.GetExecutingAssembly().GetName().Version?.ToString() ?? "0.0.0";
+                /* Strip git hash suffix if present (e.g., "2.5.0+abc123" → "2.5.0") */
+                int plusIndex = appVersion.IndexOf('+');
+                if (plusIndex >= 0) appVersion = appVersion[..plusIndex];
+
+                /* Normalize both to 3-part for comparison */
+                string Normalize(string v)
+                {
+                    if (Version.TryParse(v, out var parsed))
+                        return new Version(parsed.Major, parsed.Minor, parsed.Build).ToString();
+                    return v;
+                }
+
+                string normalizedInstalled = Normalize(installedVersion);
+                string normalizedApp = Normalize(appVersion);
+
+                if (Version.TryParse(normalizedInstalled, out var installed) &&
+                    Version.TryParse(normalizedApp, out var app) &&
+                    installed < app)
+                {
+                    var result = MessageBox.Show(
+                        $"'{server.DisplayNameWithIntent}' has v{normalizedInstalled} installed.\n\nv{normalizedApp} is available. Open the server editor to upgrade?",
+                        "Update Available",
+                        MessageBoxButton.YesNo,
+                        MessageBoxImage.Information);
+
+                    if (result == MessageBoxResult.Yes)
+                    {
+                        var dialog = new AddServerDialog(server);
+                        dialog.Owner = this;
+
+                        if (dialog.ShowDialog() == true)
+                        {
+                            try
+                            {
+                                _serverManager.UpdateServer(dialog.ServerConnection, dialog.Username, dialog.Password);
+                                LoadServers();
+                                ServersModified = true;
+                            }
+                            catch (Exception ex)
+                            {
+                                MessageBox.Show(
+                                    $"Failed to update server:\n\n{ex.Message}",
+                                    "Error",
+                                    MessageBoxButton.OK,
+                                    MessageBoxImage.Error);
+                            }
+                        }
+                    }
+                }
+                else
+                {
+                    MessageBox.Show(
+                        $"'{server.DisplayNameWithIntent}' is up to date (v{normalizedInstalled}).",
+                        "No Updates",
+                        MessageBoxButton.OK,
+                        MessageBoxImage.Information);
+                }
+            }
+            catch (Exception ex)
+            {
+                MessageBox.Show(
+                    $"Failed to check for updates:\n\n{ex.Message}",
+                    "Connection Error",
+                    MessageBoxButton.OK,
+                    MessageBoxImage.Error);
+            }
+            finally
+            {
+                CheckUpdatesButton.IsEnabled = true;
+                CheckUpdatesButton.Content = "Check Server Version";
+            }
+        }
+
         private void CopyCell_Click(object sender, RoutedEventArgs e)
         {
             if (sender is MenuItem menuItem && menuItem.Parent is ContextMenu contextMenu)
diff --git a/Dashboard/Models/ServerConnectionStatus.cs b/Dashboard/Models/ServerConnectionStatus.cs
index ac102bb..77d3ed1 100644
--- a/Dashboard/Models/ServerConnectionStatus.cs
+++ b/Dashboard/Models/ServerConnectionStatus.cs
@@ -80,6 +80,12 @@ public class ServerConnectionStatus
         /// </summary>
         public int? UtcOffsetMinutes { get; set; }
 
+        /// <summary>
+        /// The installed PerformanceMonitor version on the server (e.g., "2.5.0").
+        /// Null if the PerformanceMonitor database is not installed.
+        /// </summary>
+        public string? InstalledMonitorVersion { get; set; }
+
         /// <summary>
         /// Gets the status display text for the UI.
         /// </summary>
diff --git a/Dashboard/Models/ServerHealthStatus.cs b/Dashboard/Models/ServerHealthStatus.cs
index 5908002..aa176f5 100644
--- a/Dashboard/Models/ServerHealthStatus.cs
+++ b/Dashboard/Models/ServerHealthStatus.cs
@@ -71,6 +71,9 @@ public class ServerHealthStatus : INotifyPropertyChanged
         private string? _topWaitType;
         private decimal _topWaitDurationSeconds;
 
+        // Installed version
+        private string? _monitorVersion;
+
         public ServerHealthStatus(ServerConnection server)
         {
             _server = server;
@@ -533,15 +536,30 @@ public HealthSeverity ConnectionSeverity
             }
         }
 
+        public string? MonitorVersion
+        {
+            get => _monitorVersion;
+            set { _monitorVersion = value; OnPropertyChanged(); OnPropertyChanged(nameof(ConnectionStatusText)); }
+        }
+
         public string ConnectionStatusText
         {
             get
             {
                 if (!_isOnline.HasValue) return "Unknown";
+                if (_isOnline.Value && _monitorVersion != null)
+                    return $"Online — Monitor v{NormalizeVersion(_monitorVersion)}";
                 return _isOnline.Value ? "Online" : "Offline";
             }
         }
 
+        private static string NormalizeVersion(string version)
+        {
+            if (Version.TryParse(version, out var parsed))
+                return new Version(parsed.Major, parsed.Minor, parsed.Build).ToString();
+            return version;
+        }
+
         // Overall health - worst severity across all metrics
         public HealthSeverity OverallSeverity
         {
diff --git a/Dashboard/Models/ServerListItem.cs b/Dashboard/Models/ServerListItem.cs
index 02c6a7d..63a5c80 100644
--- a/Dashboard/Models/ServerListItem.cs
+++ b/Dashboard/Models/ServerListItem.cs
@@ -48,6 +48,7 @@ public ServerConnectionStatus Status
                     OnPropertyChanged(nameof(StatusDurationDisplay));
                     OnPropertyChanged(nameof(IsOnline));
                     OnPropertyChanged(nameof(HasBeenChecked));
+                    OnPropertyChanged(nameof(MonitorVersionDisplay));
                 }
             }
         }
@@ -103,6 +104,22 @@ public string StatusColor
         /// </summary>
         public bool HasBeenChecked => _status.LastChecked.HasValue;
 
+        /// <summary>
+        /// Display text for the installed monitor version (e.g., "Monitor v2.5.0").
+        /// Empty string if not installed or not yet checked.
+        /// </summary>
+        public string MonitorVersionDisplay
+        {
+            get
+            {
+                if (string.IsNullOrEmpty(_status.InstalledMonitorVersion))
+                    return string.Empty;
+                if (System.Version.TryParse(_status.InstalledMonitorVersion, out var v))
+                    return $"Monitor v{new System.Version(v.Major, v.Minor, v.Build)}";
+                return $"Monitor v{_status.InstalledMonitorVersion}";
+            }
+        }
+
         public event PropertyChangedEventHandler? PropertyChanged;
 
         protected virtual void OnPropertyChanged([CallerMemberName] string? propertyName = null)
diff --git a/Dashboard/Services/ServerManager.cs b/Dashboard/Services/ServerManager.cs
index 1364926..d368664 100644
--- a/Dashboard/Services/ServerManager.cs
+++ b/Dashboard/Services/ServerManager.cs
@@ -15,6 +15,7 @@
 using System.Threading.Tasks;
 using System.Windows;
 using Microsoft.Data.SqlClient;
+using Installer.Core;
 using PerformanceMonitorDashboard.Helpers;
 using PerformanceMonitorDashboard.Interfaces;
 using PerformanceMonitorDashboard.Models;
@@ -323,6 +324,36 @@ CASE WHEN DB_ID('rdsadmin') IS NOT NULL THEN 1 ELSE 0 END AS is_aws_rds
                 {
                     Logger.Info($"Connectivity check passed for server '{server.DisplayName}'");
                     status.UserCancelledMfa = false; // Clear any previous cancellation flag
+
+                    /* Query installed PerformanceMonitor version */
+                    try
+                    {
+                        using var versionCmd = new SqlCommand(@"
+                            IF DB_ID(N'PerformanceMonitor') IS NOT NULL
+                            AND EXISTS (
+                                SELECT 1
+                                FROM PerformanceMonitor.sys.tables AS t
+                                JOIN PerformanceMonitor.sys.schemas AS s
+                                    ON t.schema_id = s.schema_id
+                                WHERE s.name = N'config'
+                                AND   t.name = N'installation_history'
+                            )
+                            BEGIN
+                                SELECT TOP (1)
+                                    installer_version
+                                FROM PerformanceMonitor.config.installation_history
+                                WHERE installation_status = N'SUCCESS'
+                                ORDER BY installation_date DESC;
+                            END;", connection);
+                        versionCmd.CommandTimeout = ConnectionCheckTimeoutSeconds;
+                        var versionResult = await versionCmd.ExecuteScalarAsync();
+                        status.InstalledMonitorVersion = versionResult is string v ? v : null;
+                    }
+                    catch (SqlException)
+                    {
+                        /* Non-critical — don't fail the connectivity check */
+                        status.InstalledMonitorVersion = null;
+                    }
                 }
             }
             catch (SqlException ex)
@@ -383,6 +414,17 @@ public async Task CheckAllConnectionsAsync()
             await Task.WhenAll(tasks);
         }
 
+        public async Task<string?> GetInstalledVersionAsync(ServerConnection server)
+        {
+            var connectionString = server.GetConnectionString(_credentialService);
+            var builder = new SqlConnectionStringBuilder(connectionString)
+            {
+                InitialCatalog = "master",
+                ConnectTimeout = ConnectionCheckTimeoutSeconds
+            };
+            return await InstallationService.GetInstalledVersionAsync(builder.ConnectionString);
+        }
+
         private void LoadServers()
         {
             if (!File.Exists(_configFilePath))
diff --git a/Installer.Core/Patterns.cs b/Installer.Core/Patterns.cs
index 4e5c7fe..081b692 100644
--- a/Installer.Core/Patterns.cs
+++ b/Installer.Core/Patterns.cs
@@ -27,6 +27,14 @@ public static partial class Patterns
         @"^\s*GO\s*(?:--[^\r\n]*)?\s*$",
         RegexOptions.Compiled | RegexOptions.Multiline | RegexOptions.IgnoreCase);
 
+    /// <summary>
+    /// Matches MSBuild-mangled upgrade folder names from embedded resource names.
+    /// MSBuild converts "2.2.0-to-2.3.0" to "_2._2._0_to_2._3._0" (dots become namespace
+    /// separators, hyphens become underscores, digit-leading segments get underscore prefix).
+    /// </summary>
+    [GeneratedRegex(@"^(_\d+\._\d+\._\d+_to_\d+\._\d+\._\d+)\.")]
+    public static partial Regex EmbeddedUpgradeFolderPattern();
+
     /// <summary>
     /// Prefixes that indicate excluded scripts (uninstall, test, troubleshooting).
     /// </summary>
diff --git a/Installer.Core/ScriptProvider.cs b/Installer.Core/ScriptProvider.cs
index d07219d..b136226 100644
--- a/Installer.Core/ScriptProvider.cs
+++ b/Installer.Core/ScriptProvider.cs
@@ -330,15 +330,28 @@ public override List<UpgradeInfo> GetApplicableUpgrades(
     {
         string upgradesPrefix = $"{_resourcePrefix}.Resources.upgrades.";
 
-        var folderNames = _assembly.GetManifestResourceNames()
+        /*
+        MSBuild mangles embedded resource names: folder "2.2.0-to-2.3.0" becomes
+        "_2._2._0_to_2._3._0" (dots → namespace separators, hyphens → underscores,
+        digit-leading segments → underscore prefix). Extract the mangled name and
+        recover the original for version parsing. Store mangled name in Path for
+        resource lookups; original in FolderName for display/version parsing.
+        */
+        var mangledNames = _assembly.GetManifestResourceNames()
             .Where(r => r.StartsWith(upgradesPrefix, StringComparison.Ordinal))
             .Select(r => r[upgradesPrefix.Length..])
-            .Select(r => r.Split('.')[0])
+            .Select(r => Patterns.EmbeddedUpgradeFolderPattern().Match(r))
+            .Where(m => m.Success)
+            .Select(m => m.Groups[1].Value)
             .Distinct()
             .ToList();
 
-        var allUpgrades = folderNames
-            .Select(f => ParseUpgradeFolderName(f, f))
+        var allUpgrades = mangledNames
+            .Select(mangled =>
+            {
+                string original = UnmangleUpgradeFolderName(mangled);
+                return ParseUpgradeFolderName(original, mangled);
+            })
             .Where(x => x != null)
             .Cast<UpgradeInfo>()
             .ToList();
@@ -348,7 +361,7 @@ public override List<UpgradeInfo> GetApplicableUpgrades(
         var result = new List<UpgradeInfo>();
         foreach (var upgrade in filtered)
         {
-            string manifestResource = $"{upgradesPrefix}{upgrade.FolderName}.upgrade.txt";
+            string manifestResource = $"{upgradesPrefix}{upgrade.Path}.upgrade.txt";
             if (_assembly.GetManifestResourceNames().Contains(manifestResource))
             {
                 result.Add(upgrade);
@@ -364,7 +377,7 @@ public override List<UpgradeInfo> GetApplicableUpgrades(
     public override List<string> GetUpgradeManifest(UpgradeInfo upgrade)
     {
         string upgradesPrefix = $"{_resourcePrefix}.Resources.upgrades.";
-        string manifestResource = $"{upgradesPrefix}{upgrade.FolderName}.upgrade.txt";
+        string manifestResource = $"{upgradesPrefix}{upgrade.Path}.upgrade.txt";
         string content = ReadResource(manifestResource);
         return ParseUpgradeManifest(content.Split('\n'));
     }
@@ -372,7 +385,7 @@ public override List<string> GetUpgradeManifest(UpgradeInfo upgrade)
     public override string ReadUpgradeScript(UpgradeInfo upgrade, string scriptName)
     {
         string upgradesPrefix = $"{_resourcePrefix}.Resources.upgrades.";
-        string resource = $"{upgradesPrefix}{upgrade.FolderName}.{scriptName}";
+        string resource = $"{upgradesPrefix}{upgrade.Path}.{scriptName}";
         return ReadResource(resource);
     }
 
@@ -383,10 +396,34 @@ public override Task<string> ReadUpgradeScriptAsync(
     public override bool UpgradeScriptExists(UpgradeInfo upgrade, string scriptName)
     {
         string upgradesPrefix = $"{_resourcePrefix}.Resources.upgrades.";
-        string resource = $"{upgradesPrefix}{upgrade.FolderName}.{scriptName}";
+        string resource = $"{upgradesPrefix}{upgrade.Path}.{scriptName}";
         return _assembly.GetManifestResourceNames().Contains(resource);
     }
 
+    /// <summary>
+    /// Reverses MSBuild's resource name mangling for upgrade folder names.
+    /// "_2._2._0_to_2._3._0" → "2.2.0-to-2.3.0"
+    /// </summary>
+    private static string UnmangleUpgradeFolderName(string mangled)
+    {
+        /*
+        MSBuild mangling:
+        - dots in folder names become namespace separator dots
+        - hyphens become underscores
+        - segments starting with a digit get an underscore prefix
+        Reverse: remove leading underscores from digit segments,
+        rejoin with dots, then restore the hyphen in "-to-".
+        */
+        var segments = mangled.Split('.');
+        for (int i = 0; i < segments.Length; i++)
+        {
+            if (segments[i].Length > 1 && segments[i][0] == '_' && char.IsDigit(segments[i][1]))
+                segments[i] = segments[i][1..];
+        }
+        string result = string.Join(".", segments);
+        return result.Replace("_to_", "-to-");
+    }
+
     public override string? ReadTroubleshootingScript()
     {
         string resource = $"{_resourcePrefix}.Resources.install.99_installer_troubleshooting.sql";
diff --git a/Installer.Tests/UpgradeOrderingTests.cs b/Installer.Tests/UpgradeOrderingTests.cs
index eace56b..2040070 100644
--- a/Installer.Tests/UpgradeOrderingTests.cs
+++ b/Installer.Tests/UpgradeOrderingTests.cs
@@ -1,3 +1,4 @@
+using System.Text.RegularExpressions;
 using Installer.Core;
 using Installer.Core.Models;
 using Installer.Tests.Helpers;
@@ -146,4 +147,38 @@ public void DoesNotIncludeFutureUpgrades()
         Assert.Equal(2, upgrades.Count);
         Assert.DoesNotContain(upgrades, u => u.FolderName == "2.2.0-to-2.3.0");
     }
+
+    [Fact]
+    public void EmbeddedResources_FindsUpgradeFolders()
+    {
+        // Regression test for #772: MSBuild mangles embedded resource names
+        // (e.g., "2.2.0-to-2.3.0" → "_2._2._0_to_2._3._0"), which broke
+        // upgrade discovery when using Split('.')[0].
+        var provider = ScriptProvider.FromEmbeddedResources();
+        var upgrades = provider.GetApplicableUpgrades("2.2.0", "2.5.0");
+
+        Assert.NotEmpty(upgrades);
+        Assert.Contains(upgrades, u => u.FolderName == "2.2.0-to-2.3.0");
+    }
+
+    [Theory]
+    [InlineData("_2._2._0_to_2._3._0.upgrade.txt", "_2._2._0_to_2._3._0")]
+    [InlineData("_2._2._0_to_2._3._0.03_add_growth_vlf_columns.sql", "_2._2._0_to_2._3._0")]
+    [InlineData("_10._1._0_to_10._2._0.01_schema.sql", "_10._1._0_to_10._2._0")]
+    public void EmbeddedUpgradeFolderPattern_ExtractsMangledName(string resourceSuffix, string expectedMangled)
+    {
+        var match = Patterns.EmbeddedUpgradeFolderPattern().Match(resourceSuffix);
+
+        Assert.True(match.Success);
+        Assert.Equal(expectedMangled, match.Groups[1].Value);
+    }
+
+    [Theory]
+    [InlineData("not-a-version")]
+    [InlineData("readme.txt")]
+    [InlineData("README.md")]
+    public void EmbeddedUpgradeFolderPattern_RejectsNonVersionStrings(string input)
+    {
+        Assert.False(Patterns.EmbeddedUpgradeFolderPattern().Match(input).Success);
+    }
 }

From ef2ef7ea7bedb4855cec266c4bb51bc39c2455cb Mon Sep 17 00:00:00 2001
From: Erik Darling <2136037+erikdarlingdata@users.noreply.github.com>
Date: Thu, 2 Apr 2026 08:41:44 -0400
Subject: [PATCH 04/30] Fix Lite FinOps Enterprise features query for servers
 without database_id column
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Port the COL_LENGTH check from Dashboard (#766) to Lite — detect whether
sys.dm_db_persisted_sku_features has the database_id column before querying
it, falling back to N'(unknown)' on older builds that lack the column.

Closes community PR #777

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
---
 Lite/Services/LocalDataService.FinOps.cs | 17 ++++++++++++-----
 1 file changed, 12 insertions(+), 5 deletions(-)

diff --git a/Lite/Services/LocalDataService.FinOps.cs b/Lite/Services/LocalDataService.FinOps.cs
index 1dc7101..7459cad 100644
--- a/Lite/Services/LocalDataService.FinOps.cs
+++ b/Lite/Services/LocalDataService.FinOps.cs
@@ -1569,11 +1569,18 @@ public async Task<List<RecommendationRow>> GetRecommendationsAsync(int serverId,
 
             if (edition.Contains("Enterprise", StringComparison.OrdinalIgnoreCase))
             {
-                using var featCmd = new SqlCommand(@"
-SELECT
-    DB_NAME(database_id) AS database_name,
-    feature_name
-FROM sys.dm_db_persisted_sku_features", sqlConn);
+                var hasDatabaseId = false;
+                using (var colCheck = new SqlCommand(
+                    "SELECT COL_LENGTH('sys.dm_db_persisted_sku_features', 'database_id')", sqlConn))
+                {
+                    colCheck.CommandTimeout = 10;
+                    hasDatabaseId = await colCheck.ExecuteScalarAsync() is not null and not DBNull;
+                }
+
+                var featSql = hasDatabaseId
+                    ? "SELECT DB_NAME(database_id) AS database_name, feature_name FROM sys.dm_db_persisted_sku_features"
+                    : "SELECT N'(unknown)' AS database_name, feature_name FROM sys.dm_db_persisted_sku_features";
+                using var featCmd = new SqlCommand(featSql, sqlConn);
                 featCmd.CommandTimeout = 30;
 
                 var features = new List<string>();

From 9f2f63db1419f7bd78b8d66df11b446cae62c175 Mon Sep 17 00:00:00 2001
From: Erik Darling <2136037+erikdarlingdata@users.noreply.github.com>
Date: Thu, 2 Apr 2026 09:12:07 -0400
Subject: [PATCH 05/30] Fix Overview tab showing Memory Grant as 0 for all
 timestamps

The Overview tab's memory chart only queried v_memory_stats which has no
grant data, so TotalGrantedMb was always 0. The Memory tab worked because
it also calls GetMemoryGrantTrendAsync() from v_memory_grant_stats.

Now the Overview tab fetches grant data in parallel and aligns it to the
memory trend timestamps.

Fixes #776

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
---
 Lite/Controls/ServerTab.xaml.cs | 12 ++++++++----
 1 file changed, 8 insertions(+), 4 deletions(-)

diff --git a/Lite/Controls/ServerTab.xaml.cs b/Lite/Controls/ServerTab.xaml.cs
index f3261a5..eb87095 100644
--- a/Lite/Controls/ServerTab.xaml.cs
+++ b/Lite/Controls/ServerTab.xaml.cs
@@ -1121,15 +1121,16 @@ private async System.Threading.Tasks.Task RefreshOverviewAsync(int hoursBack, Da
         {
             var cpuTask = SafeQueryAsync(() => _dataService.GetCpuUtilizationAsync(_serverId, hoursBack, fromDate, toDate));
             var memoryTask = SafeQueryAsync(() => _dataService.GetMemoryTrendAsync(_serverId, hoursBack, fromDate, toDate));
+            var memoryGrantTask = SafeQueryAsync(() => _dataService.GetMemoryGrantTrendAsync(_serverId, hoursBack, fromDate, toDate));
             var fileIoTask = SafeQueryAsync(() => _dataService.GetFileIoLatencyTrendAsync(_serverId, hoursBack, fromDate, toDate));
 
             // Get top 5 wait types then fetch trends for each
             var waitStats = await SafeQueryAsync(() => _dataService.GetWaitStatsAsync(_serverId, hoursBack, fromDate, toDate));
             var topWaits = waitStats.Take(5).Select(w => w.WaitType).ToList();
-            await System.Threading.Tasks.Task.WhenAll(cpuTask, memoryTask, fileIoTask);
+            await System.Threading.Tasks.Task.WhenAll(cpuTask, memoryTask, memoryGrantTask, fileIoTask);
 
             UpdateOverviewCpuChart(cpuTask.Result);
-            UpdateOverviewMemoryChart(memoryTask.Result);
+            UpdateOverviewMemoryChart(memoryTask.Result, memoryGrantTask.Result);
             UpdateOverviewFileIoChart(fileIoTask.Result);
             await UpdateOverviewWaitStatsChartAsync(topWaits, hoursBack, fromDate, toDate);
         }
@@ -1164,7 +1165,7 @@ private void UpdateOverviewCpuChart(List<CpuUtilizationRow> data)
         OverviewCpuChart.Refresh();
     }
 
-    private void UpdateOverviewMemoryChart(List<MemoryTrendPoint> data)
+    private void UpdateOverviewMemoryChart(List<MemoryTrendPoint> data, List<MemoryTrendPoint> grantData)
     {
         ClearChart(OverviewMemoryChart);
         _overviewMemoryHover?.Clear();
@@ -1174,7 +1175,10 @@ private void UpdateOverviewMemoryChart(List<MemoryTrendPoint> data)
 
         var times = data.Select(d => d.CollectionTime.AddMinutes(UtcOffsetMinutes).ToOADate()).ToArray();
         var bufferPool = data.Select(d => d.BufferPoolMb).ToArray();
-        var grants = data.Select(d => d.TotalGrantedMb).ToArray();
+
+        /* Use grant data from v_memory_grant_stats, aligned to memory trend timestamps */
+        var grantLookup = grantData.ToDictionary(d => d.CollectionTime, d => d.TotalGrantedMb);
+        var grants = data.Select(d => grantLookup.TryGetValue(d.CollectionTime, out var v) ? v : 0.0).ToArray();
 
         var bpPlot = OverviewMemoryChart.Plot.Add.Scatter(times, bufferPool);
         bpPlot.LegendText = "Buffer Pool";

From b012a1397f5a523fcb78381fc0dd56701a5b60f6 Mon Sep 17 00:00:00 2001
From: Erik Darling <2136037+erikdarlingdata@users.noreply.github.com>
Date: Thu, 2 Apr 2026 09:37:21 -0400
Subject: [PATCH 06/30] Bring existing window to foreground on second launch
 instead of error
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Lite: Replace "already running" error dialog with FindWindow/
SetForegroundWindow to activate the existing instance. Only call
SW_RESTORE if the window is minimized (IsIconic) to preserve
maximized state.

Dashboard: Fix WndProc handler to only reset WindowState when
minimized, preserving maximized state on second-launch activation.

Both: Keep minimize-to-tray as a user setting — when enabled, the
window hides from the taskbar on minimize (restored via tray icon).

Fixes #769

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
---
 Dashboard/MainWindow.xaml.cs |  5 +++--
 Lite/App.xaml.cs             | 28 +++++++++++++++++++++++-----
 2 files changed, 26 insertions(+), 7 deletions(-)

diff --git a/Dashboard/MainWindow.xaml.cs b/Dashboard/MainWindow.xaml.cs
index 151d218..396e8eb 100644
--- a/Dashboard/MainWindow.xaml.cs
+++ b/Dashboard/MainWindow.xaml.cs
@@ -137,9 +137,10 @@ private IntPtr WndProc(IntPtr hwnd, int msg, IntPtr wParam, IntPtr lParam, ref b
         {
             if (msg == NativeMethods.WM_SHOWMONITOR)
             {
-                // Another instance tried to start - bring this window to front
+                // Another instance tried to start - bring this window to front (#769)
                 Show();
-                WindowState = WindowState.Normal;
+                if (WindowState == WindowState.Minimized)
+                    WindowState = WindowState.Normal;
                 Activate();
                 Topmost = true;  // Temporarily set topmost to ensure visibility
                 Topmost = false;
diff --git a/Lite/App.xaml.cs b/Lite/App.xaml.cs
index d444304..4b2ba29 100644
--- a/Lite/App.xaml.cs
+++ b/Lite/App.xaml.cs
@@ -22,6 +22,21 @@ public partial class App : Application
     [DllImport("shell32.dll", SetLastError = true)]
     private static extern void SetCurrentProcessExplicitAppUserModelID([MarshalAs(UnmanagedType.LPWStr)] string appId);
 
+    [DllImport("user32.dll")]
+    private static extern bool SetForegroundWindow(IntPtr hWnd);
+
+    [DllImport("user32.dll")]
+    private static extern bool ShowWindow(IntPtr hWnd, int nCmdShow);
+
+    [DllImport("user32.dll", CharSet = CharSet.Unicode)]
+    private static extern IntPtr FindWindow(string? lpClassName, string lpWindowName);
+
+    [DllImport("user32.dll")]
+    [return: MarshalAs(UnmanagedType.Bool)]
+    private static extern bool IsIconic(IntPtr hWnd);
+
+    private const int SW_RESTORE = 9;
+
     private const string MutexName = "PerformanceMonitorLite_SingleInstance";
     private Mutex? _singleInstanceMutex;
     private bool _ownsMutex;
@@ -167,11 +182,14 @@ protected override void OnStartup(StartupEventArgs e)
 
         if (!_ownsMutex)
         {
-            MessageBox.Show(
-                "Performance Monitor Lite is already running.",
-                "Already Running",
-                MessageBoxButton.OK,
-                MessageBoxImage.Information);
+            /* Bring the existing instance's window to the foreground instead of showing an error (#769) */
+            var hWnd = FindWindow(null, "Performance Monitor Lite");
+            if (hWnd != IntPtr.Zero)
+            {
+                if (IsIconic(hWnd))
+                    ShowWindow(hWnd, SW_RESTORE);
+                SetForegroundWindow(hWnd);
+            }
             Shutdown();
             return;
         }

From bd061f64971e3111a467ef07f2e494b7e712d9ed Mon Sep 17 00:00:00 2001
From: Erik Darling <2136037+erikdarlingdata@users.noreply.github.com>
Date: Thu, 2 Apr 2026 10:19:35 -0400
Subject: [PATCH 07/30] Fix FinOps Enterprise feature detection: query all
 databases, filter to TDE only
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

sys.dm_db_persisted_sku_features is database-scoped on all versions
(database_id column was never added). Previous code queried only the
connected database (master for Lite, PerformanceMonitor for Dashboard),
missing features in user databases.

Fixed by querying across all online user databases with dynamic SQL.
Also filtered to TransparentDataEncryption only — Compression,
Partitioning, and ColumnStoreIndex are available in Standard Edition
since SQL Server 2016 SP1, so they are not downgrade blockers.

Addresses #780

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

diff --git a/Dashboard/Services/DatabaseService.FinOps.cs b/Dashboard/Services/DatabaseService.FinOps.cs
index 5f0db5d..2df3b33 100644
--- a/Dashboard/Services/DatabaseService.FinOps.cs
+++ b/Dashboard/Services/DatabaseService.FinOps.cs
@@ -1841,30 +1841,42 @@ public async Task<List<FinOpsRecommendation>> GetFinOpsRecommendationsAsync(deci
 
                 if (edition.Contains("Enterprise", StringComparison.OrdinalIgnoreCase))
                 {
-                    var hasDatabaseId = false;
-                    using (var colCheck = new SqlCommand(
-                        "SELECT COL_LENGTH('sys.dm_db_persisted_sku_features', 'database_id')", connection))
-                    {
-                        colCheck.CommandTimeout = 10;
-                        hasDatabaseId = await colCheck.ExecuteScalarAsync() is not null and not DBNull;
-                    }
+                    /*
+                    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(@"
+DECLARE
+    @sql nvarchar(max) = N'';
 
-                    var featSql = hasDatabaseId
-                        ? "SELECT DB_NAME(database_id) AS database_name, feature_name FROM sys.dm_db_persisted_sku_features"
-                        : "SELECT N'(unknown)' AS database_name, feature_name FROM sys.dm_db_persisted_sku_features";
-                    using var featCmd = new SqlCommand(featSql, connection);
+SELECT
+    @sql += N'
+SELECT ' + QUOTENAME(name, '''') + N' AS database_name
+FROM ' + QUOTENAME(name) + N'.sys.dm_db_persisted_sku_features
+WHERE feature_name = N''TransparentDataEncryption''
+UNION ALL'
+FROM sys.databases
+WHERE database_id > 4
+AND   state_desc = N'ONLINE';
+
+IF @sql <> N''
+BEGIN
+    SET @sql = LEFT(@sql, LEN(@sql) - 10);
+    EXEC sys.sp_executesql @sql;
+END;", connection);
                     featCmd.CommandTimeout = 30;
 
-                    var features = new List<string>();
+                    var tdeDbNames = new List<string>();
                     using var featReader = await featCmd.ExecuteReaderAsync();
                     while (await featReader.ReadAsync())
                     {
-                        var db = featReader.IsDBNull(0) ? "" : featReader.GetString(0);
-                        var feat = featReader.IsDBNull(1) ? "" : featReader.GetString(1);
-                        features.Add($"{db}: {feat}");
+                        if (!featReader.IsDBNull(0))
+                            tdeDbNames.Add(featReader.GetString(0));
                     }
 
-                    if (features.Count == 0)
+                    if (tdeDbNames.Count == 0)
                     {
                         recommendations.Add(new FinOpsRecommendation
                         {
@@ -1872,23 +1884,23 @@ public async Task<List<FinOpsRecommendation>> GetFinOpsRecommendationsAsync(deci
                             Severity = "High",
                             Confidence = "High",
                             Finding = "Enterprise Edition with no Enterprise-only features detected",
-                            Detail = "sys.dm_db_persisted_sku_features reports no Enterprise-only feature usage. " +
+                            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
                     {
-                        // Check 8: Enterprise feature detail report — list what blocks a downgrade
                         recommendations.Add(new FinOpsRecommendation
                         {
                             Category = "Licensing",
                             Severity = "Low",
                             Confidence = "High",
-                            Finding = "Enterprise features in use — downgrade blockers identified",
-                            Detail = $"The following databases use Enterprise-only features: {string.Join("; ", features.Take(20))}" +
-                                     (features.Count > 20 ? $" and {features.Count - 20} more" : "") +
-                                     ". Address these before considering a Standard Edition downgrade."
+                            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)
diff --git a/Lite/Services/LocalDataService.FinOps.cs b/Lite/Services/LocalDataService.FinOps.cs
index 7459cad..73bdbe5 100644
--- a/Lite/Services/LocalDataService.FinOps.cs
+++ b/Lite/Services/LocalDataService.FinOps.cs
@@ -1569,30 +1569,42 @@ public async Task<List<RecommendationRow>> GetRecommendationsAsync(int serverId,
 
             if (edition.Contains("Enterprise", StringComparison.OrdinalIgnoreCase))
             {
-                var hasDatabaseId = false;
-                using (var colCheck = new SqlCommand(
-                    "SELECT COL_LENGTH('sys.dm_db_persisted_sku_features', 'database_id')", sqlConn))
-                {
-                    colCheck.CommandTimeout = 10;
-                    hasDatabaseId = await colCheck.ExecuteScalarAsync() is not null and not DBNull;
-                }
+                /*
+                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(@"
+DECLARE
+    @sql nvarchar(max) = N'';
 
-                var featSql = hasDatabaseId
-                    ? "SELECT DB_NAME(database_id) AS database_name, feature_name FROM sys.dm_db_persisted_sku_features"
-                    : "SELECT N'(unknown)' AS database_name, feature_name FROM sys.dm_db_persisted_sku_features";
-                using var featCmd = new SqlCommand(featSql, sqlConn);
+SELECT
+    @sql += N'
+SELECT ' + QUOTENAME(name, '''') + N' AS database_name
+FROM ' + QUOTENAME(name) + N'.sys.dm_db_persisted_sku_features
+WHERE feature_name = N''TransparentDataEncryption''
+UNION ALL'
+FROM sys.databases
+WHERE database_id > 4
+AND   state_desc = N'ONLINE';
+
+IF @sql <> N''
+BEGIN
+    SET @sql = LEFT(@sql, LEN(@sql) - 10);
+    EXEC sys.sp_executesql @sql;
+END;", sqlConn);
                 featCmd.CommandTimeout = 30;
 
-                var features = new List<string>();
+                var tdeDbNames = new List<string>();
                 using var featReader = await featCmd.ExecuteReaderAsync();
                 while (await featReader.ReadAsync())
                 {
-                    var db = featReader.IsDBNull(0) ? "" : featReader.GetString(0);
-                    var feat = featReader.IsDBNull(1) ? "" : featReader.GetString(1);
-                    features.Add($"{db}: {feat}");
+                    if (!featReader.IsDBNull(0))
+                        tdeDbNames.Add(featReader.GetString(0));
                 }
 
-                if (features.Count == 0)
+                if (tdeDbNames.Count == 0)
                 {
                     recommendations.Add(new RecommendationRow
                     {
@@ -1600,23 +1612,23 @@ public async Task<List<RecommendationRow>> GetRecommendationsAsync(int serverId,
                         Severity = "High",
                         Confidence = "High",
                         Finding = "Enterprise Edition with no Enterprise-only features detected",
-                        Detail = "sys.dm_db_persisted_sku_features reports no Enterprise-only feature usage. " +
+                        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
                 {
-                    // Check 8: Enterprise feature detail report — list what blocks a downgrade
                     recommendations.Add(new RecommendationRow
                     {
                         Category = "Licensing",
                         Severity = "Low",
                         Confidence = "High",
-                        Finding = "Enterprise features in use — downgrade blockers identified",
-                        Detail = $"The following databases use Enterprise-only features: {string.Join("; ", features.Take(20))}" +
-                                 (features.Count > 20 ? $" and {features.Count - 20} more" : "") +
-                                 ". Address these before considering a Standard Edition downgrade."
+                        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)

From 0b11df5bf0e61f0ea9cd4526ee550cbb1e8fb5b5 Mon Sep 17 00:00:00 2001
From: Erik Darling <2136037+erikdarlingdata@users.noreply.github.com>
Date: Thu, 2 Apr 2026 11:23:07 -0400
Subject: [PATCH 08/30] Fix Lite long-running query alerts firing on stale
 DuckDB snapshots
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

The alert query reads from v_query_snapshots using MAX(collection_time)
to find the latest snapshot. When the collector captures 0 active queries,
no new rows are inserted, so MAX(collection_time) still returns the old
snapshot — causing alerts to re-fire indefinitely on queries that finished
hours ago.

Add a 10-minute recency check so stale snapshots are ignored.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
---
 Lite/Services/LocalDataService.WaitStats.cs | 1 +
 1 file changed, 1 insertion(+)

diff --git a/Lite/Services/LocalDataService.WaitStats.cs b/Lite/Services/LocalDataService.WaitStats.cs
index 7ebca42..c46e6e9 100644
--- a/Lite/Services/LocalDataService.WaitStats.cs
+++ b/Lite/Services/LocalDataService.WaitStats.cs
@@ -418,6 +418,7 @@ public async Task<List<LongRunningQueryInfo>> GetLongRunningQueriesAsync(
                 FROM v_query_snapshots AS r
                 WHERE r.server_id = $1
                     AND r.collection_time = (SELECT MAX(vqs.collection_time) FROM v_query_snapshots AS vqs WHERE vqs.server_id = $1)
+                    AND r.collection_time >= NOW() - INTERVAL '10 MINUTES'
                     AND r.session_id > 50
                     {spServerDiagnosticsFilter}
                     {waitForFilter}

From 91d00f6e2697559bac441ddcf961e1692c0bea82 Mon Sep 17 00:00:00 2001
From: Erik Darling <2136037+erikdarlingdata@users.noreply.github.com>
Date: Fri, 3 Apr 2026 17:53:39 -0400
Subject: [PATCH 09/30] Add trust-cert and encryption prompts to CLI installer
 interactive mode

Interactive mode defaulted to Mandatory encryption with no cert trust,
causing connection failures on servers with self-signed certificates.
The retired GUI installer defaulted to Optional/trust-cert which worked.

Now interactive mode prompts for both settings with sensible defaults
(trust cert = Y, encryption = Optional) matching the old GUI behavior.

Fixes #784

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
---
 Installer/Program.cs | 18 ++++++++++++++++++
 1 file changed, 18 insertions(+)

diff --git a/Installer/Program.cs b/Installer/Program.cs
index daa4cb9..9c7cb65 100644
--- a/Installer/Program.cs
+++ b/Installer/Program.cs
@@ -231,6 +231,24 @@ Automated mode with command-line arguments
                     return (int)InstallationResultCode.InvalidArguments;
                 }
 
+                Console.Write("Trust server certificate? (Y/N, default Y): ");
+                string? trustResponse = Console.ReadLine()?.Trim();
+                trustCert = string.IsNullOrWhiteSpace(trustResponse)
+                    || trustResponse.Equals("Y", StringComparison.OrdinalIgnoreCase);
+
+                Console.WriteLine("Encryption level:");
+                Console.WriteLine("  [O] Optional (default)");
+                Console.WriteLine("  [M] Mandatory");
+                Console.WriteLine("  [S] Strict");
+                Console.Write("Choice (O/M/S, default O): ");
+                string? encryptResponse = Console.ReadLine()?.Trim();
+                encryptionLevel = encryptResponse?.ToUpperInvariant() switch
+                {
+                    "M" => "Mandatory",
+                    "S" => "Strict",
+                    _ => "Optional"
+                };
+
                 Console.WriteLine("Authentication type:");
                 Console.WriteLine("  [W] Windows Authentication (default)");
                 Console.WriteLine("  [S] SQL Server Authentication");

From 3ad290808245d94650a8f68402a85ff60ef1d616 Mon Sep 17 00:00:00 2001
From: Erik Darling <2136037+erikdarlingdata@users.noreply.github.com>
Date: Fri, 3 Apr 2026 22:35:44 -0400
Subject: [PATCH 10/30] Fix CLI installer argument parsing treating flags as
 positional args

Flags like --encrypt optional (space-separated) were not fully stripped
from positional arguments, causing the installer to misinterpret them as
a username and fall into the SQL Auth path unexpectedly.

Replace individual flag filters with a single loop that strips all --
prefixed flags and consumes trailing values for --entra and --encrypt.
Also support --encrypt <level> (space) in addition to --encrypt=<level>.

Fixes #786

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
---
 Installer/Program.cs | 52 +++++++++++++++++++++++++++++---------------
 1 file changed, 35 insertions(+), 17 deletions(-)

diff --git a/Installer/Program.cs b/Installer/Program.cs
index 9c7cb65..bbb487a 100644
--- a/Installer/Program.cs
+++ b/Installer/Program.cs
@@ -100,12 +100,13 @@ static async Task<int> Main(string[] args)
                 }
             }
 
-            /*Parse encryption option (default: Mandatory)*/
-            var encryptArg = args.FirstOrDefault(a => a.StartsWith("--encrypt=", StringComparison.OrdinalIgnoreCase));
+            /*Parse encryption option (default: Mandatory)
+              Supports both --encrypt=optional and --encrypt optional */
             string encryptionLevel = "Mandatory";
-            if (encryptArg != null)
+            var encryptEqualsArg = args.FirstOrDefault(a => a.StartsWith("--encrypt=", StringComparison.OrdinalIgnoreCase));
+            if (encryptEqualsArg != null)
             {
-                string encryptValue = encryptArg.Substring("--encrypt=".Length).ToLowerInvariant();
+                string encryptValue = encryptEqualsArg.Substring("--encrypt=".Length).ToLowerInvariant();
                 encryptionLevel = encryptValue switch
                 {
                     "optional" => "Optional",
@@ -113,21 +114,38 @@ static async Task<int> Main(string[] args)
                     _ => "Mandatory"
                 };
             }
+            else
+            {
+                int encryptIndex = Array.FindIndex(args, a => a.Equals("--encrypt", StringComparison.OrdinalIgnoreCase));
+                if (encryptIndex >= 0 && encryptIndex + 1 < args.Length && !args[encryptIndex + 1].StartsWith("--", StringComparison.Ordinal))
+                {
+                    encryptionLevel = args[encryptIndex + 1].ToLowerInvariant() switch
+                    {
+                        "optional" => "Optional",
+                        "strict" => "Strict",
+                        _ => "Mandatory"
+                    };
+                }
+            }
 
-            /*Filter out option flags and --entra <email> to get positional arguments*/
-            var filteredArgsList = args
-                .Where(a => !a.Equals("--reinstall", StringComparison.OrdinalIgnoreCase))
-                .Where(a => !a.Equals("--uninstall", StringComparison.OrdinalIgnoreCase))
-                .Where(a => !a.Equals("--reset-schedule", StringComparison.OrdinalIgnoreCase))
-                .Where(a => !a.Equals("--trust-cert", StringComparison.OrdinalIgnoreCase))
-                .Where(a => !a.StartsWith("--encrypt=", StringComparison.OrdinalIgnoreCase))
-                .Where(a => !a.Equals("--entra", StringComparison.OrdinalIgnoreCase))
-                .ToList();
-
-            /*Remove the entra email from positional args if present*/
-            if (entraEmail != null)
+            /*Filter out all --flags and their trailing values to get positional arguments
+              (server, username, password). Flags like --entra <email> and --encrypt <level>
+              have a following value that must also be removed.*/
+            var filteredArgsList = new List<string>();
+            for (int i = 0; i < args.Length; i++)
             {
-                filteredArgsList.Remove(entraEmail);
+                if (args[i].StartsWith("--", StringComparison.Ordinal))
+                {
+                    /*Skip flags that take a trailing value (--entra <email>, --encrypt <level>)*/
+                    if ((args[i].Equals("--entra", StringComparison.OrdinalIgnoreCase)
+                        || args[i].Equals("--encrypt", StringComparison.OrdinalIgnoreCase))
+                        && i + 1 < args.Length && !args[i + 1].StartsWith("--", StringComparison.Ordinal))
+                    {
+                        i++; /*skip the value too*/
+                    }
+                    continue;
+                }
+                filteredArgsList.Add(args[i]);
             }
 
             var filteredArgs = filteredArgsList.ToArray();

From 6afaef661798e440589654fded856aacea10d019 Mon Sep 17 00:00:00 2001
From: Erik Darling <2136037+erikdarlingdata@users.noreply.github.com>
Date: Mon, 6 Apr 2026 10:02:52 -0400
Subject: [PATCH 11/30] Add plans/ directory to .gitignore

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
---
 .gitignore | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/.gitignore b/.gitignore
index 8d19cb1..e5507e8 100644
--- a/.gitignore
+++ b/.gitignore
@@ -56,3 +56,6 @@ nul
 Lite/config/servers.json
 Lite/servers.json
 Lite/collection_schedule.json
+
+# Plans directory
+plans/

From 1bfabb44e13d2d2dffe510673b74cd67a3198aeb Mon Sep 17 00:00:00 2001
From: Erik Darling <2136037+erikdarlingdata@users.noreply.github.com>
Date: Mon, 6 Apr 2026 11:10:42 -0400
Subject: [PATCH 12/30] Show nonclustered index count badge on modification
 operators in plan viewer

Closes #788. Parses Object elements with IndexKind="NonClustered" from
Update/SimpleUpdate/CreateIndex operators and displays a "+N NC" badge on
the plan node, with index names in the tooltip and properties panel.
Matches PerformanceStudio implementation. Both Dashboard and Lite in sync.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
---
 Dashboard/Controls/PlanViewerControl.xaml.cs | 33 +++++++++++++++++++-
 Dashboard/Models/PlanModels.cs               |  4 +++
 Dashboard/Services/ShowPlanParser.cs         | 16 ++++++++++
 Lite/Controls/PlanViewerControl.xaml.cs      | 33 +++++++++++++++++++-
 Lite/Models/PlanModels.cs                    |  4 +++
 Lite/Services/ShowPlanParser.cs              | 16 ++++++++++
 6 files changed, 104 insertions(+), 2 deletions(-)

diff --git a/Dashboard/Controls/PlanViewerControl.xaml.cs b/Dashboard/Controls/PlanViewerControl.xaml.cs
index 3ec40d4..247581d 100644
--- a/Dashboard/Controls/PlanViewerControl.xaml.cs
+++ b/Dashboard/Controls/PlanViewerControl.xaml.cs
@@ -279,6 +279,27 @@ private Border CreateNodeVisual(PlanNode node, int totalWarningCount = -1)
             iconRow.Children.Add(parBadge);
         }
 
+        // Nonclustered index count badge (modification operators maintaining multiple NC indexes)
+        if (node.NonClusteredIndexCount > 0)
+        {
+            var ncBadge = new Border
+            {
+                Background = new SolidColorBrush(Color.FromRgb(0x6C, 0x75, 0x7D)),
+                CornerRadius = new CornerRadius(4),
+                Padding = new Thickness(4, 1, 4, 1),
+                Margin = new Thickness(4, 0, 0, 0),
+                VerticalAlignment = VerticalAlignment.Center,
+                Child = new TextBlock
+                {
+                    Text = $"+{node.NonClusteredIndexCount} NC",
+                    FontSize = 10,
+                    FontWeight = FontWeights.SemiBold,
+                    Foreground = Brushes.White
+                }
+            };
+            iconRow.Children.Add(ncBadge);
+        }
+
         stack.Children.Add(iconRow);
 
         // Operator name — use full name, let TextTrimming handle overflow
@@ -693,7 +714,7 @@ private void ShowPropertiesPanel(PlanNode node)
             || node.SortDistinct || node.StartupExpression
             || node.NLOptimized || node.WithOrderedPrefetch || node.WithUnorderedPrefetch
             || node.WithTies || node.Remoting || node.LocalParallelism
-            || node.SpoolStack || node.DMLRequestSort
+            || node.SpoolStack || node.DMLRequestSort || node.NonClusteredIndexCount > 0
             || !string.IsNullOrEmpty(node.OffsetExpression) || node.TopRows > 0
             || !string.IsNullOrEmpty(node.ConstantScanValues)
             || !string.IsNullOrEmpty(node.UdxUsedColumns);
@@ -742,6 +763,12 @@ private void ShowPropertiesPanel(PlanNode node)
                 AddPropertyRow("Primary Node Id", $"{node.PrimaryNodeId}");
             if (node.DMLRequestSort)
                 AddPropertyRow("DML Request Sort", "True");
+            if (node.NonClusteredIndexCount > 0)
+            {
+                AddPropertyRow("NC Indexes Maintained", $"{node.NonClusteredIndexCount}");
+                foreach (var ixName in node.NonClusteredIndexNames)
+                    AddPropertyRow("", ixName, isCode: true);
+            }
             if (!string.IsNullOrEmpty(node.ActionColumn))
                 AddPropertyRow("Action Column", node.ActionColumn, isCode: true);
             if (!string.IsNullOrEmpty(node.SegmentColumn))
@@ -1652,6 +1679,10 @@ private ToolTip BuildNodeTooltip(PlanNode node, List<PlanWarning>? allWarnings =
                 AddTooltipRow(stack, "Scan Direction", node.ScanDirection);
         }
 
+        // NC index maintenance count
+        if (node.NonClusteredIndexCount > 0)
+            AddTooltipRow(stack, "NC Indexes Maintained", string.Join(", ", node.NonClusteredIndexNames));
+
         // Operator details (key items only in tooltip)
         var hasTooltipDetails = !string.IsNullOrEmpty(node.OrderBy)
             || !string.IsNullOrEmpty(node.TopExpression)
diff --git a/Dashboard/Models/PlanModels.cs b/Dashboard/Models/PlanModels.cs
index 57d6a25..d3c7527 100644
--- a/Dashboard/Models/PlanModels.cs
+++ b/Dashboard/Models/PlanModels.cs
@@ -251,6 +251,10 @@ public class PlanNode
     public List<PlanWarning> Warnings { get; set; } = new();
     public bool HasWarnings => Warnings.Count > 0;
 
+    // Modification operator: nonclustered indexes maintained
+    public int NonClusteredIndexCount { get; set; }
+    public List<string> NonClusteredIndexNames { get; set; } = new();
+
     // Tree structure
     public List<PlanNode> Children { get; set; } = new();
     public PlanNode? Parent { get; set; }
diff --git a/Dashboard/Services/ShowPlanParser.cs b/Dashboard/Services/ShowPlanParser.cs
index 0066879..b8c45c6 100644
--- a/Dashboard/Services/ShowPlanParser.cs
+++ b/Dashboard/Services/ShowPlanParser.cs
@@ -972,6 +972,22 @@ private static PlanNode ParseRelOp(XElement relOpEl)
             if (actionColEl != null)
                 node.ActionColumn = FormatColumnRef(actionColEl);
 
+            // Nonclustered indexes maintained by modification operators (Update/SimpleUpdate/CreateIndex)
+            var opName = physicalOpEl.Name.LocalName;
+            if (opName is "Update" or "SimpleUpdate" or "CreateIndex")
+            {
+                var ncObjects = ScopedDescendants(physicalOpEl, Ns + "Object")
+                    .Where(o => string.Equals(o.Attribute("IndexKind")?.Value, "NonClustered", StringComparison.OrdinalIgnoreCase))
+                    .ToList();
+                node.NonClusteredIndexCount = ncObjects.Count;
+                foreach (var ncObj in ncObjects)
+                {
+                    var ixName = ncObj.Attribute("Index")?.Value?.Replace("[", "").Replace("]", "");
+                    if (!string.IsNullOrEmpty(ixName))
+                        node.NonClusteredIndexNames.Add(ixName);
+                }
+            }
+
             // SET predicate (UPDATE operator)
             var setPredicateEl = physicalOpEl.Element(Ns + "SetPredicate");
             if (setPredicateEl != null)
diff --git a/Lite/Controls/PlanViewerControl.xaml.cs b/Lite/Controls/PlanViewerControl.xaml.cs
index fc40d6a..fb4af2e 100644
--- a/Lite/Controls/PlanViewerControl.xaml.cs
+++ b/Lite/Controls/PlanViewerControl.xaml.cs
@@ -295,6 +295,27 @@ private Border CreateNodeVisual(PlanNode node, int totalWarningCount = -1)
             iconRow.Children.Add(parBadge);
         }
 
+        // Nonclustered index count badge (modification operators maintaining multiple NC indexes)
+        if (node.NonClusteredIndexCount > 0)
+        {
+            var ncBadge = new Border
+            {
+                Background = new SolidColorBrush(Color.FromRgb(0x6C, 0x75, 0x7D)),
+                CornerRadius = new CornerRadius(4),
+                Padding = new Thickness(4, 1, 4, 1),
+                Margin = new Thickness(4, 0, 0, 0),
+                VerticalAlignment = VerticalAlignment.Center,
+                Child = new TextBlock
+                {
+                    Text = $"+{node.NonClusteredIndexCount} NC",
+                    FontSize = 10,
+                    FontWeight = FontWeights.SemiBold,
+                    Foreground = Brushes.White
+                }
+            };
+            iconRow.Children.Add(ncBadge);
+        }
+
         stack.Children.Add(iconRow);
 
         // Operator name — use full name, let TextTrimming handle overflow
@@ -710,7 +731,7 @@ private void ShowPropertiesPanel(PlanNode node)
             || node.SortDistinct || node.StartupExpression
             || node.NLOptimized || node.WithOrderedPrefetch || node.WithUnorderedPrefetch
             || node.WithTies || node.Remoting || node.LocalParallelism
-            || node.SpoolStack || node.DMLRequestSort
+            || node.SpoolStack || node.DMLRequestSort || node.NonClusteredIndexCount > 0
             || !string.IsNullOrEmpty(node.OffsetExpression) || node.TopRows > 0
             || !string.IsNullOrEmpty(node.ConstantScanValues)
             || !string.IsNullOrEmpty(node.UdxUsedColumns);
@@ -759,6 +780,12 @@ private void ShowPropertiesPanel(PlanNode node)
                 AddPropertyRow("Primary Node Id", $"{node.PrimaryNodeId}");
             if (node.DMLRequestSort)
                 AddPropertyRow("DML Request Sort", "True");
+            if (node.NonClusteredIndexCount > 0)
+            {
+                AddPropertyRow("NC Indexes Maintained", $"{node.NonClusteredIndexCount}");
+                foreach (var ixName in node.NonClusteredIndexNames)
+                    AddPropertyRow("", ixName, isCode: true);
+            }
             if (!string.IsNullOrEmpty(node.ActionColumn))
                 AddPropertyRow("Action Column", node.ActionColumn, isCode: true);
             if (!string.IsNullOrEmpty(node.SegmentColumn))
@@ -1664,6 +1691,10 @@ private ToolTip BuildNodeTooltip(PlanNode node, List<PlanWarning>? allWarnings =
                 AddTooltipRow(stack, "Scan Direction", node.ScanDirection);
         }
 
+        // NC index maintenance count
+        if (node.NonClusteredIndexCount > 0)
+            AddTooltipRow(stack, "NC Indexes Maintained", string.Join(", ", node.NonClusteredIndexNames));
+
         // Operator details (key items only in tooltip)
         var hasTooltipDetails = !string.IsNullOrEmpty(node.OrderBy)
             || !string.IsNullOrEmpty(node.TopExpression)
diff --git a/Lite/Models/PlanModels.cs b/Lite/Models/PlanModels.cs
index a6e62f7..50a3392 100644
--- a/Lite/Models/PlanModels.cs
+++ b/Lite/Models/PlanModels.cs
@@ -251,6 +251,10 @@ public class PlanNode
     public List<PlanWarning> Warnings { get; set; } = new();
     public bool HasWarnings => Warnings.Count > 0;
 
+    // Modification operator: nonclustered indexes maintained
+    public int NonClusteredIndexCount { get; set; }
+    public List<string> NonClusteredIndexNames { get; set; } = new();
+
     // Tree structure
     public List<PlanNode> Children { get; set; } = new();
     public PlanNode? Parent { get; set; }
diff --git a/Lite/Services/ShowPlanParser.cs b/Lite/Services/ShowPlanParser.cs
index b30fb0f..bd08ff2 100644
--- a/Lite/Services/ShowPlanParser.cs
+++ b/Lite/Services/ShowPlanParser.cs
@@ -972,6 +972,22 @@ private static PlanNode ParseRelOp(XElement relOpEl)
             if (actionColEl != null)
                 node.ActionColumn = FormatColumnRef(actionColEl);
 
+            // Nonclustered indexes maintained by modification operators (Update/SimpleUpdate/CreateIndex)
+            var opName = physicalOpEl.Name.LocalName;
+            if (opName is "Update" or "SimpleUpdate" or "CreateIndex")
+            {
+                var ncObjects = ScopedDescendants(physicalOpEl, Ns + "Object")
+                    .Where(o => string.Equals(o.Attribute("IndexKind")?.Value, "NonClustered", StringComparison.OrdinalIgnoreCase))
+                    .ToList();
+                node.NonClusteredIndexCount = ncObjects.Count;
+                foreach (var ncObj in ncObjects)
+                {
+                    var ixName = ncObj.Attribute("Index")?.Value?.Replace("[", "").Replace("]", "");
+                    if (!string.IsNullOrEmpty(ixName))
+                        node.NonClusteredIndexNames.Add(ixName);
+                }
+            }
+
             // SET predicate (UPDATE operator)
             var setPredicateEl = physicalOpEl.Element(Ns + "SetPredicate");
             if (setPredicateEl != null)

From 1b05bae6b0887952ff3c6aeda09e565a197b4a60 Mon Sep 17 00:00:00 2001
From: Erik Darling <2136037+erikdarlingdata@users.noreply.github.com>
Date: Mon, 6 Apr 2026 12:17:27 -0400
Subject: [PATCH 13/30] Add correlated timeline lanes to Lite Overview tab
 (#688)

Replaces the 2x2 chart grid with 5 vertically stacked lanes sharing a
synchronized time axis and crosshair: CPU, Wait Stats, Blocking &
Deadlocking, Memory, and I/O Latency. Hovering any lane shows values
from all lanes at that time point.

New files:
- CorrelatedTimelineLanesControl (XAML + code-behind)
- CorrelatedCrosshairManager (cross-chart sync with multi-series support)
- GetTotalWaitTrendAsync (aggregated wait stats query)

Also fixes GetDeadlockTrendAsync granularity from hourly to per-minute
buckets to match blocking trend.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
---
 .../CorrelatedTimelineLanesControl.xaml       | 100 +++++
 .../CorrelatedTimelineLanesControl.xaml.cs    | 380 ++++++++++++++++++
 Lite/Controls/ServerTab.xaml                  |  25 +-
 Lite/Controls/ServerTab.xaml.cs               | 172 +-------
 Lite/Helpers/CorrelatedCrosshairManager.cs    | 309 ++++++++++++++
 Lite/Services/LocalDataService.Blocking.cs    |   6 +-
 Lite/Services/LocalDataService.WaitStats.cs   |  49 +++
 7 files changed, 848 insertions(+), 193 deletions(-)
 create mode 100644 Lite/Controls/CorrelatedTimelineLanesControl.xaml
 create mode 100644 Lite/Controls/CorrelatedTimelineLanesControl.xaml.cs
 create mode 100644 Lite/Helpers/CorrelatedCrosshairManager.cs

diff --git a/Lite/Controls/CorrelatedTimelineLanesControl.xaml b/Lite/Controls/CorrelatedTimelineLanesControl.xaml
new file mode 100644
index 0000000..ef273ba
--- /dev/null
+++ b/Lite/Controls/CorrelatedTimelineLanesControl.xaml
@@ -0,0 +1,100 @@
+<UserControl x:Class="PerformanceMonitorLite.Controls.CorrelatedTimelineLanesControl"
+             xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
+             xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
+             xmlns:ScottPlot="clr-namespace:ScottPlot.WPF;assembly=ScottPlot.WPF">
+
+    <Grid Margin="8">
+        <Grid.RowDefinitions>
+            <!-- 5 lanes, equal height -->
+            <RowDefinition Height="*"/>
+            <RowDefinition Height="*"/>
+            <RowDefinition Height="*"/>
+            <RowDefinition Height="*"/>
+            <RowDefinition Height="*"/>
+        </Grid.RowDefinitions>
+
+        <!-- Lane 1: CPU -->
+        <Grid Grid.Row="0" Margin="0,0,0,2">
+            <Grid.ColumnDefinitions>
+                <ColumnDefinition Width="100"/>
+                <ColumnDefinition Width="*"/>
+                <ColumnDefinition Width="80"/>
+            </Grid.ColumnDefinitions>
+            <TextBlock Grid.Column="0" Text="CPU %" VerticalAlignment="Center"
+                       FontSize="12" FontWeight="SemiBold"
+                       Foreground="{DynamicResource ForegroundBrush}" Margin="4,0"/>
+            <ScottPlot:WpfPlot Grid.Column="1" x:Name="CpuChart"/>
+            <TextBlock Grid.Column="2" x:Name="CpuValueLabel" VerticalAlignment="Center"
+                       HorizontalAlignment="Right" FontSize="11"
+                       Foreground="{DynamicResource ForegroundBrush}" Margin="4,0"/>
+        </Grid>
+
+        <!-- Lane 2: Wait Stats -->
+        <Grid Grid.Row="1" Margin="0,2,0,2">
+            <Grid.ColumnDefinitions>
+                <ColumnDefinition Width="100"/>
+                <ColumnDefinition Width="*"/>
+                <ColumnDefinition Width="80"/>
+            </Grid.ColumnDefinitions>
+            <TextBlock Grid.Column="0" Text="Wait ms/sec" VerticalAlignment="Center"
+                       FontSize="12" FontWeight="SemiBold"
+                       Foreground="{DynamicResource ForegroundBrush}" Margin="4,0"/>
+            <ScottPlot:WpfPlot Grid.Column="1" x:Name="WaitStatsChart"/>
+            <TextBlock Grid.Column="2" x:Name="WaitStatsValueLabel" VerticalAlignment="Center"
+                       HorizontalAlignment="Right" FontSize="11"
+                       Foreground="{DynamicResource ForegroundBrush}" Margin="4,0"/>
+        </Grid>
+
+        <!-- Lane 3: Blocking -->
+        <Grid Grid.Row="2" Margin="0,2,0,2">
+            <Grid.ColumnDefinitions>
+                <ColumnDefinition Width="100"/>
+                <ColumnDefinition Width="*"/>
+                <ColumnDefinition Width="80"/>
+            </Grid.ColumnDefinitions>
+            <TextBlock Grid.Column="0" VerticalAlignment="Center"
+                       FontSize="12" FontWeight="SemiBold"
+                       Foreground="{DynamicResource ForegroundBrush}" Margin="4,0">
+                <Run Text="Blocking &amp;"/>
+                <LineBreak/>
+                <Run Text="Deadlocking"/>
+            </TextBlock>
+            <ScottPlot:WpfPlot Grid.Column="1" x:Name="BlockingChart"/>
+            <TextBlock Grid.Column="2" x:Name="BlockingValueLabel" VerticalAlignment="Center"
+                       HorizontalAlignment="Right" FontSize="11"
+                       Foreground="{DynamicResource ForegroundBrush}" Margin="4,0"/>
+        </Grid>
+
+        <!-- Lane 4: Memory -->
+        <Grid Grid.Row="3" Margin="0,2,0,2">
+            <Grid.ColumnDefinitions>
+                <ColumnDefinition Width="100"/>
+                <ColumnDefinition Width="*"/>
+                <ColumnDefinition Width="80"/>
+            </Grid.ColumnDefinitions>
+            <TextBlock Grid.Column="0" Text="Memory MB" VerticalAlignment="Center"
+                       FontSize="12" FontWeight="SemiBold"
+                       Foreground="{DynamicResource ForegroundBrush}" Margin="4,0"/>
+            <ScottPlot:WpfPlot Grid.Column="1" x:Name="MemoryChart"/>
+            <TextBlock Grid.Column="2" x:Name="MemoryValueLabel" VerticalAlignment="Center"
+                       HorizontalAlignment="Right" FontSize="11"
+                       Foreground="{DynamicResource ForegroundBrush}" Margin="4,0"/>
+        </Grid>
+
+        <!-- Lane 5: File I/O -->
+        <Grid Grid.Row="4" Margin="0,2,0,0">
+            <Grid.ColumnDefinitions>
+                <ColumnDefinition Width="100"/>
+                <ColumnDefinition Width="*"/>
+                <ColumnDefinition Width="80"/>
+            </Grid.ColumnDefinitions>
+            <TextBlock Grid.Column="0" Text="I/O Latency" VerticalAlignment="Center"
+                       FontSize="12" FontWeight="SemiBold"
+                       Foreground="{DynamicResource ForegroundBrush}" Margin="4,0"/>
+            <ScottPlot:WpfPlot Grid.Column="1" x:Name="FileIoChart"/>
+            <TextBlock Grid.Column="2" x:Name="FileIoValueLabel" VerticalAlignment="Center"
+                       HorizontalAlignment="Right" FontSize="11"
+                       Foreground="{DynamicResource ForegroundBrush}" Margin="4,0"/>
+        </Grid>
+    </Grid>
+</UserControl>
diff --git a/Lite/Controls/CorrelatedTimelineLanesControl.xaml.cs b/Lite/Controls/CorrelatedTimelineLanesControl.xaml.cs
new file mode 100644
index 0000000..5f4e01d
--- /dev/null
+++ b/Lite/Controls/CorrelatedTimelineLanesControl.xaml.cs
@@ -0,0 +1,380 @@
+/*
+ * 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.
+ *
+ * SYNC WARNING: Dashboard has a matching copy at Dashboard/Controls/CorrelatedTimelineLanesControl.xaml.cs.
+ * Changes here must be mirrored there.
+ */
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+using System.Windows;
+using System.Windows.Controls;
+using PerformanceMonitorLite.Helpers;
+using PerformanceMonitorLite.Services;
+
+namespace PerformanceMonitorLite.Controls;
+
+public partial class CorrelatedTimelineLanesControl : UserControl
+{
+    private LocalDataService? _dataService;
+    private int _serverId;
+    private CorrelatedCrosshairManager? _crosshairManager;
+    private bool _isRefreshing;
+
+    public CorrelatedTimelineLanesControl()
+    {
+        InitializeComponent();
+        Unloaded += (_, _) => _crosshairManager?.Dispose();
+    }
+
+    /// <summary>
+    /// Initializes the control with the data service and server ID.
+    /// Must be called before RefreshAsync.
+    /// </summary>
+    public void Initialize(LocalDataService dataService, int serverId)
+    {
+        _dataService = dataService;
+        _serverId = serverId;
+
+        var charts = new[] { CpuChart, WaitStatsChart, BlockingChart, MemoryChart, FileIoChart };
+        foreach (var chart in charts)
+        {
+            ApplyTheme(chart);
+            // Disable zoom/pan/drag but keep mouse events for crosshair
+            chart.UserInputProcessor.UserActionResponses.Clear();
+        }
+
+        _crosshairManager = new CorrelatedCrosshairManager();
+        _crosshairManager.AddLane(CpuChart, "CPU", "%", CpuValueLabel);
+        _crosshairManager.AddLane(WaitStatsChart, "Wait Stats", "ms/sec", WaitStatsValueLabel);
+        _crosshairManager.AddLane(BlockingChart, "Blocking", "events", BlockingValueLabel);
+        _crosshairManager.AddLane(MemoryChart, "Memory", "MB", MemoryValueLabel);
+        _crosshairManager.AddLane(FileIoChart, "I/O Latency", "ms", FileIoValueLabel);
+    }
+
+    /// <summary>
+    /// Refreshes all lane data for the given time range.
+    /// </summary>
+    public async Task RefreshAsync(int hoursBack, DateTime? fromDate, DateTime? toDate)
+    {
+        if (_dataService == null || _isRefreshing) return;
+        _isRefreshing = true;
+
+        try
+        {
+            _crosshairManager?.PrepareForRefresh();
+
+            var cpuTask = _dataService.GetCpuUtilizationAsync(_serverId, hoursBack, fromDate, toDate);
+            var waitTask = _dataService.GetTotalWaitTrendAsync(_serverId, hoursBack, fromDate, toDate);
+            var blockingTask = _dataService.GetBlockingTrendAsync(_serverId, hoursBack, fromDate, toDate);
+            var deadlockTask = _dataService.GetDeadlockTrendAsync(_serverId, hoursBack, fromDate, toDate);
+            var memoryTask = _dataService.GetMemoryTrendAsync(_serverId, hoursBack, fromDate, toDate);
+            var fileIoTask = _dataService.GetFileIoLatencyTrendAsync(_serverId, hoursBack, fromDate, toDate);
+
+            try
+            {
+                await Task.WhenAll(cpuTask, waitTask, blockingTask, deadlockTask, memoryTask, fileIoTask);
+            }
+            catch (Exception ex)
+            {
+                AppLogger.Info("CorrelatedLanes", $"Data fetch failed: {ex.Message}");
+            }
+
+            var utcOffset = ServerTimeHelper.UtcOffsetMinutes;
+
+            if (cpuTask.IsCompletedSuccessfully)
+                UpdateLane(CpuChart, "CPU %",
+                    cpuTask.Result.Select(d => (d.SampleTime.ToOADate(), (double)d.SqlServerCpu)).ToList(),
+                    "#4FC3F7", 0, 105);
+            else
+                ShowEmpty(CpuChart, "CPU %");
+
+            if (waitTask.IsCompletedSuccessfully)
+                UpdateLane(WaitStatsChart, "Wait ms/sec",
+                    waitTask.Result.Select(d => (d.CollectionTime.AddMinutes(utcOffset).ToOADate(), d.WaitTimeMsPerSecond)).ToList(),
+                    "#FFB74D");
+            else
+                ShowEmpty(WaitStatsChart, "Wait ms/sec");
+
+            {
+                var blockingData = blockingTask.IsCompletedSuccessfully
+                    ? blockingTask.Result.Select(d => (d.Time.AddMinutes(utcOffset).ToOADate(), (double)d.Count)).ToList()
+                    : new List<(double, double)>();
+                var deadlockData = deadlockTask.IsCompletedSuccessfully
+                    ? deadlockTask.Result.Select(d => (d.Time.AddMinutes(utcOffset).ToOADate(), (double)d.Count)).ToList()
+                    : new List<(double, double)>();
+                UpdateBlockingLane(blockingData, deadlockData);
+            }
+
+            if (memoryTask.IsCompletedSuccessfully)
+                UpdateLane(MemoryChart, "Memory MB",
+                    memoryTask.Result.Select(d => (d.CollectionTime.AddMinutes(utcOffset).ToOADate(), d.BufferPoolMb)).ToList(),
+                    "#CE93D8");
+            else
+                ShowEmpty(MemoryChart, "Memory MB");
+
+            if (fileIoTask.IsCompletedSuccessfully)
+            {
+                var ioGrouped = fileIoTask.Result
+                    .GroupBy(d => d.CollectionTime)
+                    .OrderBy(g => g.Key)
+                    .Select(g => (g.Key.AddMinutes(utcOffset).ToOADate(), g.Average(x => x.AvgReadLatencyMs)))
+                    .ToList();
+                UpdateLane(FileIoChart, "I/O ms", ioGrouped, "#81C784");
+            }
+            else
+                ShowEmpty(FileIoChart, "I/O ms");
+
+            _crosshairManager?.ReattachVLines();
+            SyncXAxes(hoursBack, fromDate, toDate, utcOffset);
+        }
+        finally
+        {
+            _isRefreshing = false;
+        }
+    }
+
+    private void UpdateBlockingLane(List<(double Time, double Value)> blockingData,
+        List<(double Time, double Value)> deadlockData)
+    {
+        ClearChart(BlockingChart);
+        ApplyTheme(BlockingChart);
+
+        // Register blocking and deadlock as separate named series for the tooltip
+        var blockTimes = blockingData.Select(d => d.Time).ToArray();
+        var blockValues = blockingData.Select(d => d.Value).ToArray();
+        var deadTimes = deadlockData.Select(d => d.Time).ToArray();
+        var deadValues = deadlockData.Select(d => d.Value).ToArray();
+
+        // First series clears any previous data
+        _crosshairManager?.SetLaneData(BlockingChart, blockTimes, blockValues, isEventBased: true);
+        // Rename the auto-created series and add the second
+        _crosshairManager?.AddLaneSeries(BlockingChart, "Deadlocks", "events",
+            deadTimes, deadValues, isEventBased: true);
+
+        if (blockingData.Count == 0 && deadlockData.Count == 0)
+        {
+            ShowEmpty(BlockingChart, "Block/Dead");
+            return;
+        }
+
+        double barWidth = 30.0 / 86400.0;
+        double maxCount = 0;
+
+        // Blocking bars — red
+        if (blockingData.Count > 0)
+        {
+            var bars = blockingData.Select(d => new ScottPlot.Bar
+            {
+                Position = d.Time,
+                Value = d.Value,
+                Size = barWidth,
+                FillColor = ScottPlot.Color.FromHex("#E57373"),
+                LineWidth = 0
+            }).ToArray();
+            BlockingChart.Plot.Add.Bars(bars);
+            maxCount = Math.Max(maxCount, blockingData.Max(d => d.Value));
+        }
+
+        // Deadlock bars — yellow/amber, slightly narrower so both are visible
+        if (deadlockData.Count > 0)
+        {
+            var bars = deadlockData.Select(d => new ScottPlot.Bar
+            {
+                Position = d.Time,
+                Value = d.Value,
+                Size = barWidth * 0.6,
+                FillColor = ScottPlot.Color.FromHex("#FFD54F"),
+                LineWidth = 0
+            }).ToArray();
+            BlockingChart.Plot.Add.Bars(bars);
+            maxCount = Math.Max(maxCount, deadlockData.Max(d => d.Value));
+        }
+
+        BlockingChart.Plot.Axes.DateTimeTicksBottom();
+        BlockingChart.Plot.Axes.Bottom.TickLabelStyle.IsVisible = false;
+        ReapplyAxisColors(BlockingChart);
+
+        BlockingChart.Plot.Title("");
+        BlockingChart.Plot.YLabel("");
+        BlockingChart.Plot.Legend.IsVisible = false;
+        BlockingChart.Plot.Axes.Margins(bottom: 0);
+        BlockingChart.Plot.Axes.SetLimitsY(0, Math.Max(maxCount * 1.3, 2));
+
+        BlockingChart.Refresh();
+    }
+
+    private void UpdateLane(ScottPlot.WPF.WpfPlot chart, string title,
+        List<(double Time, double Value)> data, string colorHex,
+        double? yMin = null, double? yMax = null)
+    {
+        ClearChart(chart);
+        ApplyTheme(chart);
+
+        if (data.Count == 0)
+        {
+            ShowEmpty(chart, title);
+            return;
+        }
+
+        var times = data.Select(d => d.Time).ToArray();
+        var values = data.Select(d => d.Value).ToArray();
+
+        var scatter = chart.Plot.Add.Scatter(times, values);
+        scatter.Color = ScottPlot.Color.FromHex(colorHex);
+        scatter.MarkerSize = 0;
+        scatter.LineWidth = 1.5f;
+        scatter.LegendText = title;
+        scatter.ConnectStyle = ScottPlot.ConnectStyle.Straight;
+
+        _crosshairManager?.SetLaneData(chart, times, values);
+
+        chart.Plot.Axes.DateTimeTicksBottom();
+        // Hide bottom tick labels on all lanes except the last (File I/O)
+        if (chart != FileIoChart)
+            chart.Plot.Axes.Bottom.TickLabelStyle.IsVisible = false;
+
+        ReapplyAxisColors(chart);
+
+        // Compact layout: hide Y label, minimize title, no legend
+        chart.Plot.Title("");
+        chart.Plot.YLabel("");
+        chart.Plot.Legend.IsVisible = false;
+        chart.Plot.Axes.Margins(bottom: 0);
+
+        if (yMin.HasValue && yMax.HasValue)
+            chart.Plot.Axes.SetLimitsY(yMin.Value, yMax.Value);
+        else
+        {
+            var maxVal = data.Max(d => d.Value);
+            var minVal = data.Min(d => d.Value);
+            var padding = Math.Max((maxVal - minVal) * 0.1, 1);
+            chart.Plot.Axes.SetLimitsY(Math.Max(0, minVal - padding), maxVal + padding);
+        }
+
+        chart.Refresh();
+    }
+
+    /// <summary>
+    /// Sets identical X-axis limits across all lanes.
+    /// </summary>
+    private void SyncXAxes(int hoursBack, DateTime? fromDate, DateTime? toDate, double utcOffset)
+    {
+        DateTime xStart, xEnd;
+        if (fromDate.HasValue && toDate.HasValue)
+        {
+            xStart = fromDate.Value;
+            xEnd = toDate.Value;
+        }
+        else
+        {
+            xEnd = DateTime.UtcNow.AddMinutes(utcOffset);
+            xStart = xEnd.AddHours(-hoursBack);
+        }
+
+        double xMin = xStart.ToOADate();
+        double xMax = xEnd.ToOADate();
+
+        var charts = new[] { CpuChart, WaitStatsChart, BlockingChart, MemoryChart, FileIoChart };
+        foreach (var chart in charts)
+        {
+            chart.Plot.Axes.SetLimitsX(xMin, xMax);
+            chart.Refresh();
+        }
+    }
+
+    private static void ClearChart(ScottPlot.WPF.WpfPlot chart)
+    {
+        chart.Reset();
+        chart.Plot.Clear();
+    }
+
+    private static void ShowEmpty(ScottPlot.WPF.WpfPlot chart, string title)
+    {
+        ReapplyAxisColors(chart);
+        var text = chart.Plot.Add.Text($"{title}\nNo Data", 0, 0);
+        text.LabelFontColor = ScottPlot.Color.FromHex("#888888");
+        text.LabelFontSize = 12;
+        text.LabelAlignment = ScottPlot.Alignment.MiddleCenter;
+        chart.Plot.HideGrid();
+        chart.Plot.Axes.SetLimitsX(-1, 1);
+        chart.Plot.Axes.SetLimitsY(-1, 1);
+        chart.Plot.Axes.Bottom.TickGenerator = new ScottPlot.TickGenerators.EmptyTickGenerator();
+        chart.Plot.Axes.Left.TickGenerator = new ScottPlot.TickGenerators.EmptyTickGenerator();
+        chart.Plot.Legend.IsVisible = false;
+        chart.Refresh();
+    }
+
+    /// <summary>
+    /// Reapplies theme to all lane charts (call on theme change).
+    /// </summary>
+    public void ReapplyTheme()
+    {
+        var charts = new[] { CpuChart, WaitStatsChart, BlockingChart, MemoryChart, FileIoChart };
+        foreach (var chart in charts)
+        {
+            ApplyTheme(chart);
+            chart.Refresh();
+        }
+    }
+
+    private static void ApplyTheme(ScottPlot.WPF.WpfPlot chart)
+    {
+        ScottPlot.Color figureBackground, dataBackground, textColor, gridColor;
+
+        if (ThemeManager.CurrentTheme == "CoolBreeze")
+        {
+            figureBackground = ScottPlot.Color.FromHex("#EEF4FA");
+            dataBackground   = ScottPlot.Color.FromHex("#DAE6F0");
+            textColor        = ScottPlot.Color.FromHex("#364D61");
+            gridColor        = ScottPlot.Color.FromHex("#A8BDD0").WithAlpha(120);
+        }
+        else if (ThemeManager.HasLightBackground)
+        {
+            figureBackground = ScottPlot.Color.FromHex("#FFFFFF");
+            dataBackground   = ScottPlot.Color.FromHex("#F5F7FA");
+            textColor        = ScottPlot.Color.FromHex("#4A5568");
+            gridColor        = ScottPlot.Colors.Black.WithAlpha(20);
+        }
+        else
+        {
+            figureBackground = ScottPlot.Color.FromHex("#22252b");
+            dataBackground   = ScottPlot.Color.FromHex("#111217");
+            textColor        = ScottPlot.Color.FromHex("#9DA5B4");
+            gridColor        = ScottPlot.Colors.White.WithAlpha(40);
+        }
+
+        chart.Plot.FigureBackground.Color = figureBackground;
+        chart.Plot.DataBackground.Color = dataBackground;
+        chart.Plot.Axes.Color(textColor);
+        chart.Plot.Grid.MajorLineColor = gridColor;
+        chart.Plot.Legend.IsVisible = false;
+        chart.Plot.Axes.Margins(bottom: 0);
+        chart.Plot.Axes.Bottom.TickLabelStyle.ForeColor = textColor;
+        chart.Plot.Axes.Left.TickLabelStyle.ForeColor = textColor;
+        chart.Plot.Axes.Bottom.Label.ForeColor = textColor;
+        chart.Plot.Axes.Left.Label.ForeColor = textColor;
+
+        chart.Background = new System.Windows.Media.SolidColorBrush(
+            System.Windows.Media.Color.FromRgb(figureBackground.R, figureBackground.G, figureBackground.B));
+    }
+
+    private static void ReapplyAxisColors(ScottPlot.WPF.WpfPlot chart)
+    {
+        var textColor = ThemeManager.CurrentTheme == "CoolBreeze"
+            ? ScottPlot.Color.FromHex("#364D61")
+            : ThemeManager.HasLightBackground
+                ? ScottPlot.Color.FromHex("#4A5568")
+                : ScottPlot.Color.FromHex("#9DA5B4");
+        chart.Plot.Axes.Bottom.TickLabelStyle.ForeColor = textColor;
+        chart.Plot.Axes.Left.TickLabelStyle.ForeColor = textColor;
+        chart.Plot.Axes.Bottom.Label.ForeColor = textColor;
+        chart.Plot.Axes.Left.Label.ForeColor = textColor;
+    }
+}
diff --git a/Lite/Controls/ServerTab.xaml b/Lite/Controls/ServerTab.xaml
index daa2305..37e079c 100644
--- a/Lite/Controls/ServerTab.xaml
+++ b/Lite/Controls/ServerTab.xaml
@@ -129,30 +129,9 @@
         <TabControl Grid.Row="1" x:Name="MainTabControl" Background="{DynamicResource BackgroundBrush}"
                     BorderThickness="0" Padding="0" SelectionChanged="MainTabControl_SelectionChanged">
 
-            <!-- Overview Tab -->
+            <!-- Overview Tab — Correlated Timeline Lanes -->
             <TabItem Header="Overview">
-                <Grid Margin="8">
-                    <Grid.RowDefinitions>
-                        <RowDefinition Height="*"/>
-                        <RowDefinition Height="*"/>
-                    </Grid.RowDefinitions>
-                    <Grid.ColumnDefinitions>
-                        <ColumnDefinition Width="*"/>
-                        <ColumnDefinition Width="*"/>
-                    </Grid.ColumnDefinitions>
-                    <Border Grid.Row="0" Grid.Column="0" Margin="0,0,4,4">
-                        <ScottPlot:WpfPlot x:Name="OverviewCpuChart"/>
-                    </Border>
-                    <Border Grid.Row="0" Grid.Column="1" Margin="4,0,0,4">
-                        <ScottPlot:WpfPlot x:Name="OverviewMemoryChart"/>
-                    </Border>
-                    <Border Grid.Row="1" Grid.Column="0" Margin="0,4,4,0">
-                        <ScottPlot:WpfPlot x:Name="OverviewFileIoChart"/>
-                    </Border>
-                    <Border Grid.Row="1" Grid.Column="1" Margin="4,4,0,0">
-                        <ScottPlot:WpfPlot x:Name="OverviewWaitStatsChart"/>
-                    </Border>
-                </Grid>
+                <controls:CorrelatedTimelineLanesControl x:Name="CorrelatedLanes"/>
             </TabItem>
 
             <!-- Wait Stats Tab -->
diff --git a/Lite/Controls/ServerTab.xaml.cs b/Lite/Controls/ServerTab.xaml.cs
index f3261a5..5f6869d 100644
--- a/Lite/Controls/ServerTab.xaml.cs
+++ b/Lite/Controls/ServerTab.xaml.cs
@@ -46,10 +46,6 @@ public partial class ServerTab : UserControl
     private List<SelectableItem> _perfmonCounterItems = new();
     private Helpers.ChartHoverHelper? _waitStatsHover;
     private Helpers.ChartHoverHelper? _perfmonHover;
-    private Helpers.ChartHoverHelper? _overviewCpuHover;
-    private Helpers.ChartHoverHelper? _overviewMemoryHover;
-    private Helpers.ChartHoverHelper? _overviewFileIoHover;
-    private Helpers.ChartHoverHelper? _overviewWaitStatsHover;
     private Helpers.ChartHoverHelper? _cpuHover;
     private Helpers.ChartHoverHelper? _memoryHover;
     private Helpers.ChartHoverHelper? _tempDbHover;
@@ -203,10 +199,6 @@ public ServerTab(ServerConnection server, DuckDbInitializer duckDb, CredentialSe
         }
 
         /* Apply theme immediately so charts don't flash white before data loads */
-        ApplyTheme(OverviewCpuChart);
-        ApplyTheme(OverviewMemoryChart);
-        ApplyTheme(OverviewFileIoChart);
-        ApplyTheme(OverviewWaitStatsChart);
         ApplyTheme(WaitStatsChart);
         ApplyTheme(QueryDurationTrendChart);
         ApplyTheme(ProcDurationTrendChart);
@@ -233,10 +225,7 @@ public ServerTab(ServerConnection server, DuckDbInitializer duckDb, CredentialSe
         ApplyTheme(QueryHeatmapChart);
 
         /* Chart hover tooltips */
-        _overviewCpuHover = new Helpers.ChartHoverHelper(OverviewCpuChart, "%");
-        _overviewMemoryHover = new Helpers.ChartHoverHelper(OverviewMemoryChart, "MB");
-        _overviewFileIoHover = new Helpers.ChartHoverHelper(OverviewFileIoChart, "ms");
-        _overviewWaitStatsHover = new Helpers.ChartHoverHelper(OverviewWaitStatsChart, "ms/sec");
+        CorrelatedLanes.Initialize(_dataService, _serverId);
         _waitStatsHover = new Helpers.ChartHoverHelper(WaitStatsChart, "ms/sec");
         _perfmonHover = new Helpers.ChartHoverHelper(PerfmonChart, "");
         _cpuHover = new Helpers.ChartHoverHelper(CpuChart, "%");
@@ -325,16 +314,6 @@ public ServerTab(ServerConnection server, DuckDbInitializer duckDb, CredentialSe
         Helpers.ContextMenuHelper.SetupChartContextMenu(ProcDurationTrendChart, "Procedure_Duration_Trends");
         Helpers.ContextMenuHelper.SetupChartContextMenu(QueryStoreDurationTrendChart, "QueryStore_Duration_Trends");
         Helpers.ContextMenuHelper.SetupChartContextMenu(ExecutionCountTrendChart, "Execution_Count_Trends");
-        /* Overview chart context menus */
-        var ovCpuMenu = Helpers.ContextMenuHelper.SetupChartContextMenu(OverviewCpuChart, "Overview_CPU");
-        AddChartDrillDownMenuItem(OverviewCpuChart, ovCpuMenu, _overviewCpuHover, "Show Active Queries at This Time", OnCpuDrillDown);
-        var ovMemMenu = Helpers.ContextMenuHelper.SetupChartContextMenu(OverviewMemoryChart, "Overview_Memory");
-        AddChartDrillDownMenuItem(OverviewMemoryChart, ovMemMenu, _overviewMemoryHover, "Show Active Queries at This Time", OnMemoryDrillDown);
-        var ovIoMenu = Helpers.ContextMenuHelper.SetupChartContextMenu(OverviewFileIoChart, "Overview_FileIO");
-        AddChartDrillDownMenuItem(OverviewFileIoChart, ovIoMenu, _overviewFileIoHover, "Show Active Queries at This Time", OnCpuDrillDown);
-        var ovWaitMenu = Helpers.ContextMenuHelper.SetupChartContextMenu(OverviewWaitStatsChart, "Overview_WaitStats");
-        AddChartDrillDownMenuItem(OverviewWaitStatsChart, ovWaitMenu, _overviewWaitStatsHover, "Show Active Queries at This Time", OnCpuDrillDown);
-
         var cpuMenu = Helpers.ContextMenuHelper.SetupChartContextMenu(CpuChart, "CPU_Usage");
         AddChartDrillDownMenuItem(CpuChart, cpuMenu, _cpuHover, "Show Active Queries at This Time", OnCpuDrillDown);
         var memoryMenu = Helpers.ContextMenuHelper.SetupChartContextMenu(MemoryChart, "Memory_Usage");
@@ -1114,24 +1093,12 @@ await System.Threading.Tasks.Task.WhenAll(
     }
 
     /// <summary>Tab 3 — CPU</summary>
-    /// <summary>Tab 0 — Overview (4 charts: CPU, Memory, File I/O, Wait Stats)</summary>
+    /// <summary>Tab 0 — Overview (Correlated Timeline Lanes)</summary>
     private async System.Threading.Tasks.Task RefreshOverviewAsync(int hoursBack, DateTime? fromDate, DateTime? toDate)
     {
         try
         {
-            var cpuTask = SafeQueryAsync(() => _dataService.GetCpuUtilizationAsync(_serverId, hoursBack, fromDate, toDate));
-            var memoryTask = SafeQueryAsync(() => _dataService.GetMemoryTrendAsync(_serverId, hoursBack, fromDate, toDate));
-            var fileIoTask = SafeQueryAsync(() => _dataService.GetFileIoLatencyTrendAsync(_serverId, hoursBack, fromDate, toDate));
-
-            // Get top 5 wait types then fetch trends for each
-            var waitStats = await SafeQueryAsync(() => _dataService.GetWaitStatsAsync(_serverId, hoursBack, fromDate, toDate));
-            var topWaits = waitStats.Take(5).Select(w => w.WaitType).ToList();
-            await System.Threading.Tasks.Task.WhenAll(cpuTask, memoryTask, fileIoTask);
-
-            UpdateOverviewCpuChart(cpuTask.Result);
-            UpdateOverviewMemoryChart(memoryTask.Result);
-            UpdateOverviewFileIoChart(fileIoTask.Result);
-            await UpdateOverviewWaitStatsChartAsync(topWaits, hoursBack, fromDate, toDate);
+            await CorrelatedLanes.RefreshAsync(hoursBack, fromDate, toDate);
         }
         catch (Exception ex)
         {
@@ -1139,133 +1106,6 @@ private async System.Threading.Tasks.Task RefreshOverviewAsync(int hoursBack, Da
         }
     }
 
-    private void UpdateOverviewCpuChart(List<CpuUtilizationRow> data)
-    {
-        ClearChart(OverviewCpuChart);
-        _overviewCpuHover?.Clear();
-        ApplyTheme(OverviewCpuChart);
-
-        if (data.Count == 0) { RefreshEmptyChart(OverviewCpuChart, "CPU Utilization", "CPU %"); return; }
-
-        var times = data.Select(d => d.SampleTime.ToOADate()).ToArray();
-        var sqlCpu = data.Select(d => (double)d.SqlServerCpu).ToArray();
-
-        var plot = OverviewCpuChart.Plot.Add.Scatter(times, sqlCpu);
-        plot.LegendText = "SQL CPU %";
-        plot.Color = ScottPlot.Color.FromHex("#4FC3F7");
-        _overviewCpuHover?.Add(plot, "SQL CPU %");
-
-        OverviewCpuChart.Plot.Axes.DateTimeTicksBottom();
-        ReapplyAxisColors(OverviewCpuChart);
-        OverviewCpuChart.Plot.Title("CPU Utilization");
-        OverviewCpuChart.Plot.YLabel("CPU %");
-        OverviewCpuChart.Plot.Axes.SetLimitsY(0, 105);
-        ShowChartLegend(OverviewCpuChart);
-        OverviewCpuChart.Refresh();
-    }
-
-    private void UpdateOverviewMemoryChart(List<MemoryTrendPoint> data)
-    {
-        ClearChart(OverviewMemoryChart);
-        _overviewMemoryHover?.Clear();
-        ApplyTheme(OverviewMemoryChart);
-
-        if (data.Count == 0) { RefreshEmptyChart(OverviewMemoryChart, "Memory Utilization", "MB"); return; }
-
-        var times = data.Select(d => d.CollectionTime.AddMinutes(UtcOffsetMinutes).ToOADate()).ToArray();
-        var bufferPool = data.Select(d => d.BufferPoolMb).ToArray();
-        var grants = data.Select(d => d.TotalGrantedMb).ToArray();
-
-        var bpPlot = OverviewMemoryChart.Plot.Add.Scatter(times, bufferPool);
-        bpPlot.LegendText = "Buffer Pool";
-        bpPlot.Color = ScottPlot.Color.FromHex("#CE93D8");
-        _overviewMemoryHover?.Add(bpPlot, "Buffer Pool");
-
-        var grantPlot = OverviewMemoryChart.Plot.Add.Scatter(times, grants);
-        grantPlot.LegendText = "Memory Grants";
-        grantPlot.Color = ScottPlot.Color.FromHex("#FFB74D");
-        _overviewMemoryHover?.Add(grantPlot, "Memory Grants");
-
-        OverviewMemoryChart.Plot.Axes.DateTimeTicksBottom();
-        ReapplyAxisColors(OverviewMemoryChart);
-        OverviewMemoryChart.Plot.Title("Memory Utilization");
-        OverviewMemoryChart.Plot.YLabel("MB");
-        SetChartYLimitsWithLegendPadding(OverviewMemoryChart, 0, bufferPool.Max());
-        ShowChartLegend(OverviewMemoryChart);
-        OverviewMemoryChart.Refresh();
-    }
-
-    private void UpdateOverviewFileIoChart(List<FileIoTrendPoint> data)
-    {
-        ClearChart(OverviewFileIoChart);
-        _overviewFileIoHover?.Clear();
-        ApplyTheme(OverviewFileIoChart);
-
-        if (data.Count == 0) { RefreshEmptyChart(OverviewFileIoChart, "File I/O Latency", "ms"); return; }
-
-        // Aggregate across all databases/files per collection time
-        var grouped = data
-            .GroupBy(d => d.CollectionTime)
-            .OrderBy(g => g.Key)
-            .Select(g => new { Time = g.Key, ReadMs = g.Average(x => x.AvgReadLatencyMs), WriteMs = g.Average(x => x.AvgWriteLatencyMs) })
-            .ToList();
-
-        var times = grouped.Select(d => d.Time.AddMinutes(UtcOffsetMinutes).ToOADate()).ToArray();
-        var readMs = grouped.Select(d => d.ReadMs).ToArray();
-        var writeMs = grouped.Select(d => d.WriteMs).ToArray();
-
-        var readPlot = OverviewFileIoChart.Plot.Add.Scatter(times, readMs);
-        readPlot.LegendText = "Read ms";
-        readPlot.Color = ScottPlot.Color.FromHex("#81C784");
-        _overviewFileIoHover?.Add(readPlot, "Read ms");
-
-        var writePlot = OverviewFileIoChart.Plot.Add.Scatter(times, writeMs);
-        writePlot.LegendText = "Write ms";
-        writePlot.Color = ScottPlot.Color.FromHex("#FFB74D");
-        _overviewFileIoHover?.Add(writePlot, "Write ms");
-
-        OverviewFileIoChart.Plot.Axes.DateTimeTicksBottom();
-        ReapplyAxisColors(OverviewFileIoChart);
-        OverviewFileIoChart.Plot.Title("File I/O Latency");
-        OverviewFileIoChart.Plot.YLabel("Latency (ms)");
-        var maxVal = Math.Max(readMs.DefaultIfEmpty(0).Max(), writeMs.DefaultIfEmpty(0).Max());
-        SetChartYLimitsWithLegendPadding(OverviewFileIoChart, 0, maxVal);
-        ShowChartLegend(OverviewFileIoChart);
-        OverviewFileIoChart.Refresh();
-    }
-
-    private async System.Threading.Tasks.Task UpdateOverviewWaitStatsChartAsync(
-        List<string> topWaits, int hoursBack, DateTime? fromDate, DateTime? toDate)
-    {
-        ClearChart(OverviewWaitStatsChart);
-        _overviewWaitStatsHover?.Clear();
-        ApplyTheme(OverviewWaitStatsChart);
-
-        if (topWaits.Count == 0) { RefreshEmptyChart(OverviewWaitStatsChart, "Wait Statistics", "ms/sec"); return; }
-
-        var colors = new[] { "#4FC3F7", "#81C784", "#FFB74D", "#CE93D8", "#E57373" };
-        for (int i = 0; i < Math.Min(topWaits.Count, 5); i++)
-        {
-            var trend = await _dataService.GetWaitStatsTrendAsync(_serverId, topWaits[i], hoursBack, fromDate, toDate);
-            if (trend.Count < 2) continue;
-
-            var times = trend.Select(d => d.CollectionTime.AddMinutes(UtcOffsetMinutes).ToOADate()).ToArray();
-            var values = trend.Select(d => d.WaitTimeMsPerSecond).ToArray();
-
-            var plot = OverviewWaitStatsChart.Plot.Add.Scatter(times, values);
-            plot.LegendText = topWaits[i];
-            plot.Color = ScottPlot.Color.FromHex(colors[i]);
-            _overviewWaitStatsHover?.Add(plot, topWaits[i]);
-        }
-
-        OverviewWaitStatsChart.Plot.Axes.DateTimeTicksBottom();
-        ReapplyAxisColors(OverviewWaitStatsChart);
-        OverviewWaitStatsChart.Plot.Title("Wait Statistics");
-        OverviewWaitStatsChart.Plot.YLabel("Wait Time (ms/sec)");
-        ShowChartLegend(OverviewWaitStatsChart);
-        OverviewWaitStatsChart.Refresh();
-    }
-
     private async System.Threading.Tasks.Task RefreshCpuAsync(int hoursBack, DateTime? fromDate, DateTime? toDate)
     {
         try
@@ -3849,6 +3689,8 @@ private void OnThemeChanged(string _)
                 chart.Refresh();
             }
         }
+
+        CorrelatedLanes.ReapplyTheme();
     }
 
     private static IEnumerable<ScottPlot.WPF.WpfPlot> GetAllCharts(DependencyObject root)
@@ -5247,10 +5089,6 @@ public void DisposeChartHelpers()
     {
         _waitStatsHover?.Dispose();
         _perfmonHover?.Dispose();
-        _overviewCpuHover?.Dispose();
-        _overviewMemoryHover?.Dispose();
-        _overviewFileIoHover?.Dispose();
-        _overviewWaitStatsHover?.Dispose();
         _cpuHover?.Dispose();
         _memoryHover?.Dispose();
         _tempDbHover?.Dispose();
diff --git a/Lite/Helpers/CorrelatedCrosshairManager.cs b/Lite/Helpers/CorrelatedCrosshairManager.cs
new file mode 100644
index 0000000..da7267c
--- /dev/null
+++ b/Lite/Helpers/CorrelatedCrosshairManager.cs
@@ -0,0 +1,309 @@
+/*
+ * 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.
+ *
+ * SYNC WARNING: Dashboard has a matching copy at Dashboard/Helpers/CorrelatedCrosshairManager.cs.
+ * Changes here must be mirrored there.
+ */
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Windows;
+using System.Windows.Controls;
+using System.Windows.Controls.Primitives;
+using System.Windows.Input;
+using System.Windows.Media;
+using PerformanceMonitorLite.Services;
+
+namespace PerformanceMonitorLite.Helpers;
+
+/// <summary>
+/// Synchronizes vertical crosshair lines across multiple ScottPlot charts.
+/// When the user hovers over any lane, all lanes show a VLine at the same X (time)
+/// coordinate and value labels update to show each lane's value at that time.
+/// </summary>
+internal sealed class CorrelatedCrosshairManager : IDisposable
+{
+    private readonly List<LaneInfo> _lanes = new();
+    private readonly Popup _tooltip;
+    private readonly TextBlock _tooltipText;
+    private DateTime _lastUpdate;
+    private bool _isRefreshing;
+
+    public CorrelatedCrosshairManager()
+    {
+        _tooltipText = new TextBlock
+        {
+            Foreground = new SolidColorBrush(Color.FromRgb(0xE0, 0xE0, 0xE0)),
+            FontSize = 13
+        };
+
+        _tooltip = new Popup
+        {
+            Placement = PlacementMode.Relative,
+            IsHitTestVisible = false,
+            AllowsTransparency = true,
+            Child = new Border
+            {
+                Background = new SolidColorBrush(Color.FromRgb(0x33, 0x33, 0x33)),
+                BorderBrush = new SolidColorBrush(Color.FromRgb(0x55, 0x55, 0x55)),
+                BorderThickness = new Thickness(1),
+                CornerRadius = new CornerRadius(3),
+                Padding = new Thickness(8, 4, 8, 4),
+                Child = _tooltipText
+            }
+        };
+    }
+
+    /// <summary>
+    /// Registers a chart lane for crosshair synchronization.
+    /// </summary>
+    public void AddLane(ScottPlot.WPF.WpfPlot chart, string label, string unit, TextBlock valueLabel)
+    {
+        var lane = new LaneInfo
+        {
+            Chart = chart,
+            Label = label,
+            Unit = unit,
+            ValueLabel = valueLabel
+        };
+
+        chart.MouseMove += (s, e) => OnMouseMove(lane, e);
+        chart.MouseLeave += (s, e) => OnMouseLeave();
+
+        _lanes.Add(lane);
+    }
+
+    /// <summary>
+    /// Sets a single data series for a lane (most lanes have one series).
+    /// </summary>
+    public void SetLaneData(ScottPlot.WPF.WpfPlot chart, double[] times, double[] values,
+        bool isEventBased = false)
+    {
+        var lane = _lanes.Find(l => l.Chart == chart);
+        if (lane == null) return;
+
+        lane.Series.Clear();
+        lane.Series.Add(new DataSeries
+        {
+            Name = lane.Label,
+            Times = times,
+            Values = values,
+            IsEventBased = isEventBased
+        });
+    }
+
+    /// <summary>
+    /// Adds a named data series to a lane (for lanes with multiple overlaid series).
+    /// Call SetLaneData first to clear, then AddLaneSeries for additional series.
+    /// </summary>
+    public void AddLaneSeries(ScottPlot.WPF.WpfPlot chart, string name, string unit,
+        double[] times, double[] values, bool isEventBased = false)
+    {
+        var lane = _lanes.Find(l => l.Chart == chart);
+        if (lane == null) return;
+
+        lane.Series.Add(new DataSeries
+        {
+            Name = name,
+            Unit = unit,
+            Times = times,
+            Values = values,
+            IsEventBased = isEventBased
+        });
+    }
+
+    /// <summary>
+    /// Clears data and VLines. Call before re-populating charts.
+    /// </summary>
+    public void PrepareForRefresh()
+    {
+        _isRefreshing = true;
+        _tooltip.IsOpen = false;
+        foreach (var lane in _lanes)
+        {
+            lane.Series.Clear();
+            lane.VLine = null;
+        }
+    }
+
+    /// <summary>
+    /// Creates fresh VLine plottables on each lane's chart.
+    /// Must be called AFTER chart data is populated.
+    /// </summary>
+    public void ReattachVLines()
+    {
+        foreach (var lane in _lanes)
+        {
+            var vline = lane.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;
+        }
+        _isRefreshing = false;
+    }
+
+    private void OnMouseMove(LaneInfo sourceLane, MouseEventArgs e)
+    {
+        if (_isRefreshing || sourceLane.VLine == null) return;
+
+        var now = DateTime.UtcNow;
+        if ((now - _lastUpdate).TotalMilliseconds < 16) return;
+        _lastUpdate = now;
+
+        var pos = e.GetPosition(sourceLane.Chart);
+        var dpi = VisualTreeHelper.GetDpi(sourceLane.Chart);
+        var pixel = new ScottPlot.Pixel(
+            (float)(pos.X * dpi.DpiScaleX),
+            (float)(pos.Y * dpi.DpiScaleY));
+        var mouseCoords = sourceLane.Chart.Plot.GetCoordinates(pixel);
+        double xValue = mouseCoords.X;
+
+        var tooltipLines = new List<string>();
+        var time = DateTime.FromOADate(xValue);
+        var displayTime = ServerTimeHelper.ConvertForDisplay(time, ServerTimeHelper.CurrentDisplayMode);
+        tooltipLines.Add(displayTime.ToString("yyyy-MM-dd HH:mm:ss"));
+
+        foreach (var lane in _lanes)
+        {
+            if (lane.VLine == null) continue;
+
+            lane.VLine.IsVisible = true;
+            lane.VLine.X = xValue;
+
+            if (lane.Series.Count == 1)
+            {
+                // Single series — use lane label and unit
+                var series = lane.Series[0];
+                double? value = FindNearestValue(series, xValue);
+
+                if (value.HasValue)
+                {
+                    lane.ValueLabel.Text = $"{value.Value:N1} {lane.Unit}";
+                    tooltipLines.Add($"{lane.Label}: {value.Value:N1} {lane.Unit}");
+                }
+                else
+                {
+                    lane.ValueLabel.Text = "";
+                    tooltipLines.Add($"{lane.Label}: —");
+                }
+            }
+            else if (lane.Series.Count > 1)
+            {
+                // Multiple series — show each with its own name
+                var valueParts = new List<string>();
+                foreach (var series in lane.Series)
+                {
+                    double? value = FindNearestValue(series, xValue);
+                    string unit = series.Unit ?? lane.Unit;
+                    if (value.HasValue)
+                    {
+                        valueParts.Add($"{value.Value:N0}");
+                        tooltipLines.Add($"{series.Name}: {value.Value:N0} {unit}");
+                    }
+                    else
+                    {
+                        tooltipLines.Add($"{series.Name}: —");
+                    }
+                }
+                lane.ValueLabel.Text = valueParts.Count > 0 ? string.Join("/", valueParts) : "";
+            }
+            else
+            {
+                lane.ValueLabel.Text = "";
+                tooltipLines.Add($"{lane.Label}: —");
+            }
+
+            lane.Chart.Refresh();
+        }
+
+        _tooltipText.Text = string.Join("\n", tooltipLines);
+        _tooltip.PlacementTarget = sourceLane.Chart;
+        _tooltip.HorizontalOffset = pos.X + 15;
+        _tooltip.VerticalOffset = pos.Y + 15;
+        _tooltip.IsOpen = true;
+    }
+
+    private static double? FindNearestValue(DataSeries series, double targetX)
+    {
+        if (series.Times == null || series.Values == null || series.Times.Length == 0)
+            return null;
+
+        var times = series.Times;
+        var values = series.Values;
+
+        int lo = 0, hi = times.Length - 1;
+        while (lo < hi)
+        {
+            int mid = (lo + hi) / 2;
+            if (times[mid] < targetX)
+                lo = mid + 1;
+            else
+                hi = mid;
+        }
+
+        int best = lo;
+        if (lo > 0 && Math.Abs(times[lo - 1] - targetX) < Math.Abs(times[lo] - targetX))
+            best = lo - 1;
+
+        double val = values[best];
+        if (double.IsNaN(val)) return null;
+
+        if (series.IsEventBased)
+        {
+            double oneMinute = 1.0 / 1440.0;
+            if (Math.Abs(times[best] - targetX) > oneMinute)
+                return 0;
+        }
+
+        return val;
+    }
+
+    private void OnMouseLeave()
+    {
+        _tooltip.IsOpen = false;
+        foreach (var lane in _lanes)
+        {
+            if (lane.VLine != null)
+                lane.VLine.IsVisible = false;
+            lane.ValueLabel.Text = "";
+            lane.Chart.Refresh();
+        }
+    }
+
+    public void Dispose()
+    {
+        _tooltip.IsOpen = false;
+        foreach (var lane in _lanes)
+        {
+            lane.Series.Clear();
+            lane.VLine = null;
+        }
+        _lanes.Clear();
+    }
+
+    private class DataSeries
+    {
+        public string Name { get; set; } = "";
+        public string? Unit { get; set; }
+        public double[]? Times { get; set; }
+        public double[]? Values { get; set; }
+        public bool IsEventBased { get; set; }
+    }
+
+    private class LaneInfo
+    {
+        public ScottPlot.WPF.WpfPlot Chart { get; set; } = null!;
+        public string Label { get; set; } = "";
+        public string Unit { get; set; } = "";
+        public ScottPlot.Plottables.VerticalLine? VLine { get; set; }
+        public TextBlock ValueLabel { get; set; } = null!;
+        public List<DataSeries> Series { get; set; } = new();
+    }
+}
diff --git a/Lite/Services/LocalDataService.Blocking.cs b/Lite/Services/LocalDataService.Blocking.cs
index ee9037c..73556eb 100644
--- a/Lite/Services/LocalDataService.Blocking.cs
+++ b/Lite/Services/LocalDataService.Blocking.cs
@@ -564,7 +564,7 @@ GROUP BY DATE_TRUNC('minute', event_time)
     }
 
     /// <summary>
-    /// Gets deadlock trend (count of deadlocks per hour bucket).
+    /// Gets deadlock trend (count of deadlocks per minute bucket).
     /// </summary>
     public async Task<List<TrendPoint>> GetDeadlockTrendAsync(int serverId, int hoursBack = 24, DateTime? fromDate = null, DateTime? toDate = null)
     {
@@ -579,13 +579,13 @@ public async Task<List<TrendPoint>> GetDeadlockTrendAsync(int serverId, int hour
     deadlock_count
 FROM (
     SELECT
-        DATE_TRUNC('hour', deadlock_time) AS bucket,
+        DATE_TRUNC('minute', deadlock_time) AS bucket,
         COUNT(*) AS deadlock_count
     FROM v_deadlocks
     WHERE server_id = $1
     AND   collection_time >= $2
     AND   collection_time <= $3
-    GROUP BY DATE_TRUNC('hour', deadlock_time)
+    GROUP BY DATE_TRUNC('minute', deadlock_time)
 ) sub
 ORDER BY bucket";
 
diff --git a/Lite/Services/LocalDataService.WaitStats.cs b/Lite/Services/LocalDataService.WaitStats.cs
index 7ebca42..6fef57a 100644
--- a/Lite/Services/LocalDataService.WaitStats.cs
+++ b/Lite/Services/LocalDataService.WaitStats.cs
@@ -150,6 +150,55 @@ FROM raw
         return items;
     }
 
+    /// <summary>
+    /// Gets total wait time trend across all wait types as a single aggregated time-series.
+    /// Used by the correlated timeline lanes for a single-line wait stats overview.
+    /// </summary>
+    public async Task<List<WaitStatsTrendPoint>> GetTotalWaitTrendAsync(int serverId, int hoursBack = 24, DateTime? fromDate = null, DateTime? toDate = null)
+    {
+        using var _q = TimeQuery("GetTotalWaitTrendAsync", "wait_stats total trend");
+        using var connection = await OpenConnectionAsync();
+        using var command = connection.CreateCommand();
+
+        var (startTime, endTime) = GetTimeRange(hoursBack, fromDate, toDate);
+
+        command.CommandText = @"
+WITH per_collection AS
+(
+    SELECT
+        collection_time,
+        SUM(delta_wait_time_ms) AS total_delta_ms,
+        date_diff('second', LAG(collection_time) OVER (ORDER BY collection_time), collection_time) AS interval_seconds
+    FROM v_wait_stats
+    WHERE server_id = $1
+    AND   collection_time >= $2
+    AND   collection_time <= $3
+    GROUP BY collection_time
+)
+SELECT
+    collection_time,
+    CASE WHEN interval_seconds > 0 THEN CAST(total_delta_ms AS DOUBLE) / interval_seconds ELSE 0 END AS wait_time_ms_per_second
+FROM per_collection
+ORDER BY collection_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<WaitStatsTrendPoint>();
+        using var reader = await command.ExecuteReaderAsync();
+        while (await reader.ReadAsync())
+        {
+            items.Add(new WaitStatsTrendPoint
+            {
+                CollectionTime = reader.GetDateTime(0),
+                WaitTimeMsPerSecond = reader.IsDBNull(1) ? 0 : reader.GetDouble(1)
+            });
+        }
+
+        return items;
+    }
+
     /// <summary>
     /// Gets the latest poison wait deltas for alert checking.
     /// Returns entries where delta_waiting_tasks > 0 with computed avg ms per wait.

From b6c9f3ed4ace0c4be5291acade6ece449d36d61e Mon Sep 17 00:00:00 2001
From: Erik Darling <2136037+erikdarlingdata@users.noreply.github.com>
Date: Mon, 6 Apr 2026 12:32:11 -0400
Subject: [PATCH 14/30] Port correlated timeline lanes to Dashboard (#688)

Ports the Lite correlated lanes feature to the Dashboard app:
- Replaces Server Trends 2x2 grid with 5 synchronized lanes
- Adds GetTotalWaitStatsTrendAsync (aggregate wait ms/sec trend)
- Adds GetDeadlockTrendAsync (per-minute deadlock counts)
- All queries read from existing collected data, no new collectors

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
---
 .../CorrelatedTimelineLanesControl.xaml       | 100 +++++
 .../CorrelatedTimelineLanesControl.xaml.cs    | 335 +++++++++++++++
 .../Controls/ResourceMetricsContent.xaml      |  68 +--
 .../Controls/ResourceMetricsContent.xaml.cs   | 386 +-----------------
 .../Helpers/CorrelatedCrosshairManager.cs     | 309 ++++++++++++++
 .../DatabaseService.QueryPerformance.cs       |  62 +++
 .../DatabaseService.ResourceMetrics.cs        | 171 ++++++++
 7 files changed, 983 insertions(+), 448 deletions(-)
 create mode 100644 Dashboard/Controls/CorrelatedTimelineLanesControl.xaml
 create mode 100644 Dashboard/Controls/CorrelatedTimelineLanesControl.xaml.cs
 create mode 100644 Dashboard/Helpers/CorrelatedCrosshairManager.cs

diff --git a/Dashboard/Controls/CorrelatedTimelineLanesControl.xaml b/Dashboard/Controls/CorrelatedTimelineLanesControl.xaml
new file mode 100644
index 0000000..46b6815
--- /dev/null
+++ b/Dashboard/Controls/CorrelatedTimelineLanesControl.xaml
@@ -0,0 +1,100 @@
+<UserControl x:Class="PerformanceMonitorDashboard.Controls.CorrelatedTimelineLanesControl"
+             xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
+             xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
+             xmlns:ScottPlot="clr-namespace:ScottPlot.WPF;assembly=ScottPlot.WPF">
+
+    <Grid Margin="8">
+        <Grid.RowDefinitions>
+            <!-- 5 lanes, equal height -->
+            <RowDefinition Height="*"/>
+            <RowDefinition Height="*"/>
+            <RowDefinition Height="*"/>
+            <RowDefinition Height="*"/>
+            <RowDefinition Height="*"/>
+        </Grid.RowDefinitions>
+
+        <!-- Lane 1: CPU -->
+        <Grid Grid.Row="0" Margin="0,0,0,2">
+            <Grid.ColumnDefinitions>
+                <ColumnDefinition Width="100"/>
+                <ColumnDefinition Width="*"/>
+                <ColumnDefinition Width="80"/>
+            </Grid.ColumnDefinitions>
+            <TextBlock Grid.Column="0" Text="CPU %" VerticalAlignment="Center"
+                       FontSize="12" FontWeight="SemiBold"
+                       Foreground="{DynamicResource ForegroundBrush}" Margin="4,0"/>
+            <ScottPlot:WpfPlot Grid.Column="1" x:Name="CpuChart"/>
+            <TextBlock Grid.Column="2" x:Name="CpuValueLabel" VerticalAlignment="Center"
+                       HorizontalAlignment="Right" FontSize="11"
+                       Foreground="{DynamicResource ForegroundBrush}" Margin="4,0"/>
+        </Grid>
+
+        <!-- Lane 2: Wait Stats -->
+        <Grid Grid.Row="1" Margin="0,2,0,2">
+            <Grid.ColumnDefinitions>
+                <ColumnDefinition Width="100"/>
+                <ColumnDefinition Width="*"/>
+                <ColumnDefinition Width="80"/>
+            </Grid.ColumnDefinitions>
+            <TextBlock Grid.Column="0" Text="Wait ms/sec" VerticalAlignment="Center"
+                       FontSize="12" FontWeight="SemiBold"
+                       Foreground="{DynamicResource ForegroundBrush}" Margin="4,0"/>
+            <ScottPlot:WpfPlot Grid.Column="1" x:Name="WaitStatsChart"/>
+            <TextBlock Grid.Column="2" x:Name="WaitStatsValueLabel" VerticalAlignment="Center"
+                       HorizontalAlignment="Right" FontSize="11"
+                       Foreground="{DynamicResource ForegroundBrush}" Margin="4,0"/>
+        </Grid>
+
+        <!-- Lane 3: Blocking -->
+        <Grid Grid.Row="2" Margin="0,2,0,2">
+            <Grid.ColumnDefinitions>
+                <ColumnDefinition Width="100"/>
+                <ColumnDefinition Width="*"/>
+                <ColumnDefinition Width="80"/>
+            </Grid.ColumnDefinitions>
+            <TextBlock Grid.Column="0" VerticalAlignment="Center"
+                       FontSize="12" FontWeight="SemiBold"
+                       Foreground="{DynamicResource ForegroundBrush}" Margin="4,0">
+                <Run Text="Blocking &amp;"/>
+                <LineBreak/>
+                <Run Text="Deadlocking"/>
+            </TextBlock>
+            <ScottPlot:WpfPlot Grid.Column="1" x:Name="BlockingChart"/>
+            <TextBlock Grid.Column="2" x:Name="BlockingValueLabel" VerticalAlignment="Center"
+                       HorizontalAlignment="Right" FontSize="11"
+                       Foreground="{DynamicResource ForegroundBrush}" Margin="4,0"/>
+        </Grid>
+
+        <!-- Lane 4: Memory -->
+        <Grid Grid.Row="3" Margin="0,2,0,2">
+            <Grid.ColumnDefinitions>
+                <ColumnDefinition Width="100"/>
+                <ColumnDefinition Width="*"/>
+                <ColumnDefinition Width="80"/>
+            </Grid.ColumnDefinitions>
+            <TextBlock Grid.Column="0" Text="Memory MB" VerticalAlignment="Center"
+                       FontSize="12" FontWeight="SemiBold"
+                       Foreground="{DynamicResource ForegroundBrush}" Margin="4,0"/>
+            <ScottPlot:WpfPlot Grid.Column="1" x:Name="MemoryChart"/>
+            <TextBlock Grid.Column="2" x:Name="MemoryValueLabel" VerticalAlignment="Center"
+                       HorizontalAlignment="Right" FontSize="11"
+                       Foreground="{DynamicResource ForegroundBrush}" Margin="4,0"/>
+        </Grid>
+
+        <!-- Lane 5: File I/O -->
+        <Grid Grid.Row="4" Margin="0,2,0,0">
+            <Grid.ColumnDefinitions>
+                <ColumnDefinition Width="100"/>
+                <ColumnDefinition Width="*"/>
+                <ColumnDefinition Width="80"/>
+            </Grid.ColumnDefinitions>
+            <TextBlock Grid.Column="0" Text="I/O Latency" VerticalAlignment="Center"
+                       FontSize="12" FontWeight="SemiBold"
+                       Foreground="{DynamicResource ForegroundBrush}" Margin="4,0"/>
+            <ScottPlot:WpfPlot Grid.Column="1" x:Name="FileIoChart"/>
+            <TextBlock Grid.Column="2" x:Name="FileIoValueLabel" VerticalAlignment="Center"
+                       HorizontalAlignment="Right" FontSize="11"
+                       Foreground="{DynamicResource ForegroundBrush}" Margin="4,0"/>
+        </Grid>
+    </Grid>
+</UserControl>
diff --git a/Dashboard/Controls/CorrelatedTimelineLanesControl.xaml.cs b/Dashboard/Controls/CorrelatedTimelineLanesControl.xaml.cs
new file mode 100644
index 0000000..94aa429
--- /dev/null
+++ b/Dashboard/Controls/CorrelatedTimelineLanesControl.xaml.cs
@@ -0,0 +1,335 @@
+/*
+ * Copyright (c) 2026 Erik Darling, Darling Data LLC
+ *
+ * This file is part of the SQL Server Performance Monitor Dashboard.
+ *
+ * Licensed under the MIT License. See LICENSE file in the project root for full license information.
+ *
+ * SYNC WARNING: Lite has a matching copy at Lite/Controls/CorrelatedTimelineLanesControl.xaml.cs.
+ * Changes here must be mirrored there.
+ */
+
+using System;
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.Linq;
+using System.Threading.Tasks;
+using System.Windows;
+using System.Windows.Controls;
+using PerformanceMonitorDashboard.Helpers;
+using PerformanceMonitorDashboard.Services;
+
+namespace PerformanceMonitorDashboard.Controls;
+
+public partial class CorrelatedTimelineLanesControl : UserControl
+{
+    private DatabaseService? _dataService;
+    private CorrelatedCrosshairManager? _crosshairManager;
+    private bool _isRefreshing;
+
+    public CorrelatedTimelineLanesControl()
+    {
+        InitializeComponent();
+        Unloaded += (_, _) => _crosshairManager?.Dispose();
+    }
+
+    /// <summary>
+    /// Initializes the control with the data service.
+    /// Must be called before RefreshAsync.
+    /// </summary>
+    public void Initialize(DatabaseService dataService)
+    {
+        _dataService = dataService;
+
+        var charts = new[] { CpuChart, WaitStatsChart, BlockingChart, MemoryChart, FileIoChart };
+        foreach (var chart in charts)
+        {
+            TabHelpers.ApplyThemeToChart(chart);
+            // Disable zoom/pan/drag but keep mouse events for crosshair
+            chart.UserInputProcessor.UserActionResponses.Clear();
+        }
+
+        _crosshairManager = new CorrelatedCrosshairManager();
+        _crosshairManager.AddLane(CpuChart, "CPU", "%", CpuValueLabel);
+        _crosshairManager.AddLane(WaitStatsChart, "Wait Stats", "ms/sec", WaitStatsValueLabel);
+        _crosshairManager.AddLane(BlockingChart, "Blocking", "events", BlockingValueLabel);
+        _crosshairManager.AddLane(MemoryChart, "Memory", "MB", MemoryValueLabel);
+        _crosshairManager.AddLane(FileIoChart, "I/O Latency", "ms", FileIoValueLabel);
+    }
+
+    /// <summary>
+    /// Refreshes all lane data for the given time range.
+    /// </summary>
+    public async Task RefreshAsync(int hoursBack, DateTime? fromDate, DateTime? toDate)
+    {
+        if (_dataService == null || _isRefreshing) return;
+        _isRefreshing = true;
+
+        try
+        {
+            _crosshairManager?.PrepareForRefresh();
+
+            var cpuTask = _dataService.GetCpuUtilizationAsync(hoursBack, fromDate, toDate);
+            var waitTask = _dataService.GetTotalWaitStatsTrendAsync(hoursBack, fromDate, toDate);
+            var blockingTask = _dataService.GetBlockedSessionTrendAsync(hoursBack, fromDate, toDate);
+            var deadlockTask = _dataService.GetDeadlockTrendAsync(hoursBack, fromDate, toDate);
+            var memoryTask = _dataService.GetMemoryStatsAsync(hoursBack, fromDate, toDate);
+            var fileIoTask = _dataService.GetFileIoLatencyTimeSeriesAsync(false, hoursBack, fromDate, toDate);
+
+            try
+            {
+                await Task.WhenAll(cpuTask, waitTask, blockingTask, deadlockTask, memoryTask, fileIoTask);
+            }
+            catch (Exception ex)
+            {
+                Debug.WriteLine($"CorrelatedLanes: Data fetch failed: {ex.Message}");
+            }
+
+            if (cpuTask.IsCompletedSuccessfully)
+                UpdateLane(CpuChart, "CPU %",
+                    cpuTask.Result.Select(d => (d.SampleTime.ToOADate(), (double)d.SqlServerCpuUtilization)).ToList(),
+                    "#4FC3F7", 0, 105);
+            else
+                ShowEmpty(CpuChart, "CPU %");
+
+            if (waitTask.IsCompletedSuccessfully)
+                UpdateLane(WaitStatsChart, "Wait ms/sec",
+                    waitTask.Result.Select(d => (d.CollectionTime.ToOADate(), (double)d.WaitTimeMsPerSecond)).ToList(),
+                    "#FFB74D");
+            else
+                ShowEmpty(WaitStatsChart, "Wait ms/sec");
+
+            try
+            {
+                var blockingData = blockingTask.IsCompletedSuccessfully
+                    ? blockingTask.Result
+                        .GroupBy(d => d.CollectionTime)
+                        .OrderBy(g => g.Key)
+                        .Select(g => (g.Key.ToOADate(), (double)g.Sum(x => x.BlockedCount)))
+                        .ToList()
+                    : new List<(double, double)>();
+                var deadlockData = deadlockTask.IsCompletedSuccessfully
+                    ? deadlockTask.Result
+                        .Select(d => (d.CollectionTime.ToOADate(), (double)d.BlockedCount))
+                        .ToList()
+                    : new List<(double, double)>();
+                UpdateBlockingLane(blockingData, deadlockData);
+            }
+            catch (Exception ex)
+            {
+                Debug.WriteLine($"CorrelatedLanes: Blocking lane failed: {ex}");
+                ShowEmpty(BlockingChart, "Blocking & Deadlocking");
+            }
+
+            if (memoryTask.IsCompletedSuccessfully)
+                UpdateLane(MemoryChart, "Memory MB",
+                    memoryTask.Result.Select(d => (d.CollectionTime.ToOADate(), (double)d.TotalMemoryMb)).ToList(),
+                    "#CE93D8");
+            else
+                ShowEmpty(MemoryChart, "Memory MB");
+
+            if (fileIoTask.IsCompletedSuccessfully)
+            {
+                var ioGrouped = fileIoTask.Result
+                    .GroupBy(d => d.CollectionTime)
+                    .OrderBy(g => g.Key)
+                    .Select(g => (g.Key.ToOADate(), (double)g.Average(x => x.ReadLatencyMs)))
+                    .ToList();
+                UpdateLane(FileIoChart, "I/O ms", ioGrouped, "#81C784");
+            }
+            else
+                ShowEmpty(FileIoChart, "I/O ms");
+
+            _crosshairManager?.ReattachVLines();
+            SyncXAxes(hoursBack, fromDate, toDate);
+        }
+        finally
+        {
+            _isRefreshing = false;
+        }
+    }
+
+    private void UpdateBlockingLane(List<(double Time, double Value)> blockingData,
+        List<(double Time, double Value)> deadlockData)
+    {
+        ClearChart(BlockingChart);
+        TabHelpers.ApplyThemeToChart(BlockingChart);
+
+        // Register blocking and deadlock as separate named series for the tooltip
+        var blockTimes = blockingData.Select(d => d.Time).ToArray();
+        var blockValues = blockingData.Select(d => d.Value).ToArray();
+        var deadTimes = deadlockData.Select(d => d.Time).ToArray();
+        var deadValues = deadlockData.Select(d => d.Value).ToArray();
+
+        // First series clears any previous data
+        _crosshairManager?.SetLaneData(BlockingChart, blockTimes, blockValues, isEventBased: true);
+        // Rename the auto-created series and add the second
+        _crosshairManager?.AddLaneSeries(BlockingChart, "Deadlocks", "events",
+            deadTimes, deadValues, isEventBased: true);
+
+        if (blockingData.Count == 0 && deadlockData.Count == 0)
+        {
+            ShowEmpty(BlockingChart, "Block/Dead");
+            return;
+        }
+
+        double barWidth = 30.0 / 86400.0;
+        double maxCount = 0;
+
+        // Blocking bars — red
+        if (blockingData.Count > 0)
+        {
+            var bars = blockingData.Select(d => new ScottPlot.Bar
+            {
+                Position = d.Time,
+                Value = d.Value,
+                Size = barWidth,
+                FillColor = ScottPlot.Color.FromHex("#E57373"),
+                LineWidth = 0
+            }).ToArray();
+            BlockingChart.Plot.Add.Bars(bars);
+            maxCount = Math.Max(maxCount, blockingData.Max(d => d.Value));
+        }
+
+        // Deadlock bars — yellow/amber, slightly narrower so both are visible
+        if (deadlockData.Count > 0)
+        {
+            var bars = deadlockData.Select(d => new ScottPlot.Bar
+            {
+                Position = d.Time,
+                Value = d.Value,
+                Size = barWidth * 0.6,
+                FillColor = ScottPlot.Color.FromHex("#FFD54F"),
+                LineWidth = 0
+            }).ToArray();
+            BlockingChart.Plot.Add.Bars(bars);
+            maxCount = Math.Max(maxCount, deadlockData.Max(d => d.Value));
+        }
+
+        BlockingChart.Plot.Axes.DateTimeTicksBottom();
+        BlockingChart.Plot.Axes.Bottom.TickLabelStyle.IsVisible = false;
+        TabHelpers.ReapplyAxisColors(BlockingChart);
+
+        BlockingChart.Plot.Title("");
+        BlockingChart.Plot.YLabel("");
+        BlockingChart.Plot.Legend.IsVisible = false;
+        BlockingChart.Plot.Axes.Margins(bottom: 0);
+        BlockingChart.Plot.Axes.SetLimitsY(0, Math.Max(maxCount * 1.3, 2));
+
+        BlockingChart.Refresh();
+    }
+
+    private void UpdateLane(ScottPlot.WPF.WpfPlot chart, string title,
+        List<(double Time, double Value)> data, string colorHex,
+        double? yMin = null, double? yMax = null)
+    {
+        ClearChart(chart);
+        TabHelpers.ApplyThemeToChart(chart);
+
+        if (data.Count == 0)
+        {
+            ShowEmpty(chart, title);
+            return;
+        }
+
+        var times = data.Select(d => d.Time).ToArray();
+        var values = data.Select(d => d.Value).ToArray();
+
+        var scatter = chart.Plot.Add.Scatter(times, values);
+        scatter.Color = ScottPlot.Color.FromHex(colorHex);
+        scatter.MarkerSize = 0;
+        scatter.LineWidth = 1.5f;
+        scatter.LegendText = title;
+        scatter.ConnectStyle = ScottPlot.ConnectStyle.Straight;
+
+        _crosshairManager?.SetLaneData(chart, times, values);
+
+        chart.Plot.Axes.DateTimeTicksBottom();
+        // Hide bottom tick labels on all lanes except the last (File I/O)
+        if (chart != FileIoChart)
+            chart.Plot.Axes.Bottom.TickLabelStyle.IsVisible = false;
+
+        TabHelpers.ReapplyAxisColors(chart);
+
+        // Compact layout: hide Y label, minimize title, no legend
+        chart.Plot.Title("");
+        chart.Plot.YLabel("");
+        chart.Plot.Legend.IsVisible = false;
+        chart.Plot.Axes.Margins(bottom: 0);
+
+        if (yMin.HasValue && yMax.HasValue)
+            chart.Plot.Axes.SetLimitsY(yMin.Value, yMax.Value);
+        else
+        {
+            var maxVal = data.Max(d => d.Value);
+            var minVal = data.Min(d => d.Value);
+            var padding = Math.Max((maxVal - minVal) * 0.1, 1);
+            chart.Plot.Axes.SetLimitsY(Math.Max(0, minVal - padding), maxVal + padding);
+        }
+
+        chart.Refresh();
+    }
+
+    /// <summary>
+    /// Sets identical X-axis limits across all lanes.
+    /// </summary>
+    private void SyncXAxes(int hoursBack, DateTime? fromDate, DateTime? toDate)
+    {
+        DateTime xStart, xEnd;
+        if (fromDate.HasValue && toDate.HasValue)
+        {
+            xStart = fromDate.Value;
+            xEnd = toDate.Value;
+        }
+        else
+        {
+            xEnd = ServerTimeHelper.ServerNow;
+            xStart = xEnd.AddHours(-hoursBack);
+        }
+
+        double xMin = xStart.ToOADate();
+        double xMax = xEnd.ToOADate();
+
+        var charts = new[] { CpuChart, WaitStatsChart, BlockingChart, MemoryChart, FileIoChart };
+        foreach (var chart in charts)
+        {
+            chart.Plot.Axes.SetLimitsX(xMin, xMax);
+            chart.Refresh();
+        }
+    }
+
+    private static void ClearChart(ScottPlot.WPF.WpfPlot chart)
+    {
+        chart.Reset();
+        chart.Plot.Clear();
+    }
+
+    private static void ShowEmpty(ScottPlot.WPF.WpfPlot chart, string title)
+    {
+        TabHelpers.ReapplyAxisColors(chart);
+        var text = chart.Plot.Add.Text($"{title}\nNo Data", 0, 0);
+        text.LabelFontColor = ScottPlot.Color.FromHex("#888888");
+        text.LabelFontSize = 12;
+        text.LabelAlignment = ScottPlot.Alignment.MiddleCenter;
+        chart.Plot.HideGrid();
+        chart.Plot.Axes.SetLimitsX(-1, 1);
+        chart.Plot.Axes.SetLimitsY(-1, 1);
+        chart.Plot.Axes.Bottom.TickGenerator = new ScottPlot.TickGenerators.EmptyTickGenerator();
+        chart.Plot.Axes.Left.TickGenerator = new ScottPlot.TickGenerators.EmptyTickGenerator();
+        chart.Plot.Legend.IsVisible = false;
+        chart.Refresh();
+    }
+
+    /// <summary>
+    /// Reapplies theme to all lane charts (call on theme change).
+    /// </summary>
+    public void ReapplyTheme()
+    {
+        var charts = new[] { CpuChart, WaitStatsChart, BlockingChart, MemoryChart, FileIoChart };
+        foreach (var chart in charts)
+        {
+            TabHelpers.ApplyThemeToChart(chart);
+            chart.Refresh();
+        }
+    }
+}
diff --git a/Dashboard/Controls/ResourceMetricsContent.xaml b/Dashboard/Controls/ResourceMetricsContent.xaml
index 03142ca..4067d08 100644
--- a/Dashboard/Controls/ResourceMetricsContent.xaml
+++ b/Dashboard/Controls/ResourceMetricsContent.xaml
@@ -4,6 +4,7 @@
              xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
              xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
              xmlns:ScottPlot="clr-namespace:ScottPlot.WPF;assembly=ScottPlot.WPF"
+             xmlns:local="clr-namespace:PerformanceMonitorDashboard.Controls"
              mc:Ignorable="d"
              d:DesignHeight="600" d:DesignWidth="1200">
     <UserControl.Resources>
@@ -25,72 +26,9 @@
     </UserControl.Resources>
 
     <TabControl x:Name="SubTabControl" TabStripPlacement="Top" Margin="0,5,0,0">
-        <!-- Server Trends Sub-Tab -->
+        <!-- Server Trends Sub-Tab — Correlated Timeline Lanes -->
         <TabItem Header="Server Trends">
-            <!-- 2x2 Chart Grid -->
-            <Grid Margin="5">
-                <Grid.RowDefinitions>
-                    <RowDefinition Height="*"/>
-                    <RowDefinition Height="*"/>
-                </Grid.RowDefinitions>
-                <Grid.ColumnDefinitions>
-                    <ColumnDefinition Width="*"/>
-                    <ColumnDefinition Width="*"/>
-                </Grid.ColumnDefinitions>
-
-                <!-- CPU Utilization Chart (Top Left) -->
-                <Border Grid.Row="0" Grid.Column="0" BorderBrush="{DynamicResource BorderBrush}" BorderThickness="1" Margin="5">
-                    <Grid>
-                        <Grid.RowDefinitions>
-                            <RowDefinition Height="Auto"/>
-                            <RowDefinition Height="*"/>
-                            <RowDefinition Height="Auto"/>
-                        </Grid.RowDefinitions>
-                        <TextBlock Text="CPU Utilization (%)" FontWeight="Bold" FontSize="14" Margin="10,5" Foreground="{DynamicResource ForegroundBrush}"/>
-                        <ScottPlot:WpfPlot Grid.Row="1" x:Name="ServerUtilTrendsCpuChart" Margin="5"/>
-                        <TextBlock Grid.Row="2" x:Name="CpuSchedulerStatusText"
-                                   Margin="10,0,10,5" FontSize="11"
-                                   HorizontalAlignment="Center"
-                                   Foreground="{DynamicResource ForegroundBrush}"/>
-                    </Grid>
-                </Border>
-
-                <!-- TempDB Chart (Top Right) -->
-                <Border Grid.Row="0" Grid.Column="1" BorderBrush="{DynamicResource BorderBrush}" BorderThickness="1" Margin="5">
-                    <Grid>
-                        <Grid.RowDefinitions>
-                            <RowDefinition Height="Auto"/>
-                            <RowDefinition Height="*"/>
-                        </Grid.RowDefinitions>
-                        <TextBlock Text="TempDB Usage (MB)" FontWeight="Bold" FontSize="14" Margin="10,5" Foreground="{DynamicResource ForegroundBrush}"/>
-                        <ScottPlot:WpfPlot Grid.Row="1" x:Name="ServerUtilTrendsTempdbChart" Margin="5"/>
-                    </Grid>
-                </Border>
-
-                <!-- Memory Usage Chart (Bottom Left) -->
-                <Border Grid.Row="1" Grid.Column="0" BorderBrush="{DynamicResource BorderBrush}" BorderThickness="1" Margin="5">
-                    <Grid>
-                        <Grid.RowDefinitions>
-                            <RowDefinition Height="Auto"/>
-                            <RowDefinition Height="*"/>
-                        </Grid.RowDefinitions>
-                        <TextBlock Text="Memory Usage (MB)" FontWeight="Bold" FontSize="14" Margin="10,5" Foreground="{DynamicResource ForegroundBrush}"/>
-                        <ScottPlot:WpfPlot Grid.Row="1" x:Name="ServerUtilTrendsMemoryChart" Margin="5"/>
-                    </Grid>
-                </Border>
-
-                <!-- PerfMon Chart (Bottom Right) -->
-                <Border Grid.Row="1" Grid.Column="1" BorderBrush="{DynamicResource BorderBrush}" BorderThickness="1" Margin="5">
-                    <Grid>
-                        <Grid.RowDefinitions>
-                            <RowDefinition Height="Auto"/>
-                            <RowDefinition Height="*"/>
-                        </Grid.RowDefinitions>
-                        <TextBlock Text="SQL Statistics/sec" FontWeight="Bold" FontSize="14" Margin="10,5" Foreground="{DynamicResource ForegroundBrush}"/>
-                        <ScottPlot:WpfPlot Grid.Row="1" x:Name="ServerUtilTrendsPerfmonChart" Margin="5"/>
-                    </Grid>
-                </Border>
-            </Grid>
+            <local:CorrelatedTimelineLanesControl x:Name="CorrelatedLanes"/>
         </TabItem>
 
         <!-- Wait Stats Detail Sub-Tab -->
diff --git a/Dashboard/Controls/ResourceMetricsContent.xaml.cs b/Dashboard/Controls/ResourceMetricsContent.xaml.cs
index bea433e..4884c6c 100644
--- a/Dashboard/Controls/ResourceMetricsContent.xaml.cs
+++ b/Dashboard/Controls/ResourceMetricsContent.xaml.cs
@@ -118,10 +118,6 @@ private void AddDrillDown(ScottPlot.WPF.WpfPlot chart, ContextMenu menu,
         private Helpers.ChartHoverHelper? _waitStatsHover;
         private Helpers.ChartHoverHelper? _tempdbStatsHover;
         private Helpers.ChartHoverHelper? _tempDbLatencyHover;
-        private Helpers.ChartHoverHelper? _serverTrendsCpuHover;
-        private Helpers.ChartHoverHelper? _serverTrendsTempdbHover;
-        private Helpers.ChartHoverHelper? _serverTrendsMemoryHover;
-        private Helpers.ChartHoverHelper? _serverTrendsPerfmonHover;
         // Filter state dictionaries for each DataGrid
         // Legend panel references for edge-based legends (ScottPlot issue #4717 workaround)
         // Must store and remove these by reference before creating new ones
@@ -148,10 +144,6 @@ public ResourceMetricsContent()
             TabHelpers.ApplyThemeToChart(FileIoWriteThroughputChart);
             TabHelpers.ApplyThemeToChart(PerfmonCountersChart);
             TabHelpers.ApplyThemeToChart(WaitStatsDetailChart);
-            TabHelpers.ApplyThemeToChart(ServerUtilTrendsCpuChart);
-            TabHelpers.ApplyThemeToChart(ServerUtilTrendsTempdbChart);
-            TabHelpers.ApplyThemeToChart(ServerUtilTrendsMemoryChart);
-            TabHelpers.ApplyThemeToChart(ServerUtilTrendsPerfmonChart);
 
             _sessionStatsHover = new Helpers.ChartHoverHelper(SessionStatsChart, "sessions");
             _latchStatsHover = new Helpers.ChartHoverHelper(LatchStatsChart, "ms/sec");
@@ -164,10 +156,6 @@ public ResourceMetricsContent()
             _waitStatsHover = new Helpers.ChartHoverHelper(WaitStatsDetailChart, "ms/sec");
             _tempdbStatsHover = new Helpers.ChartHoverHelper(TempdbStatsChart, "MB");
             _tempDbLatencyHover = new Helpers.ChartHoverHelper(TempDbLatencyChart, "ms");
-            _serverTrendsCpuHover = new Helpers.ChartHoverHelper(ServerUtilTrendsCpuChart, "%");
-            _serverTrendsTempdbHover = new Helpers.ChartHoverHelper(ServerUtilTrendsTempdbChart, "MB");
-            _serverTrendsMemoryHover = new Helpers.ChartHoverHelper(ServerUtilTrendsMemoryChart, "MB");
-            _serverTrendsPerfmonHover = new Helpers.ChartHoverHelper(ServerUtilTrendsPerfmonChart, "/sec");
         }
 
         private void OnLoaded(object sender, RoutedEventArgs e)
@@ -188,6 +176,7 @@ private void OnThemeChanged(string _)
                     chart.Refresh();
                 }
             }
+            CorrelatedLanes.ReapplyTheme();
         }
 
         private void SetupChartContextMenus()
@@ -214,16 +203,6 @@ private void SetupChartContextMenus()
             TabHelpers.SetupChartContextMenu(FileIoWriteThroughputChart, "UserDB_Write_Throughput", "collect.file_io_stats");
             TabHelpers.SetupChartContextMenu(TempDbLatencyChart, "TempDB_Latency", "collect.file_io_stats");
 
-            // Server Utilization Trends charts
-            var cpuTrendsMenu = TabHelpers.SetupChartContextMenu(ServerUtilTrendsCpuChart, "Server_CPU_Trends", "collect.cpu_utilization_stats");
-            AddDrillDown(ServerUtilTrendsCpuChart, cpuTrendsMenu, () => _serverTrendsCpuHover, "Show Active Queries at This Time", "CPU");
-            var tempDbTrendsMenu = TabHelpers.SetupChartContextMenu(ServerUtilTrendsTempdbChart, "Server_TempDB_Trends", "collect.tempdb_stats");
-            AddDrillDown(ServerUtilTrendsTempdbChart, tempDbTrendsMenu, () => _serverTrendsTempdbHover, "Show Active Queries at This Time", "TempDB");
-            var memTrendsMenu = TabHelpers.SetupChartContextMenu(ServerUtilTrendsMemoryChart, "Server_Memory_Trends", "collect.memory_stats");
-            AddDrillDown(ServerUtilTrendsMemoryChart, memTrendsMenu, () => _serverTrendsMemoryHover, "Show Active Queries at This Time", "Memory");
-            var perfmonTrendsMenu = TabHelpers.SetupChartContextMenu(ServerUtilTrendsPerfmonChart, "Server_Perfmon_Trends", "collect.perfmon_stats");
-            AddDrillDown(ServerUtilTrendsPerfmonChart, perfmonTrendsMenu, () => _serverTrendsPerfmonHover, "Show Active Queries at This Time", "Perfmon");
-
             // Perfmon Counters chart
             TabHelpers.SetupChartContextMenu(PerfmonCountersChart, "Perfmon_Counters", "collect.perfmon_stats");
 
@@ -238,6 +217,7 @@ private void SetupChartContextMenus()
         public void Initialize(DatabaseService databaseService)
         {
             _databaseService = databaseService ?? throw new ArgumentNullException(nameof(databaseService));
+            CorrelatedLanes.Initialize(databaseService);
         }
 
         /// <summary>
@@ -1047,32 +1027,9 @@ private async Task LoadFileIoThroughputChartsAsync()
         private async Task RefreshServerTrendsAsync()
         {
             if (_databaseService == null) return;
-
             try
             {
-                var cpuTask = _databaseService.GetCpuSpikesAsync(_serverTrendsHoursBack, _serverTrendsFromDate, _serverTrendsToDate);
-                var tempdbTask = _databaseService.GetTempdbStatsAsync(_serverTrendsHoursBack, _serverTrendsFromDate, _serverTrendsToDate);
-                var memoryTask = _databaseService.GetMemoryStatsAsync(_serverTrendsHoursBack, _serverTrendsFromDate, _serverTrendsToDate);
-                var perfmonTask = _databaseService.GetPerfmonStatsFilteredAsync(
-                    new[] { "Batch Requests/sec", "SQL Compilations/sec", "SQL Re-Compilations/sec", "Optimizer Statistics" },
-                    _serverTrendsHoursBack, _serverTrendsFromDate, _serverTrendsToDate);
-
-                await Task.WhenAll(cpuTask, tempdbTask, memoryTask, perfmonTask);
-
-                LoadServerTrendsCpuChart(await cpuTask, _serverTrendsHoursBack, _serverTrendsFromDate, _serverTrendsToDate);
-                LoadServerTrendsTempdbChart(await tempdbTask, _serverTrendsHoursBack, _serverTrendsFromDate, _serverTrendsToDate);
-                LoadServerTrendsMemoryChart(await memoryTask, _serverTrendsHoursBack, _serverTrendsFromDate, _serverTrendsToDate);
-                LoadServerTrendsPerfmonChart(await perfmonTask, _serverTrendsHoursBack, _serverTrendsFromDate, _serverTrendsToDate);
-
-                try
-                {
-                    var pressure = await _databaseService.GetCpuPressureAsync();
-                    UpdateCpuSchedulerStatus(pressure);
-                }
-                catch (Exception pressureEx)
-                {
-                    Logger.Error($"Error loading CPU scheduler pressure: {pressureEx.Message}", pressureEx);
-                }
+                await CorrelatedLanes.RefreshAsync(_serverTrendsHoursBack, _serverTrendsFromDate, _serverTrendsToDate);
             }
             catch (Exception ex)
             {
@@ -1080,343 +1037,6 @@ private async Task RefreshServerTrendsAsync()
             }
         }
 
-        private void UpdateCpuSchedulerStatus(CpuPressureItem? pressure)
-        {
-            if (pressure == null)
-            {
-                CpuSchedulerStatusText.Text = "";
-                return;
-            }
-
-            CpuSchedulerStatusText.Inlines.Clear();
-
-            var summary = $"Schedulers: {pressure.TotalSchedulers} | " +
-                          $"Workers: {pressure.TotalWorkers:N0}/{pressure.MaxWorkers:N0} ({pressure.WorkerUtilizationPercent:F1}%) | " +
-                          $"Runnable: {pressure.TotalRunnableTasks} ({pressure.AvgRunnableTasksPerScheduler:F2}/sched) | " +
-                          $"Active: {pressure.TotalActiveRequests} | " +
-                          $"Queued: {pressure.TotalQueuedRequests} | ";
-
-            CpuSchedulerStatusText.Inlines.Add(new Run(summary));
-
-            var levelText = pressure.PressureLevel;
-            var levelRun = new Run(levelText);
-
-            if (levelText.Contains("CRITICAL") || levelText.Contains("HIGH"))
-            {
-                levelRun.Foreground = new SolidColorBrush(Color.FromRgb(0xFF, 0x44, 0x44));
-                levelRun.FontWeight = FontWeights.Bold;
-            }
-            else if (levelText.Contains("MEDIUM"))
-            {
-                levelRun.Foreground = new SolidColorBrush(Color.FromRgb(0xFF, 0xA5, 0x00));
-                levelRun.FontWeight = FontWeights.Bold;
-            }
-
-            CpuSchedulerStatusText.Inlines.Add(levelRun);
-        }
-
-        private void LoadServerTrendsCpuChart(IEnumerable<CpuSpikeItem> cpuData, int hoursBack, DateTime? fromDate, DateTime? toDate)
-        {
-            DateTime rangeEnd = toDate ?? Helpers.ServerTimeHelper.ServerNow;
-            DateTime rangeStart = fromDate ?? rangeEnd.AddHours(-hoursBack);
-            double xMin = rangeStart.ToOADate();
-            double xMax = rangeEnd.ToOADate();
-
-            if (_legendPanels.TryGetValue(ServerUtilTrendsCpuChart, out var existingCpuPanel) && existingCpuPanel != null)
-            {
-                ServerUtilTrendsCpuChart.Plot.Axes.Remove(existingCpuPanel);
-                _legendPanels[ServerUtilTrendsCpuChart] = null;
-            }
-            ServerUtilTrendsCpuChart.Plot.Clear();
-            _serverTrendsCpuHover?.Clear();
-            TabHelpers.ApplyThemeToChart(ServerUtilTrendsCpuChart);
-
-            var dataList = cpuData?.OrderBy(d => d.EventTime).ToList() ?? new List<CpuSpikeItem>();
-            if (dataList.Count > 0)
-            {
-                // SQL CPU series
-                var (sqlXs, sqlYs) = TabHelpers.FillTimeSeriesGaps(
-                    dataList.Select(d => d.EventTime),
-                    dataList.Select(d => (double)d.SqlServerCpu));
-                var sqlScatter = ServerUtilTrendsCpuChart.Plot.Add.Scatter(sqlXs, sqlYs);
-                sqlScatter.LineWidth = 2;
-                sqlScatter.MarkerSize = 5;
-                sqlScatter.Color = TabHelpers.ChartColors[0];
-                sqlScatter.LegendText = "SQL CPU";
-                _serverTrendsCpuHover?.Add(sqlScatter, "SQL CPU");
-
-                // Other CPU series
-                var (otherXs, otherYs) = TabHelpers.FillTimeSeriesGaps(
-                    dataList.Select(d => d.EventTime),
-                    dataList.Select(d => (double)d.OtherProcessCpu));
-                var otherScatter = ServerUtilTrendsCpuChart.Plot.Add.Scatter(otherXs, otherYs);
-                otherScatter.LineWidth = 2;
-                otherScatter.MarkerSize = 5;
-                otherScatter.Color = TabHelpers.ChartColors[2];
-                otherScatter.LegendText = "Other CPU";
-                _serverTrendsCpuHover?.Add(otherScatter, "Other CPU");
-
-                _legendPanels[ServerUtilTrendsCpuChart] = ServerUtilTrendsCpuChart.Plot.ShowLegend(ScottPlot.Edge.Bottom);
-                ServerUtilTrendsCpuChart.Plot.Legend.FontSize = 12;
-            }
-            else
-            {
-                double xCenter = xMin + (xMax - xMin) / 2;
-                var noDataText = ServerUtilTrendsCpuChart.Plot.Add.Text("No data for selected time range", xCenter, 0.5);
-                noDataText.LabelFontSize = 14;
-                noDataText.LabelFontColor = ScottPlot.Colors.Gray;
-                noDataText.LabelAlignment = ScottPlot.Alignment.MiddleCenter;
-            }
-
-            ServerUtilTrendsCpuChart.Plot.Axes.DateTimeTicksBottom();
-            ServerUtilTrendsCpuChart.Plot.Axes.SetLimitsX(xMin, xMax);
-            TabHelpers.SetChartYLimitsWithLegendPadding(ServerUtilTrendsCpuChart);
-            ServerUtilTrendsCpuChart.Plot.YLabel("CPU %");
-            TabHelpers.LockChartVerticalAxis(ServerUtilTrendsCpuChart);
-            ServerUtilTrendsCpuChart.Refresh();
-        }
-
-        private void LoadServerTrendsTempdbChart(IEnumerable<TempdbStatsItem> tempdbData, int hoursBack, DateTime? fromDate, DateTime? toDate)
-        {
-            DateTime rangeEnd = toDate ?? Helpers.ServerTimeHelper.ServerNow;
-            DateTime rangeStart = fromDate ?? rangeEnd.AddHours(-hoursBack);
-            double xMin = rangeStart.ToOADate();
-            double xMax = rangeEnd.ToOADate();
-
-            if (_legendPanels.TryGetValue(ServerUtilTrendsTempdbChart, out var existingTrendsTempdbPanel) && existingTrendsTempdbPanel != null)
-            {
-                ServerUtilTrendsTempdbChart.Plot.Axes.Remove(existingTrendsTempdbPanel);
-                _legendPanels[ServerUtilTrendsTempdbChart] = null;
-            }
-            ServerUtilTrendsTempdbChart.Plot.Clear();
-            _serverTrendsTempdbHover?.Clear();
-            TabHelpers.ApplyThemeToChart(ServerUtilTrendsTempdbChart);
-
-            var dataList = tempdbData?.OrderBy(d => d.CollectionTime).ToList() ?? new List<TempdbStatsItem>();
-            if (dataList.Count >= 1)
-            {
-                var userTimePoints = dataList.Select(d => d.CollectionTime);
-                var userValues = dataList.Select(d => (double)(d.UserObjectReservedPageCount * 8 / 1024));
-                var (userXs, userYs) = TabHelpers.FillTimeSeriesGaps(userTimePoints, userValues);
-
-                var versionTimePoints = dataList.Select(d => d.CollectionTime);
-                var versionValues = dataList.Select(d => (double)(d.VersionStoreReservedPageCount * 8 / 1024));
-                var (versionXs, versionYs) = TabHelpers.FillTimeSeriesGaps(versionTimePoints, versionValues);
-
-                var userScatter = ServerUtilTrendsTempdbChart.Plot.Add.Scatter(userXs, userYs);
-                userScatter.LineWidth = 2;
-                userScatter.MarkerSize = 5;
-                userScatter.Color = TabHelpers.ChartColors[1];
-                userScatter.LegendText = "User Objects";
-                _serverTrendsTempdbHover?.Add(userScatter, "User Objects");
-
-                var versionScatter = ServerUtilTrendsTempdbChart.Plot.Add.Scatter(versionXs, versionYs);
-                versionScatter.LineWidth = 2;
-                versionScatter.MarkerSize = 5;
-                versionScatter.Color = TabHelpers.ChartColors[2];
-                versionScatter.LegendText = "Version Store";
-                _serverTrendsTempdbHover?.Add(versionScatter, "Version Store");
-
-                _legendPanels[ServerUtilTrendsTempdbChart] = ServerUtilTrendsTempdbChart.Plot.ShowLegend(ScottPlot.Edge.Bottom);
-                ServerUtilTrendsTempdbChart.Plot.Legend.FontSize = 12;
-            }
-            else
-            {
-                double xCenter = xMin + (xMax - xMin) / 2;
-                var noDataText = ServerUtilTrendsTempdbChart.Plot.Add.Text("No data for selected time range", xCenter, 0.5);
-                noDataText.LabelFontSize = 14;
-                noDataText.LabelFontColor = ScottPlot.Colors.Gray;
-                noDataText.LabelAlignment = ScottPlot.Alignment.MiddleCenter;
-            }
-
-            ServerUtilTrendsTempdbChart.Plot.Axes.DateTimeTicksBottom();
-            ServerUtilTrendsTempdbChart.Plot.Axes.SetLimitsX(xMin, xMax);
-            TabHelpers.SetChartYLimitsWithLegendPadding(ServerUtilTrendsTempdbChart);
-            ServerUtilTrendsTempdbChart.Plot.YLabel("MB");
-            TabHelpers.LockChartVerticalAxis(ServerUtilTrendsTempdbChart);
-            ServerUtilTrendsTempdbChart.Refresh();
-        }
-
-        private void LoadServerTrendsMemoryChart(IEnumerable<MemoryStatsItem> memoryData, int hoursBack, DateTime? fromDate, DateTime? toDate)
-        {
-            DateTime rangeEnd = toDate ?? Helpers.ServerTimeHelper.ServerNow;
-            DateTime rangeStart = fromDate ?? rangeEnd.AddHours(-hoursBack);
-            double xMin = rangeStart.ToOADate();
-            double xMax = rangeEnd.ToOADate();
-
-            if (_legendPanels.TryGetValue(ServerUtilTrendsMemoryChart, out var existingMemoryPanel) && existingMemoryPanel != null)
-            {
-                ServerUtilTrendsMemoryChart.Plot.Axes.Remove(existingMemoryPanel);
-                _legendPanels[ServerUtilTrendsMemoryChart] = null;
-            }
-            ServerUtilTrendsMemoryChart.Plot.Clear();
-            _serverTrendsMemoryHover?.Clear();
-            TabHelpers.ApplyThemeToChart(ServerUtilTrendsMemoryChart);
-
-            var dataList = memoryData?.OrderBy(d => d.CollectionTime).ToList() ?? new List<MemoryStatsItem>();
-            if (dataList.Count >= 1)
-            {
-                var bufferTimePoints = dataList.Select(d => d.CollectionTime);
-                var bufferValues = dataList.Select(d => (double)d.BufferPoolMb);
-                var (bufferXs, bufferYs) = TabHelpers.FillTimeSeriesGaps(bufferTimePoints, bufferValues);
-
-                var cacheTimePoints = dataList.Select(d => d.CollectionTime);
-                var cacheValues = dataList.Select(d => (double)d.PlanCacheMb);
-                var (cacheXs, cacheYs) = TabHelpers.FillTimeSeriesGaps(cacheTimePoints, cacheValues);
-
-                // DEBUG: Log the last data points to diagnose the "drop to 0" issue
-                if (bufferXs.Length > 0)
-                {
-                    var lastTime = DateTime.FromOADate(bufferXs[^1]);
-                    var lastValue = bufferYs[^1];
-                    Logger.Info($"Memory chart: Last buffer point = {lastTime:yyyy-MM-dd HH:mm:ss}, Value = {lastValue}. Array length = {bufferXs.Length}");
-                    Logger.Info($"Memory chart: rangeStart = {rangeStart:yyyy-MM-dd HH:mm:ss}, rangeEnd = {rangeEnd:yyyy-MM-dd HH:mm:ss}");
-
-                    // Check for any zero values in the array
-                    var zeroIndices = bufferYs.Select((v, i) => new { Value = v, Index = i })
-                        .Where(x => x.Value == 0)
-                        .Select(x => x.Index)
-                        .ToList();
-                    if (zeroIndices.Count > 0)
-                    {
-                        Logger.Warning($"Memory chart: Found {zeroIndices.Count} zero values at indices: {string.Join(", ", zeroIndices.Take(10))}");
-                        foreach (var idx in zeroIndices.Take(5))
-                        {
-                            var zeroTime = DateTime.FromOADate(bufferXs[idx]);
-                            Logger.Warning($"  Zero at index {idx}: Time = {zeroTime:yyyy-MM-dd HH:mm:ss}");
-                        }
-                    }
-
-                    // Log first and last 3 points
-                    Logger.Info($"Memory chart: First 3 points:");
-                    for (int i = 0; i < Math.Min(3, bufferXs.Length); i++)
-                    {
-                        Logger.Info($"  [{i}] Time = {DateTime.FromOADate(bufferXs[i]):HH:mm:ss}, Value = {bufferYs[i]}");
-                    }
-                    Logger.Info($"Memory chart: Last 3 points:");
-                    for (int i = Math.Max(0, bufferXs.Length - 3); i < bufferXs.Length; i++)
-                    {
-                        Logger.Info($"  [{i}] Time = {DateTime.FromOADate(bufferXs[i]):HH:mm:ss}, Value = {bufferYs[i]}");
-                    }
-                }
-
-                var bufferScatter = ServerUtilTrendsMemoryChart.Plot.Add.Scatter(bufferXs, bufferYs);
-                bufferScatter.LineWidth = 2;
-                bufferScatter.MarkerSize = 5;
-                bufferScatter.Color = TabHelpers.ChartColors[4];
-                bufferScatter.LegendText = "Buffer Pool";
-                _serverTrendsMemoryHover?.Add(bufferScatter, "Buffer Pool");
-
-                var cacheScatter = ServerUtilTrendsMemoryChart.Plot.Add.Scatter(cacheXs, cacheYs);
-                cacheScatter.LineWidth = 2;
-                cacheScatter.MarkerSize = 5;
-                cacheScatter.Color = TabHelpers.ChartColors[5];
-                cacheScatter.LegendText = "Plan Cache";
-                _serverTrendsMemoryHover?.Add(cacheScatter, "Plan Cache");
-
-                _legendPanels[ServerUtilTrendsMemoryChart] = ServerUtilTrendsMemoryChart.Plot.ShowLegend(ScottPlot.Edge.Bottom);
-                ServerUtilTrendsMemoryChart.Plot.Legend.FontSize = 12;
-
-                // Limit X-axis to actual data range to prevent ScottPlot from extrapolating beyond data
-                if (bufferXs.Length > 0)
-                {
-                    var oldXMax = xMax;
-                    xMax = Math.Min(xMax, bufferXs[^1]);
-                    Logger.Info($"Memory chart: xMax changed from {DateTime.FromOADate(oldXMax):HH:mm:ss} to {DateTime.FromOADate(xMax):HH:mm:ss}");
-                }
-            }
-            else
-            {
-                double xCenter = xMin + (xMax - xMin) / 2;
-                var noDataText = ServerUtilTrendsMemoryChart.Plot.Add.Text("No data for selected time range", xCenter, 0.5);
-                noDataText.LabelFontSize = 14;
-                noDataText.LabelFontColor = ScottPlot.Colors.Gray;
-                noDataText.LabelAlignment = ScottPlot.Alignment.MiddleCenter;
-            }
-
-            ServerUtilTrendsMemoryChart.Plot.Axes.DateTimeTicksBottom();
-            ServerUtilTrendsMemoryChart.Plot.Axes.SetLimitsX(xMin, xMax);
-            TabHelpers.SetChartYLimitsWithLegendPadding(ServerUtilTrendsMemoryChart);
-            ServerUtilTrendsMemoryChart.Plot.YLabel("MB");
-            TabHelpers.LockChartVerticalAxis(ServerUtilTrendsMemoryChart);
-            ServerUtilTrendsMemoryChart.Refresh();
-        }
-
-        private void LoadServerTrendsPerfmonChart(IEnumerable<PerfmonStatsItem> perfmonData, int hoursBack, DateTime? fromDate, DateTime? toDate)
-        {
-            DateTime rangeEnd = toDate ?? Helpers.ServerTimeHelper.ServerNow;
-            DateTime rangeStart = fromDate ?? rangeEnd.AddHours(-hoursBack);
-            double xMin = rangeStart.ToOADate();
-            double xMax = rangeEnd.ToOADate();
-
-            if (_legendPanels.TryGetValue(ServerUtilTrendsPerfmonChart, out var existingPerfmonTrendsPanel) && existingPerfmonTrendsPanel != null)
-            {
-                ServerUtilTrendsPerfmonChart.Plot.Axes.Remove(existingPerfmonTrendsPanel);
-                _legendPanels[ServerUtilTrendsPerfmonChart] = null;
-            }
-            ServerUtilTrendsPerfmonChart.Plot.Clear();
-            _serverTrendsPerfmonHover?.Clear();
-            TabHelpers.ApplyThemeToChart(ServerUtilTrendsPerfmonChart);
-
-            var allData = (perfmonData ?? Enumerable.Empty<PerfmonStatsItem>()).ToList();
-
-            // Counters to display
-            var countersToShow = new[] {
-                ("Batch Requests/sec", TabHelpers.ChartColors[0]),
-                ("SQL Compilations/sec", TabHelpers.ChartColors[2]),
-                ("SQL Re-Compilations/sec", TabHelpers.ChartColors[3]),
-                ("Optimizer Statistics", TabHelpers.ChartColors[1])
-            };
-
-            // Get all time points across all counters for gap filling
-            int linesAdded = 0;
-            foreach (var (counterName, color) in countersToShow)
-            {
-                var counterData = allData
-                    .Where(d => d.CounterName == counterName)
-                    .GroupBy(d => d.CollectionTime)
-                    .Select(g => new { Time = g.Key, Value = g.Sum(x => x.CntrValuePerSecond ?? x.CntrValueDelta ?? x.CntrValue) })
-                    .OrderBy(d => d.Time)
-                    .ToList();
-
-                if (counterData.Count >= 1)
-                {
-                    var timePoints = counterData.Select(d => d.Time);
-                    var values = counterData.Select(d => (double)d.Value);
-                    var (xs, ys) = TabHelpers.FillTimeSeriesGaps(timePoints, values);
-
-                    var scatter = ServerUtilTrendsPerfmonChart.Plot.Add.Scatter(xs, ys);
-                    scatter.LineWidth = 2;
-                    scatter.MarkerSize = 5;
-                    scatter.Color = color;
-                    scatter.LegendText = counterName.Replace("/sec", "", StringComparison.Ordinal);
-                    _serverTrendsPerfmonHover?.Add(scatter, counterName);
-                    linesAdded++;
-                }
-            }
-
-            if (linesAdded > 0)
-            {
-                _legendPanels[ServerUtilTrendsPerfmonChart] = ServerUtilTrendsPerfmonChart.Plot.ShowLegend(ScottPlot.Edge.Bottom);
-                ServerUtilTrendsPerfmonChart.Plot.Legend.FontSize = 12;
-            }
-            else
-            {
-                double xCenter = xMin + (xMax - xMin) / 2;
-                var noDataText = ServerUtilTrendsPerfmonChart.Plot.Add.Text("No data for selected time range", xCenter, 0.5);
-                noDataText.LabelFontSize = 14;
-                noDataText.LabelFontColor = ScottPlot.Colors.Gray;
-                noDataText.LabelAlignment = ScottPlot.Alignment.MiddleCenter;
-            }
-
-            ServerUtilTrendsPerfmonChart.Plot.Axes.DateTimeTicksBottom();
-            ServerUtilTrendsPerfmonChart.Plot.Axes.SetLimitsX(xMin, xMax);
-            TabHelpers.SetChartYLimitsWithLegendPadding(ServerUtilTrendsPerfmonChart);
-            ServerUtilTrendsPerfmonChart.Plot.YLabel("Per Second");
-            TabHelpers.LockChartVerticalAxis(ServerUtilTrendsPerfmonChart);
-            ServerUtilTrendsPerfmonChart.Refresh();
-        }
-
         #endregion
 
         #region Context Menu Handlers
diff --git a/Dashboard/Helpers/CorrelatedCrosshairManager.cs b/Dashboard/Helpers/CorrelatedCrosshairManager.cs
new file mode 100644
index 0000000..7da5400
--- /dev/null
+++ b/Dashboard/Helpers/CorrelatedCrosshairManager.cs
@@ -0,0 +1,309 @@
+/*
+ * 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.
+ *
+ * SYNC WARNING: Lite has a matching copy at Lite/Helpers/CorrelatedCrosshairManager.cs.
+ * Changes here must be mirrored there.
+ */
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Windows;
+using System.Windows.Controls;
+using System.Windows.Controls.Primitives;
+using System.Windows.Input;
+using System.Windows.Media;
+using PerformanceMonitorDashboard.Services;
+
+namespace PerformanceMonitorDashboard.Helpers;
+
+/// <summary>
+/// Synchronizes vertical crosshair lines across multiple ScottPlot charts.
+/// When the user hovers over any lane, all lanes show a VLine at the same X (time)
+/// coordinate and value labels update to show each lane's value at that time.
+/// </summary>
+internal sealed class CorrelatedCrosshairManager : IDisposable
+{
+    private readonly List<LaneInfo> _lanes = new();
+    private readonly Popup _tooltip;
+    private readonly TextBlock _tooltipText;
+    private DateTime _lastUpdate;
+    private bool _isRefreshing;
+
+    public CorrelatedCrosshairManager()
+    {
+        _tooltipText = new TextBlock
+        {
+            Foreground = new SolidColorBrush(Color.FromRgb(0xE0, 0xE0, 0xE0)),
+            FontSize = 13
+        };
+
+        _tooltip = new Popup
+        {
+            Placement = PlacementMode.Relative,
+            IsHitTestVisible = false,
+            AllowsTransparency = true,
+            Child = new Border
+            {
+                Background = new SolidColorBrush(Color.FromRgb(0x33, 0x33, 0x33)),
+                BorderBrush = new SolidColorBrush(Color.FromRgb(0x55, 0x55, 0x55)),
+                BorderThickness = new Thickness(1),
+                CornerRadius = new CornerRadius(3),
+                Padding = new Thickness(8, 4, 8, 4),
+                Child = _tooltipText
+            }
+        };
+    }
+
+    /// <summary>
+    /// Registers a chart lane for crosshair synchronization.
+    /// </summary>
+    public void AddLane(ScottPlot.WPF.WpfPlot chart, string label, string unit, TextBlock valueLabel)
+    {
+        var lane = new LaneInfo
+        {
+            Chart = chart,
+            Label = label,
+            Unit = unit,
+            ValueLabel = valueLabel
+        };
+
+        chart.MouseMove += (s, e) => OnMouseMove(lane, e);
+        chart.MouseLeave += (s, e) => OnMouseLeave();
+
+        _lanes.Add(lane);
+    }
+
+    /// <summary>
+    /// Sets a single data series for a lane (most lanes have one series).
+    /// </summary>
+    public void SetLaneData(ScottPlot.WPF.WpfPlot chart, double[] times, double[] values,
+        bool isEventBased = false)
+    {
+        var lane = _lanes.Find(l => l.Chart == chart);
+        if (lane == null) return;
+
+        lane.Series.Clear();
+        lane.Series.Add(new DataSeries
+        {
+            Name = lane.Label,
+            Times = times,
+            Values = values,
+            IsEventBased = isEventBased
+        });
+    }
+
+    /// <summary>
+    /// Adds a named data series to a lane (for lanes with multiple overlaid series).
+    /// Call SetLaneData first to clear, then AddLaneSeries for additional series.
+    /// </summary>
+    public void AddLaneSeries(ScottPlot.WPF.WpfPlot chart, string name, string unit,
+        double[] times, double[] values, bool isEventBased = false)
+    {
+        var lane = _lanes.Find(l => l.Chart == chart);
+        if (lane == null) return;
+
+        lane.Series.Add(new DataSeries
+        {
+            Name = name,
+            Unit = unit,
+            Times = times,
+            Values = values,
+            IsEventBased = isEventBased
+        });
+    }
+
+    /// <summary>
+    /// Clears data and VLines. Call before re-populating charts.
+    /// </summary>
+    public void PrepareForRefresh()
+    {
+        _isRefreshing = true;
+        _tooltip.IsOpen = false;
+        foreach (var lane in _lanes)
+        {
+            lane.Series.Clear();
+            lane.VLine = null;
+        }
+    }
+
+    /// <summary>
+    /// Creates fresh VLine plottables on each lane's chart.
+    /// Must be called AFTER chart data is populated.
+    /// </summary>
+    public void ReattachVLines()
+    {
+        foreach (var lane in _lanes)
+        {
+            var vline = lane.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;
+        }
+        _isRefreshing = false;
+    }
+
+    private void OnMouseMove(LaneInfo sourceLane, MouseEventArgs e)
+    {
+        if (_isRefreshing || sourceLane.VLine == null) return;
+
+        var now = DateTime.UtcNow;
+        if ((now - _lastUpdate).TotalMilliseconds < 16) return;
+        _lastUpdate = now;
+
+        var pos = e.GetPosition(sourceLane.Chart);
+        var dpi = VisualTreeHelper.GetDpi(sourceLane.Chart);
+        var pixel = new ScottPlot.Pixel(
+            (float)(pos.X * dpi.DpiScaleX),
+            (float)(pos.Y * dpi.DpiScaleY));
+        var mouseCoords = sourceLane.Chart.Plot.GetCoordinates(pixel);
+        double xValue = mouseCoords.X;
+
+        var tooltipLines = new List<string>();
+        var time = DateTime.FromOADate(xValue);
+        var displayTime = ServerTimeHelper.ConvertForDisplay(time, ServerTimeHelper.CurrentDisplayMode);
+        tooltipLines.Add(displayTime.ToString("yyyy-MM-dd HH:mm:ss"));
+
+        foreach (var lane in _lanes)
+        {
+            if (lane.VLine == null) continue;
+
+            lane.VLine.IsVisible = true;
+            lane.VLine.X = xValue;
+
+            if (lane.Series.Count == 1)
+            {
+                // Single series — use lane label and unit
+                var series = lane.Series[0];
+                double? value = FindNearestValue(series, xValue);
+
+                if (value.HasValue)
+                {
+                    lane.ValueLabel.Text = $"{value.Value:N1} {lane.Unit}";
+                    tooltipLines.Add($"{lane.Label}: {value.Value:N1} {lane.Unit}");
+                }
+                else
+                {
+                    lane.ValueLabel.Text = "";
+                    tooltipLines.Add($"{lane.Label}: —");
+                }
+            }
+            else if (lane.Series.Count > 1)
+            {
+                // Multiple series — show each with its own name
+                var valueParts = new List<string>();
+                foreach (var series in lane.Series)
+                {
+                    double? value = FindNearestValue(series, xValue);
+                    string unit = series.Unit ?? lane.Unit;
+                    if (value.HasValue)
+                    {
+                        valueParts.Add($"{value.Value:N0}");
+                        tooltipLines.Add($"{series.Name}: {value.Value:N0} {unit}");
+                    }
+                    else
+                    {
+                        tooltipLines.Add($"{series.Name}: —");
+                    }
+                }
+                lane.ValueLabel.Text = valueParts.Count > 0 ? string.Join("/", valueParts) : "";
+            }
+            else
+            {
+                lane.ValueLabel.Text = "";
+                tooltipLines.Add($"{lane.Label}: —");
+            }
+
+            lane.Chart.Refresh();
+        }
+
+        _tooltipText.Text = string.Join("\n", tooltipLines);
+        _tooltip.PlacementTarget = sourceLane.Chart;
+        _tooltip.HorizontalOffset = pos.X + 15;
+        _tooltip.VerticalOffset = pos.Y + 15;
+        _tooltip.IsOpen = true;
+    }
+
+    private static double? FindNearestValue(DataSeries series, double targetX)
+    {
+        if (series.Times == null || series.Values == null || series.Times.Length == 0)
+            return null;
+
+        var times = series.Times;
+        var values = series.Values;
+
+        int lo = 0, hi = times.Length - 1;
+        while (lo < hi)
+        {
+            int mid = (lo + hi) / 2;
+            if (times[mid] < targetX)
+                lo = mid + 1;
+            else
+                hi = mid;
+        }
+
+        int best = lo;
+        if (lo > 0 && Math.Abs(times[lo - 1] - targetX) < Math.Abs(times[lo] - targetX))
+            best = lo - 1;
+
+        double val = values[best];
+        if (double.IsNaN(val)) return null;
+
+        if (series.IsEventBased)
+        {
+            double oneMinute = 1.0 / 1440.0;
+            if (Math.Abs(times[best] - targetX) > oneMinute)
+                return 0;
+        }
+
+        return val;
+    }
+
+    private void OnMouseLeave()
+    {
+        _tooltip.IsOpen = false;
+        foreach (var lane in _lanes)
+        {
+            if (lane.VLine != null)
+                lane.VLine.IsVisible = false;
+            lane.ValueLabel.Text = "";
+            lane.Chart.Refresh();
+        }
+    }
+
+    public void Dispose()
+    {
+        _tooltip.IsOpen = false;
+        foreach (var lane in _lanes)
+        {
+            lane.Series.Clear();
+            lane.VLine = null;
+        }
+        _lanes.Clear();
+    }
+
+    private class DataSeries
+    {
+        public string Name { get; set; } = "";
+        public string? Unit { get; set; }
+        public double[]? Times { get; set; }
+        public double[]? Values { get; set; }
+        public bool IsEventBased { get; set; }
+    }
+
+    private class LaneInfo
+    {
+        public ScottPlot.WPF.WpfPlot Chart { get; set; } = null!;
+        public string Label { get; set; } = "";
+        public string Unit { get; set; } = "";
+        public ScottPlot.Plottables.VerticalLine? VLine { get; set; }
+        public TextBlock ValueLabel { get; set; } = null!;
+        public List<DataSeries> Series { get; set; } = new();
+    }
+}
diff --git a/Dashboard/Services/DatabaseService.QueryPerformance.cs b/Dashboard/Services/DatabaseService.QueryPerformance.cs
index 1d88ab9..2e162eb 100644
--- a/Dashboard/Services/DatabaseService.QueryPerformance.cs
+++ b/Dashboard/Services/DatabaseService.QueryPerformance.cs
@@ -3587,6 +3587,68 @@ ORDER BY
             return items;
         }
 
+        public async Task<List<BlockedSessionTrendItem>> GetDeadlockTrendAsync(int hoursBack = 24, DateTime? fromDate = null, DateTime? toDate = null)
+        {
+            var items = new List<BlockedSessionTrendItem>();
+
+            await using var tc = await OpenThrottledConnectionAsync();
+            var connection = tc.Connection;
+
+            string query;
+            if (fromDate.HasValue && toDate.HasValue)
+            {
+                query = @"
+                    SET TRANSACTION ISOLATION LEVEL READ UNCOMMITTED;
+
+                    SELECT
+                        CollectionTime = DATEADD(MINUTE, DATEDIFF(MINUTE, 0, d.event_date), 0),
+                        DatabaseName = N'',
+                        BlockedCount = COUNT(*)
+                    FROM collect.deadlocks AS d
+                    WHERE d.event_date >= @from_date
+                    AND   d.event_date <= @to_date
+                    GROUP BY
+                        DATEADD(MINUTE, DATEDIFF(MINUTE, 0, d.event_date), 0)
+                    ORDER BY
+                        CollectionTime;";
+            }
+            else
+            {
+                query = @"
+                    SET TRANSACTION ISOLATION LEVEL READ UNCOMMITTED;
+
+                    SELECT
+                        CollectionTime = DATEADD(MINUTE, DATEDIFF(MINUTE, 0, d.event_date), 0),
+                        DatabaseName = N'',
+                        BlockedCount = COUNT(*)
+                    FROM collect.deadlocks AS d
+                    WHERE d.event_date >= DATEADD(HOUR, @hours_back, SYSDATETIME())
+                    GROUP BY
+                        DATEADD(MINUTE, DATEDIFF(MINUTE, 0, d.event_date), 0)
+                    ORDER BY
+                        CollectionTime;";
+            }
+
+            using var command = new SqlCommand(query, connection);
+            command.CommandTimeout = 120;
+            command.Parameters.Add(new SqlParameter("@hours_back", SqlDbType.Int) { Value = -hoursBack });
+            if (fromDate.HasValue) command.Parameters.Add(new SqlParameter("@from_date", SqlDbType.DateTime2) { Value = fromDate.Value });
+            if (toDate.HasValue) command.Parameters.Add(new SqlParameter("@to_date", SqlDbType.DateTime2) { Value = toDate.Value });
+
+            using var reader = await command.ExecuteReaderAsync();
+            while (await reader.ReadAsync())
+            {
+                items.Add(new BlockedSessionTrendItem
+                {
+                    CollectionTime = reader.GetDateTime(0),
+                    DatabaseName = reader.IsDBNull(1) ? string.Empty : reader.GetString(1),
+                    BlockedCount = reader.IsDBNull(2) ? 0 : Convert.ToInt32(reader.GetValue(2), CultureInfo.InvariantCulture)
+                });
+            }
+
+            return items;
+        }
+
         private static string GetHeatmapMetricExpr(Models.HeatmapMetric metric) => metric switch
         {
             Models.HeatmapMetric.Duration => "(qs.total_elapsed_time_delta / 1000.0) / NULLIF(qs.execution_count_delta, 0)",
diff --git a/Dashboard/Services/DatabaseService.ResourceMetrics.cs b/Dashboard/Services/DatabaseService.ResourceMetrics.cs
index 4912092..b449232 100644
--- a/Dashboard/Services/DatabaseService.ResourceMetrics.cs
+++ b/Dashboard/Services/DatabaseService.ResourceMetrics.cs
@@ -2223,5 +2223,176 @@ ORDER BY
 
             return items;
         }
+
+        public async Task<List<WaitStatsDataPoint>> GetTotalWaitStatsTrendAsync(int hoursBack = 24, DateTime? fromDate = null, DateTime? toDate = null)
+        {
+            var items = new List<WaitStatsDataPoint>();
+
+            await using var tc = await OpenThrottledConnectionAsync();
+            var connection = tc.Connection;
+
+            string query;
+            if (fromDate.HasValue && toDate.HasValue)
+            {
+                query = @"
+                    SET TRANSACTION ISOLATION LEVEL READ UNCOMMITTED;
+
+                    WITH wait_deltas AS
+                    (
+                        SELECT
+                            collection_time = ws.collection_time,
+                            wait_type = ws.wait_type,
+                            wait_time_ms_delta =
+                                ws.wait_time_ms - LAG(ws.wait_time_ms, 1, ws.wait_time_ms) OVER
+                                (
+                                    PARTITION BY
+                                        ws.wait_type
+                                    ORDER BY
+                                        ws.collection_time
+                                ),
+                            signal_wait_time_ms_delta =
+                                ws.signal_wait_time_ms - LAG(ws.signal_wait_time_ms, 1, ws.signal_wait_time_ms) OVER
+                                (
+                                    PARTITION BY
+                                        ws.wait_type
+                                    ORDER BY
+                                        ws.collection_time
+                                ),
+                            interval_seconds =
+                                DATEDIFF
+                                (
+                                    SECOND,
+                                    LAG(ws.collection_time, 1, ws.collection_time) OVER
+                                    (
+                                        PARTITION BY
+                                            ws.wait_type
+                                        ORDER BY
+                                            ws.collection_time
+                                    ),
+                                    ws.collection_time
+                                )
+                        FROM collect.wait_stats AS ws
+                        WHERE ws.collection_time >= @from_date
+                        AND   ws.collection_time <= @to_date
+                    )
+                    SELECT
+                        wd.collection_time,
+                        wait_type = N'Total',
+                        wait_time_ms_per_second =
+                            SUM
+                            (
+                                CASE
+                                    WHEN wd.interval_seconds > 0
+                                    THEN CAST(CAST(wd.wait_time_ms_delta AS decimal(19, 4)) / wd.interval_seconds AS decimal(18, 4))
+                                    ELSE 0
+                                END
+                            ),
+                        signal_wait_time_ms_per_second =
+                            SUM
+                            (
+                                CASE
+                                    WHEN wd.interval_seconds > 0
+                                    THEN CAST(CAST(wd.signal_wait_time_ms_delta AS decimal(19, 4)) / wd.interval_seconds AS decimal(18, 4))
+                                    ELSE 0
+                                END
+                            )
+                    FROM wait_deltas AS wd
+                    WHERE wd.wait_time_ms_delta >= 0
+                    GROUP BY
+                        wd.collection_time
+                    ORDER BY
+                        wd.collection_time ASC;";
+            }
+            else
+            {
+                query = @"
+                    SET TRANSACTION ISOLATION LEVEL READ UNCOMMITTED;
+
+                    WITH wait_deltas AS
+                    (
+                        SELECT
+                            collection_time = ws.collection_time,
+                            wait_type = ws.wait_type,
+                            wait_time_ms_delta =
+                                ws.wait_time_ms - LAG(ws.wait_time_ms, 1, ws.wait_time_ms) OVER
+                                (
+                                    PARTITION BY
+                                        ws.wait_type
+                                    ORDER BY
+                                        ws.collection_time
+                                ),
+                            signal_wait_time_ms_delta =
+                                ws.signal_wait_time_ms - LAG(ws.signal_wait_time_ms, 1, ws.signal_wait_time_ms) OVER
+                                (
+                                    PARTITION BY
+                                        ws.wait_type
+                                    ORDER BY
+                                        ws.collection_time
+                                ),
+                            interval_seconds =
+                                DATEDIFF
+                                (
+                                    SECOND,
+                                    LAG(ws.collection_time, 1, ws.collection_time) OVER
+                                    (
+                                        PARTITION BY
+                                            ws.wait_type
+                                        ORDER BY
+                                            ws.collection_time
+                                    ),
+                                    ws.collection_time
+                                )
+                        FROM collect.wait_stats AS ws
+                        WHERE ws.collection_time >= DATEADD(HOUR, @hours_back, SYSDATETIME())
+                    )
+                    SELECT
+                        wd.collection_time,
+                        wait_type = N'Total',
+                        wait_time_ms_per_second =
+                            SUM
+                            (
+                                CASE
+                                    WHEN wd.interval_seconds > 0
+                                    THEN CAST(CAST(wd.wait_time_ms_delta AS decimal(19, 4)) / wd.interval_seconds AS decimal(18, 4))
+                                    ELSE 0
+                                END
+                            ),
+                        signal_wait_time_ms_per_second =
+                            SUM
+                            (
+                                CASE
+                                    WHEN wd.interval_seconds > 0
+                                    THEN CAST(CAST(wd.signal_wait_time_ms_delta AS decimal(19, 4)) / wd.interval_seconds AS decimal(18, 4))
+                                    ELSE 0
+                                END
+                            )
+                    FROM wait_deltas AS wd
+                    WHERE wd.wait_time_ms_delta >= 0
+                    GROUP BY
+                        wd.collection_time
+                    ORDER BY
+                        wd.collection_time ASC;";
+            }
+
+            using var command = new SqlCommand(query, connection);
+            command.CommandTimeout = 120;
+            command.Parameters.Add(new SqlParameter("@hours_back", SqlDbType.Int) { Value = -hoursBack });
+            if (fromDate.HasValue) command.Parameters.Add(new SqlParameter("@from_date", SqlDbType.DateTime2) { Value = fromDate.Value });
+            if (toDate.HasValue) command.Parameters.Add(new SqlParameter("@to_date", SqlDbType.DateTime2) { Value = toDate.Value });
+
+            using var reader = await command.ExecuteReaderAsync();
+            while (await reader.ReadAsync())
+            {
+                items.Add(new WaitStatsDataPoint
+                {
+                    CollectionTime = reader.GetDateTime(0),
+                    WaitType = reader.IsDBNull(1) ? string.Empty : reader.GetString(1),
+                    WaitTimeMsPerSecond = reader.IsDBNull(2) ? 0m : Convert.ToDecimal(reader.GetValue(2), CultureInfo.InvariantCulture),
+                    SignalWaitTimeMsPerSecond = reader.IsDBNull(3) ? 0m : Convert.ToDecimal(reader.GetValue(3), CultureInfo.InvariantCulture)
+                });
+            }
+
+            return items;
+        }
     }
 }

From 750c0b93c1e640fc204fa074878330da39b7e254 Mon Sep 17 00:00:00 2001
From: Erik Darling <2136037+erikdarlingdata@users.noreply.github.com>
Date: Mon, 6 Apr 2026 13:48:16 -0400
Subject: [PATCH 15/30] Fix archive compaction OOM on large parquet groups

DuckDB was running out of memory compacting monthly parquet files
(e.g., 4 query_snapshots files needing ~480MB to merge). Three changes:

- Raise DuckDB memory cap from 2GB to 4GB
- Create a fresh DuckDB connection per (month, table) group so memory
  is fully released between groups
- For groups with >2 files, merge incrementally in pairs (smallest-first)
  instead of all at once, reducing peak memory significantly

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
---
 Lite/Services/ArchiveService.cs | 95 +++++++++++++++++++++++++--------
 1 file changed, 72 insertions(+), 23 deletions(-)

diff --git a/Lite/Services/ArchiveService.cs b/Lite/Services/ArchiveService.cs
index 9f5f0bb..d286589 100644
--- a/Lite/Services/ArchiveService.cs
+++ b/Lite/Services/ArchiveService.cs
@@ -305,18 +305,8 @@ private void CompactParquetFiles()
             }
         }
 
-        /* Compact each group that has more than one file (or any non-monthly files) */
-        using var con = new DuckDBConnection("DataSource=:memory:");
-        con.Open();
-
-        /* Cap memory to avoid multi-GB spikes decompressing large parquet archives.
-           DuckDB will spill excess to its temp directory automatically. */
-        using (var pragma = con.CreateCommand())
-        {
-            pragma.CommandText = "SET memory_limit = '2GB'; SET preserve_insertion_order = false;";
-            pragma.ExecuteNonQuery();
-        }
-
+        /* Compact each group that has more than one file (or any non-monthly files).
+           Each group gets its own DuckDB connection so memory is fully released between groups. */
         var totalMerged = 0;
         var totalRemoved = 0;
 
@@ -346,16 +336,16 @@ DuckDB will spill excess to its temp directory automatically. */
                 var sourcePaths = files
                     .Select(f => Path.Combine(_archivePath, f).Replace("\\", "/"))
                     .ToList();
-                var pathList = string.Join(", ", sourcePaths.Select(p => $"'{p}'"));
 
-                /* Build SELECT with column exclusions for specific tables.
-                   Only exclude columns that actually exist in the source files
-                   (they may have been stripped in a previous compaction). */
+                /* Determine column exclusions up front using all source files */
                 var selectClause = "*";
                 if (CompactionExcludeColumns.TryGetValue(table, out var excludeCols))
                 {
-                    using var schemaCmd = con.CreateCommand();
-                    schemaCmd.CommandText = $"SELECT column_name FROM (DESCRIBE SELECT * FROM read_parquet([{pathList}], union_by_name=true))";
+                    using var schemaCon = new DuckDBConnection("DataSource=:memory:");
+                    schemaCon.Open();
+                    var allPathList = string.Join(", ", sourcePaths.Select(p => $"'{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();
                     var existingCols = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
                     while (reader.Read()) existingCols.Add(reader.GetString(0));
@@ -367,10 +357,65 @@ Only exclude columns that actually exist in the source files
                     }
                 }
 
-                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)";
-                cmd.ExecuteNonQuery();
+                if (sourcePaths.Count <= 2)
+                {
+                    /* Small group — single-pass merge */
+                    using var con = new DuckDBConnection("DataSource=:memory:");
+                    con.Open();
+                    using (var pragma = con.CreateCommand())
+                    {
+                        pragma.CommandText = "SET memory_limit = '4GB'; SET preserve_insertion_order = false;";
+                        pragma.ExecuteNonQuery();
+                    }
+
+                    var pathList = string.Join(", ", sourcePaths.Select(p => $"'{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)";
+                    cmd.ExecuteNonQuery();
+                }
+                else
+                {
+                    /* Large group — incremental merge (pairs) to keep peak memory low.
+                       Sort smallest-first so early merges are cheap. */
+                    var sorted = sourcePaths
+                        .OrderBy(p => new FileInfo(p.Replace("/", "\\")).Length)
+                        .ToList();
+
+                    var currentPath = sorted[0];
+                    var intermediateFiles = new List<string>();
+
+                    for (var i = 1; i < sorted.Count; i++)
+                    {
+                        var stepOutput = i < sorted.Count - 1
+                            ? targetPath + $".step{i}.tmp"
+                            : tempPath;
+
+                        using var con = new DuckDBConnection("DataSource=:memory:");
+                        con.Open();
+                        using (var pragma = con.CreateCommand())
+                        {
+                            pragma.CommandText = "SET memory_limit = '4GB'; SET preserve_insertion_order = false;";
+                            pragma.ExecuteNonQuery();
+                        }
+
+                        var pairList = $"'{currentPath}', '{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)";
+                        cmd.ExecuteNonQuery();
+
+                        /* Clean up previous intermediate file */
+                        if (intermediateFiles.Count > 0)
+                        {
+                            var prev = intermediateFiles[^1];
+                            try { File.Delete(prev); } catch { /* best effort */ }
+                        }
+
+                        intermediateFiles.Add(stepOutput);
+                        currentPath = stepOutput;
+                    }
+                }
 
                 /* Remove originals */
                 var removed = 0;
@@ -404,11 +449,15 @@ Only exclude columns that actually exist in the source files
             {
                 _logger?.LogError(ex, "Failed to compact {Month}/{Table} ({Count} files)", month, table, files.Count);
 
-                /* Clean up temp file on failure */
+                /* Clean up temp and intermediate files on failure */
                 if (File.Exists(tempPath))
                 {
                     try { File.Delete(tempPath); } catch { /* best effort */ }
                 }
+                foreach (var stepFile in Directory.GetFiles(_archivePath, $"{targetMonth}_{table}.parquet.step*.tmp"))
+                {
+                    try { File.Delete(stepFile); } catch { /* best effort */ }
+                }
             }
         }
 

From 02608447f04c95cd59a335171d134dfca26b4b6d Mon Sep 17 00:00:00 2001
From: Erik Darling <2136037+erikdarlingdata@users.noreply.github.com>
Date: Mon, 6 Apr 2026 18:50:01 -0400
Subject: [PATCH 16/30] Replace all muted/dim text colors with foreground
 colors for readability

Changes across Dashboard, Lite, and InstallerGui:
- ForegroundDimColor now matches ForegroundColor in all 6 themes
- InstallerGui ForegroundMutedBrush changed to foreground color
- ScottPlot chart text colors (#9DA5B4, #4A5568, #364D61) replaced
  with foreground equivalents (#E4E6EB, #1A1D23, #1A2A3A)
- SlicerLabelBrush changed from 60% opacity to full opacity
- Email template text changed from #808080 to #E4E6EB
- Removed Opacity="0.45" from empty-state icons in ServerTab

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
---
 Dashboard/Controls/TimeRangeSlicerControl.xaml.cs    |  2 +-
 Dashboard/Helpers/TabHelpers.cs                      | 12 ++++++------
 Dashboard/ServerTab.xaml                             |  2 +-
 Dashboard/Services/EmailTemplateBuilder.cs           |  6 +++---
 Dashboard/Themes/CoolBreezeTheme.xaml                |  2 +-
 Dashboard/Themes/DarkTheme.xaml                      |  4 ++--
 Dashboard/Themes/LightTheme.xaml                     |  2 +-
 InstallerGui/App.xaml                                |  2 +-
 InstallerGui/Themes/DarkTheme.xaml                   |  2 +-
 Lite/Controls/CorrelatedTimelineLanesControl.xaml.cs | 12 ++++++------
 Lite/Controls/ServerTab.xaml                         |  2 +-
 Lite/Controls/ServerTab.xaml.cs                      | 12 ++++++------
 Lite/Controls/TimeRangeSlicerControl.xaml.cs         |  2 +-
 Lite/Services/EmailTemplateBuilder.cs                |  6 +++---
 Lite/Themes/CoolBreezeTheme.xaml                     |  2 +-
 Lite/Themes/DarkTheme.xaml                           |  4 ++--
 Lite/Themes/LightTheme.xaml                          |  2 +-
 Lite/Windows/ProcedureHistoryWindow.xaml.cs          |  4 ++--
 Lite/Windows/QueryStatsHistoryWindow.xaml.cs         |  4 ++--
 Lite/Windows/QueryStoreHistoryWindow.xaml.cs         |  4 ++--
 20 files changed, 44 insertions(+), 44 deletions(-)

diff --git a/Dashboard/Controls/TimeRangeSlicerControl.xaml.cs b/Dashboard/Controls/TimeRangeSlicerControl.xaml.cs
index 9d92486..c67c0b2 100644
--- a/Dashboard/Controls/TimeRangeSlicerControl.xaml.cs
+++ b/Dashboard/Controls/TimeRangeSlicerControl.xaml.cs
@@ -213,7 +213,7 @@ public void Redraw()
         SlicerCanvas.Children.Add(new Path { Data = lineGeo, Stroke = lineBrush, StrokeThickness = 1.5 });
 
         // X-axis labels — evenly spaced by TIME across the full range, skip if too close
-        var labelBrush = FindBrush("SlicerLabelBrush", "#99E4E6EB");
+        var labelBrush = FindBrush("SlicerLabelBrush", "#E4E6EB");
         const double minLabelSpacingPx = 90;
         double lastLabelX = -minLabelSpacingPx;
         int targetLabels = Math.Max(2, (int)(w / minLabelSpacingPx));
diff --git a/Dashboard/Helpers/TabHelpers.cs b/Dashboard/Helpers/TabHelpers.cs
index 6a5a736..70f6533 100644
--- a/Dashboard/Helpers/TabHelpers.cs
+++ b/Dashboard/Helpers/TabHelpers.cs
@@ -157,7 +157,7 @@ public static void ApplyThemeToChart(WpfPlot chart)
             {
                 figureBackground = ScottPlot.Color.FromHex("#EEF4FA");
                 dataBackground   = ScottPlot.Color.FromHex("#DAE6F0");
-                textColor        = ScottPlot.Color.FromHex("#364D61");
+                textColor        = ScottPlot.Color.FromHex("#1A2A3A");
                 gridColor        = ScottPlot.Color.FromHex("#A8BDD0").WithAlpha(120);
                 legendBg         = ScottPlot.Color.FromHex("#EEF4FA");
                 legendFg         = ScottPlot.Color.FromHex("#1A2A3A");
@@ -167,7 +167,7 @@ public static void ApplyThemeToChart(WpfPlot chart)
             {
                 figureBackground = ScottPlot.Color.FromHex("#FFFFFF");
                 dataBackground   = ScottPlot.Color.FromHex("#F5F7FA");
-                textColor        = ScottPlot.Color.FromHex("#4A5568");
+                textColor        = ScottPlot.Color.FromHex("#1A1D23");
                 gridColor        = ScottPlot.Colors.Black.WithAlpha(20);
                 legendBg         = ScottPlot.Color.FromHex("#FFFFFF");
                 legendFg         = ScottPlot.Color.FromHex("#1A1D23");
@@ -177,7 +177,7 @@ public static void ApplyThemeToChart(WpfPlot chart)
             {
                 figureBackground = ScottPlot.Color.FromHex("#22252b");
                 dataBackground   = ScottPlot.Color.FromHex("#111217");
-                textColor        = ScottPlot.Color.FromHex("#9DA5B4");
+                textColor        = ScottPlot.Color.FromHex("#E4E6EB");
                 gridColor        = ScottPlot.Colors.White.WithAlpha(40);
                 legendBg         = ScottPlot.Color.FromHex("#22252b");
                 legendFg         = ScottPlot.Color.FromHex("#E4E6EB");
@@ -226,10 +226,10 @@ private static void HandleChartFirstLoaded(object sender, RoutedEventArgs e)
         public static void ReapplyAxisColors(WpfPlot chart)
         {
             var textColor = ThemeManager.CurrentTheme == "CoolBreeze"
-                ? ScottPlot.Color.FromHex("#364D61")
+                ? ScottPlot.Color.FromHex("#1A2A3A")
                 : ThemeManager.HasLightBackground
-                    ? ScottPlot.Color.FromHex("#4A5568")
-                    : ScottPlot.Color.FromHex("#9DA5B4");
+                    ? ScottPlot.Color.FromHex("#1A1D23")
+                    : ScottPlot.Color.FromHex("#E4E6EB");
             chart.Plot.Axes.Bottom.TickLabelStyle.ForeColor = textColor;
             chart.Plot.Axes.Left.TickLabelStyle.ForeColor = textColor;
             chart.Plot.Axes.Bottom.Label.ForeColor = textColor;
diff --git a/Dashboard/ServerTab.xaml b/Dashboard/ServerTab.xaml
index 9ff26d3..e1d831b 100644
--- a/Dashboard/ServerTab.xaml
+++ b/Dashboard/ServerTab.xaml
@@ -429,7 +429,7 @@
                         <StackPanel HorizontalAlignment="Center" VerticalAlignment="Center">
                             <TextBlock Text="&#xE896;" FontFamily="Segoe MDL2 Assets" FontSize="52"
                                        HorizontalAlignment="Center"
-                                       Foreground="{DynamicResource ForegroundMutedBrush}" Opacity="0.45"
+                                       Foreground="{DynamicResource ForegroundMutedBrush}"
                                        Margin="0,0,0,12"/>
                             <TextBlock Text="No Plan Loaded" FontSize="20" FontWeight="Light"
                                        Foreground="{DynamicResource ForegroundMutedBrush}" HorizontalAlignment="Center"/>
diff --git a/Dashboard/Services/EmailTemplateBuilder.cs b/Dashboard/Services/EmailTemplateBuilder.cs
index c2b9efb..c76ceff 100644
--- a/Dashboard/Services/EmailTemplateBuilder.cs
+++ b/Dashboard/Services/EmailTemplateBuilder.cs
@@ -116,7 +116,7 @@ private static string BuildHtmlBody(
             sb.Append($"<table role=\"presentation\" cellpadding=\"0\" cellspacing=\"0\" border=\"0\" width=\"100%\">");
             sb.Append("<tr><td>");
             sb.Append($"<span style=\"font-family:{FontStack};font-size:18px;font-weight:600;color:#FFFFFF;\">SQL Server Performance Monitor</span><br>");
-            sb.Append($"<span style=\"font-family:{FontStack};font-size:12px;color:#808080;\">{WebUtility.HtmlEncode(EditionName)}</span>");
+            sb.Append($"<span style=\"font-family:{FontStack};font-size:12px;color:#E4E6EB;\">{WebUtility.HtmlEncode(EditionName)}</span>");
             sb.Append("</td></tr></table>");
             sb.Append("</td></tr>");
 
@@ -167,7 +167,7 @@ private static string BuildHtmlBody(
             /* Footer */
             sb.Append("<tr><td style=\"padding:0 24px;\"><table role=\"presentation\" cellpadding=\"0\" cellspacing=\"0\" border=\"0\" width=\"100%\"><tr><td style=\"height:1px;background-color:#404040;font-size:0;line-height:0;\">&nbsp;</td></tr></table></td></tr>");
             sb.Append("<tr><td style=\"padding:12px 24px 16px 24px;\">");
-            sb.Append($"<span style=\"font-family:{FontStack};font-size:11px;color:#808080;\">");
+            sb.Append($"<span style=\"font-family:{FontStack};font-size:11px;color:#E4E6EB;\">");
             sb.Append($"Sent by {WebUtility.HtmlEncode(EditionName)}");
             if (!isTest)
             {
@@ -200,7 +200,7 @@ private static void AppendDetailSection(StringBuilder sb, AlertContext context)
             /* Separator + heading */
             sb.Append("<tr><td style=\"padding:0 24px;\"><table role=\"presentation\" cellpadding=\"0\" cellspacing=\"0\" border=\"0\" width=\"100%\"><tr><td style=\"height:1px;background-color:#404040;font-size:0;line-height:0;\">&nbsp;</td></tr></table></td></tr>");
             sb.Append("<tr><td style=\"padding:12px 24px 4px 24px;\">");
-            sb.Append($"<span style=\"font-family:{FontStack};font-size:13px;font-weight:600;color:#808080;letter-spacing:0.5px;\">RECENT EVENTS</span>");
+            sb.Append($"<span style=\"font-family:{FontStack};font-size:13px;font-weight:600;color:#E4E6EB;letter-spacing:0.5px;\">RECENT EVENTS</span>");
             sb.Append("</td></tr>");
 
             foreach (var item in context.Details)
diff --git a/Dashboard/Themes/CoolBreezeTheme.xaml b/Dashboard/Themes/CoolBreezeTheme.xaml
index ab50dea..4eb7002 100644
--- a/Dashboard/Themes/CoolBreezeTheme.xaml
+++ b/Dashboard/Themes/CoolBreezeTheme.xaml
@@ -22,7 +22,7 @@
 
     <!-- Text Colors (dark on light backgrounds) -->
     <Color x:Key="ForegroundColor">#1A2A3A</Color>
-    <Color x:Key="ForegroundDimColor">#364D61</Color>
+    <Color x:Key="ForegroundDimColor">#1A2A3A</Color>
     <Color x:Key="ForegroundMutedColor">#5B7A90</Color>
 
     <!-- Border Colors (subtle, low-contrast) -->
diff --git a/Dashboard/Themes/DarkTheme.xaml b/Dashboard/Themes/DarkTheme.xaml
index 4451911..73cc58c 100644
--- a/Dashboard/Themes/DarkTheme.xaml
+++ b/Dashboard/Themes/DarkTheme.xaml
@@ -22,7 +22,7 @@
 
     <!-- Text Colors (off-white to reduce eye strain) -->
     <Color x:Key="ForegroundColor">#E4E6EB</Color>
-    <Color x:Key="ForegroundDimColor">#9DA5B4</Color>
+    <Color x:Key="ForegroundDimColor">#E4E6EB</Color>
     <Color x:Key="ForegroundMutedColor">#6B7280</Color>
 
     <!-- Border Colors (subtle, low-contrast) -->
@@ -1265,7 +1265,7 @@
     <SolidColorBrush x:Key="SlicerSelectedBrush" Color="#22FFFFFF"/>
     <SolidColorBrush x:Key="SlicerHandleBrush" Color="#E4E6EB"/>
     <SolidColorBrush x:Key="SlicerBorderBrush" Color="#3A3D45"/>
-    <SolidColorBrush x:Key="SlicerLabelBrush" Color="#99E4E6EB"/>
+    <SolidColorBrush x:Key="SlicerLabelBrush" Color="#E4E6EB"/>
     <SolidColorBrush x:Key="SlicerToggleBrush" Color="#E4E6EB"/>
 
 </ResourceDictionary>
diff --git a/Dashboard/Themes/LightTheme.xaml b/Dashboard/Themes/LightTheme.xaml
index 882619f..b2fff24 100644
--- a/Dashboard/Themes/LightTheme.xaml
+++ b/Dashboard/Themes/LightTheme.xaml
@@ -22,7 +22,7 @@
 
     <!-- Text Colors (dark on light backgrounds) -->
     <Color x:Key="ForegroundColor">#1A1D23</Color>
-    <Color x:Key="ForegroundDimColor">#4A5568</Color>
+    <Color x:Key="ForegroundDimColor">#1A1D23</Color>
     <Color x:Key="ForegroundMutedColor">#718096</Color>
 
     <!-- Border Colors (subtle, low-contrast) -->
diff --git a/InstallerGui/App.xaml b/InstallerGui/App.xaml
index 7c9deaa..f28634d 100644
--- a/InstallerGui/App.xaml
+++ b/InstallerGui/App.xaml
@@ -14,7 +14,7 @@
         <SolidColorBrush x:Key="BackgroundLighterBrush" Color="#4a4a4a"/>
 
         <SolidColorBrush x:Key="ForegroundBrush" Color="#FFFFFF"/>
-        <SolidColorBrush x:Key="ForegroundMutedBrush" Color="#858585"/>
+        <SolidColorBrush x:Key="ForegroundMutedBrush" Color="#FFFFFF"/>
 
         <SolidColorBrush x:Key="BorderBrush" Color="#555555"/>
 
diff --git a/InstallerGui/Themes/DarkTheme.xaml b/InstallerGui/Themes/DarkTheme.xaml
index 2b9092e..7e8d026 100644
--- a/InstallerGui/Themes/DarkTheme.xaml
+++ b/InstallerGui/Themes/DarkTheme.xaml
@@ -17,7 +17,7 @@
     <SolidColorBrush x:Key="BackgroundLighterBrush" Color="#2a2d35"/>
 
     <SolidColorBrush x:Key="ForegroundBrush" Color="#E4E6EB"/>
-    <SolidColorBrush x:Key="ForegroundMutedBrush" Color="#6B7280"/>
+    <SolidColorBrush x:Key="ForegroundMutedBrush" Color="#E4E6EB"/>
 
     <SolidColorBrush x:Key="BorderBrush" Color="#2a2d35"/>
 
diff --git a/Lite/Controls/CorrelatedTimelineLanesControl.xaml.cs b/Lite/Controls/CorrelatedTimelineLanesControl.xaml.cs
index 5f4e01d..04cfc77 100644
--- a/Lite/Controls/CorrelatedTimelineLanesControl.xaml.cs
+++ b/Lite/Controls/CorrelatedTimelineLanesControl.xaml.cs
@@ -332,21 +332,21 @@ private static void ApplyTheme(ScottPlot.WPF.WpfPlot chart)
         {
             figureBackground = ScottPlot.Color.FromHex("#EEF4FA");
             dataBackground   = ScottPlot.Color.FromHex("#DAE6F0");
-            textColor        = ScottPlot.Color.FromHex("#364D61");
+            textColor        = ScottPlot.Color.FromHex("#1A2A3A");
             gridColor        = ScottPlot.Color.FromHex("#A8BDD0").WithAlpha(120);
         }
         else if (ThemeManager.HasLightBackground)
         {
             figureBackground = ScottPlot.Color.FromHex("#FFFFFF");
             dataBackground   = ScottPlot.Color.FromHex("#F5F7FA");
-            textColor        = ScottPlot.Color.FromHex("#4A5568");
+            textColor        = ScottPlot.Color.FromHex("#1A1D23");
             gridColor        = ScottPlot.Colors.Black.WithAlpha(20);
         }
         else
         {
             figureBackground = ScottPlot.Color.FromHex("#22252b");
             dataBackground   = ScottPlot.Color.FromHex("#111217");
-            textColor        = ScottPlot.Color.FromHex("#9DA5B4");
+            textColor        = ScottPlot.Color.FromHex("#E4E6EB");
             gridColor        = ScottPlot.Colors.White.WithAlpha(40);
         }
 
@@ -368,10 +368,10 @@ private static void ApplyTheme(ScottPlot.WPF.WpfPlot chart)
     private static void ReapplyAxisColors(ScottPlot.WPF.WpfPlot chart)
     {
         var textColor = ThemeManager.CurrentTheme == "CoolBreeze"
-            ? ScottPlot.Color.FromHex("#364D61")
+            ? ScottPlot.Color.FromHex("#1A2A3A")
             : ThemeManager.HasLightBackground
-                ? ScottPlot.Color.FromHex("#4A5568")
-                : ScottPlot.Color.FromHex("#9DA5B4");
+                ? ScottPlot.Color.FromHex("#1A1D23")
+                : ScottPlot.Color.FromHex("#E4E6EB");
         chart.Plot.Axes.Bottom.TickLabelStyle.ForeColor = textColor;
         chart.Plot.Axes.Left.TickLabelStyle.ForeColor = textColor;
         chart.Plot.Axes.Bottom.Label.ForeColor = textColor;
diff --git a/Lite/Controls/ServerTab.xaml b/Lite/Controls/ServerTab.xaml
index 37e079c..a845687 100644
--- a/Lite/Controls/ServerTab.xaml
+++ b/Lite/Controls/ServerTab.xaml
@@ -738,7 +738,7 @@
                         <StackPanel HorizontalAlignment="Center" VerticalAlignment="Center">
                             <TextBlock Text="&#xE896;" FontFamily="Segoe MDL2 Assets" FontSize="52"
                                        HorizontalAlignment="Center"
-                                       Foreground="{DynamicResource ForegroundMutedBrush}" Opacity="0.45"
+                                       Foreground="{DynamicResource ForegroundMutedBrush}"
                                        Margin="0,0,0,12"/>
                             <TextBlock Text="No Plan Loaded" FontSize="20" FontWeight="Light"
                                        Foreground="{DynamicResource ForegroundMutedBrush}" HorizontalAlignment="Center"/>
diff --git a/Lite/Controls/ServerTab.xaml.cs b/Lite/Controls/ServerTab.xaml.cs
index 5f6869d..19cc0c8 100644
--- a/Lite/Controls/ServerTab.xaml.cs
+++ b/Lite/Controls/ServerTab.xaml.cs
@@ -3619,7 +3619,7 @@ private static void ApplyTheme(ScottPlot.WPF.WpfPlot chart)
         {
             figureBackground = ScottPlot.Color.FromHex("#EEF4FA");
             dataBackground   = ScottPlot.Color.FromHex("#DAE6F0");
-            textColor        = ScottPlot.Color.FromHex("#364D61");
+            textColor        = ScottPlot.Color.FromHex("#1A2A3A");
             gridColor        = ScottPlot.Color.FromHex("#A8BDD0").WithAlpha(120);
             legendBg         = ScottPlot.Color.FromHex("#EEF4FA");
             legendFg         = ScottPlot.Color.FromHex("#1A2A3A");
@@ -3629,7 +3629,7 @@ private static void ApplyTheme(ScottPlot.WPF.WpfPlot chart)
         {
             figureBackground = ScottPlot.Color.FromHex("#FFFFFF");
             dataBackground   = ScottPlot.Color.FromHex("#F5F7FA");
-            textColor        = ScottPlot.Color.FromHex("#4A5568");
+            textColor        = ScottPlot.Color.FromHex("#1A1D23");
             gridColor        = ScottPlot.Colors.Black.WithAlpha(20);
             legendBg         = ScottPlot.Color.FromHex("#FFFFFF");
             legendFg         = ScottPlot.Color.FromHex("#1A1D23");
@@ -3639,7 +3639,7 @@ private static void ApplyTheme(ScottPlot.WPF.WpfPlot chart)
         {
             figureBackground = ScottPlot.Color.FromHex("#22252b");
             dataBackground   = ScottPlot.Color.FromHex("#111217");
-            textColor        = ScottPlot.Color.FromHex("#9DA5B4");
+            textColor        = ScottPlot.Color.FromHex("#E4E6EB");
             gridColor        = ScottPlot.Colors.White.WithAlpha(40);
             legendBg         = ScottPlot.Color.FromHex("#22252b");
             legendFg         = ScottPlot.Color.FromHex("#E4E6EB");
@@ -3710,10 +3710,10 @@ private void OnThemeChanged(string _)
     private static void ReapplyAxisColors(ScottPlot.WPF.WpfPlot chart)
     {
         var textColor = Helpers.ThemeManager.CurrentTheme == "CoolBreeze"
-            ? ScottPlot.Color.FromHex("#364D61")
+            ? ScottPlot.Color.FromHex("#1A2A3A")
             : Helpers.ThemeManager.HasLightBackground
-                ? ScottPlot.Color.FromHex("#4A5568")
-                : ScottPlot.Color.FromHex("#9DA5B4");
+                ? ScottPlot.Color.FromHex("#1A1D23")
+                : ScottPlot.Color.FromHex("#E4E6EB");
         chart.Plot.Axes.Bottom.TickLabelStyle.ForeColor = textColor;
         chart.Plot.Axes.Left.TickLabelStyle.ForeColor = textColor;
         chart.Plot.Axes.Bottom.Label.ForeColor = textColor;
diff --git a/Lite/Controls/TimeRangeSlicerControl.xaml.cs b/Lite/Controls/TimeRangeSlicerControl.xaml.cs
index 99d3077..2ac759d 100644
--- a/Lite/Controls/TimeRangeSlicerControl.xaml.cs
+++ b/Lite/Controls/TimeRangeSlicerControl.xaml.cs
@@ -229,7 +229,7 @@ public void Redraw()
         SlicerCanvas.Children.Add(new Path { Data = lineGeo, Stroke = lineBrush, StrokeThickness = 1.5 });
 
         // X-axis labels — evenly spaced by TIME, skip if too close
-        var labelBrush = FindBrush("SlicerLabelBrush", "#99E4E6EB");
+        var labelBrush = FindBrush("SlicerLabelBrush", "#E4E6EB");
         const double minLabelSpacingPx = 90;
         double lastLabelX = -minLabelSpacingPx;
         int targetLabels = Math.Max(2, (int)(w / minLabelSpacingPx));
diff --git a/Lite/Services/EmailTemplateBuilder.cs b/Lite/Services/EmailTemplateBuilder.cs
index 7dd5596..744d24d 100644
--- a/Lite/Services/EmailTemplateBuilder.cs
+++ b/Lite/Services/EmailTemplateBuilder.cs
@@ -116,7 +116,7 @@ private static string BuildHtmlBody(
         sb.Append($"<table role=\"presentation\" cellpadding=\"0\" cellspacing=\"0\" border=\"0\" width=\"100%\">");
         sb.Append("<tr><td>");
         sb.Append($"<span style=\"font-family:{FontStack};font-size:18px;font-weight:600;color:#FFFFFF;\">SQL Server Performance Monitor</span><br>");
-        sb.Append($"<span style=\"font-family:{FontStack};font-size:12px;color:#808080;\">{WebUtility.HtmlEncode(EditionName)}</span>");
+        sb.Append($"<span style=\"font-family:{FontStack};font-size:12px;color:#E4E6EB;\">{WebUtility.HtmlEncode(EditionName)}</span>");
         sb.Append("</td></tr></table>");
         sb.Append("</td></tr>");
 
@@ -167,7 +167,7 @@ private static string BuildHtmlBody(
         /* Footer */
         sb.Append("<tr><td style=\"padding:0 24px;\"><table role=\"presentation\" cellpadding=\"0\" cellspacing=\"0\" border=\"0\" width=\"100%\"><tr><td style=\"height:1px;background-color:#404040;font-size:0;line-height:0;\">&nbsp;</td></tr></table></td></tr>");
         sb.Append("<tr><td style=\"padding:12px 24px 16px 24px;\">");
-        sb.Append($"<span style=\"font-family:{FontStack};font-size:11px;color:#808080;\">");
+        sb.Append($"<span style=\"font-family:{FontStack};font-size:11px;color:#E4E6EB;\">");
         sb.Append($"Sent by {WebUtility.HtmlEncode(EditionName)}");
         if (!isTest)
         {
@@ -200,7 +200,7 @@ private static void AppendDetailSection(StringBuilder sb, AlertContext context)
         /* Separator + heading */
         sb.Append("<tr><td style=\"padding:0 24px;\"><table role=\"presentation\" cellpadding=\"0\" cellspacing=\"0\" border=\"0\" width=\"100%\"><tr><td style=\"height:1px;background-color:#404040;font-size:0;line-height:0;\">&nbsp;</td></tr></table></td></tr>");
         sb.Append("<tr><td style=\"padding:12px 24px 4px 24px;\">");
-        sb.Append($"<span style=\"font-family:{FontStack};font-size:13px;font-weight:600;color:#808080;letter-spacing:0.5px;\">RECENT EVENTS</span>");
+        sb.Append($"<span style=\"font-family:{FontStack};font-size:13px;font-weight:600;color:#E4E6EB;letter-spacing:0.5px;\">RECENT EVENTS</span>");
         sb.Append("</td></tr>");
 
         foreach (var item in context.Details)
diff --git a/Lite/Themes/CoolBreezeTheme.xaml b/Lite/Themes/CoolBreezeTheme.xaml
index 6bd705d..739f20b 100644
--- a/Lite/Themes/CoolBreezeTheme.xaml
+++ b/Lite/Themes/CoolBreezeTheme.xaml
@@ -22,7 +22,7 @@
 
     <!-- Text Colors (dark on light backgrounds) -->
     <Color x:Key="ForegroundColor">#1A2A3A</Color>
-    <Color x:Key="ForegroundDimColor">#364D61</Color>
+    <Color x:Key="ForegroundDimColor">#1A2A3A</Color>
     <Color x:Key="ForegroundMutedColor">#5B7A90</Color>
 
     <!-- Border Colors (subtle, low-contrast) -->
diff --git a/Lite/Themes/DarkTheme.xaml b/Lite/Themes/DarkTheme.xaml
index 014635c..db5aac5 100644
--- a/Lite/Themes/DarkTheme.xaml
+++ b/Lite/Themes/DarkTheme.xaml
@@ -22,7 +22,7 @@
 
     <!-- Text Colors (off-white to reduce eye strain) -->
     <Color x:Key="ForegroundColor">#E4E6EB</Color>
-    <Color x:Key="ForegroundDimColor">#9DA5B4</Color>
+    <Color x:Key="ForegroundDimColor">#E4E6EB</Color>
     <Color x:Key="ForegroundMutedColor">#6B7280</Color>
 
     <!-- Border Colors (subtle, low-contrast) -->
@@ -1213,7 +1213,7 @@
     <SolidColorBrush x:Key="SlicerSelectedBrush" Color="#22FFFFFF"/>
     <SolidColorBrush x:Key="SlicerHandleBrush" Color="#E4E6EB"/>
     <SolidColorBrush x:Key="SlicerBorderBrush" Color="#3A3D45"/>
-    <SolidColorBrush x:Key="SlicerLabelBrush" Color="#99E4E6EB"/>
+    <SolidColorBrush x:Key="SlicerLabelBrush" Color="#E4E6EB"/>
     <SolidColorBrush x:Key="SlicerToggleBrush" Color="#E4E6EB"/>
 
 </ResourceDictionary>
diff --git a/Lite/Themes/LightTheme.xaml b/Lite/Themes/LightTheme.xaml
index dc2dab7..063b352 100644
--- a/Lite/Themes/LightTheme.xaml
+++ b/Lite/Themes/LightTheme.xaml
@@ -22,7 +22,7 @@
 
     <!-- Text Colors (dark on light backgrounds) -->
     <Color x:Key="ForegroundColor">#1A1D23</Color>
-    <Color x:Key="ForegroundDimColor">#4A5568</Color>
+    <Color x:Key="ForegroundDimColor">#1A1D23</Color>
     <Color x:Key="ForegroundMutedColor">#718096</Color>
 
     <!-- Border Colors (subtle, low-contrast) -->
diff --git a/Lite/Windows/ProcedureHistoryWindow.xaml.cs b/Lite/Windows/ProcedureHistoryWindow.xaml.cs
index 4f94966..4ecbd89 100644
--- a/Lite/Windows/ProcedureHistoryWindow.xaml.cs
+++ b/Lite/Windows/ProcedureHistoryWindow.xaml.cs
@@ -134,14 +134,14 @@ private static void ApplyTheme(ScottPlot.WPF.WpfPlot chart)
         {
             figureBackground = ScottPlot.Color.FromHex("#FFFFFF");
             dataBackground   = ScottPlot.Color.FromHex("#F5F7FA");
-            textColor        = ScottPlot.Color.FromHex("#4A5568");
+            textColor        = ScottPlot.Color.FromHex("#1A1D23");
             gridColor        = ScottPlot.Colors.Black.WithAlpha(20);
         }
         else
         {
             figureBackground = ScottPlot.Color.FromHex("#22252b");
             dataBackground   = ScottPlot.Color.FromHex("#111217");
-            textColor        = ScottPlot.Color.FromHex("#9DA5B4");
+            textColor        = ScottPlot.Color.FromHex("#E4E6EB");
             gridColor        = ScottPlot.Colors.White.WithAlpha(40);
         }
         chart.Plot.FigureBackground.Color = figureBackground;
diff --git a/Lite/Windows/QueryStatsHistoryWindow.xaml.cs b/Lite/Windows/QueryStatsHistoryWindow.xaml.cs
index c78c005..97bce98 100644
--- a/Lite/Windows/QueryStatsHistoryWindow.xaml.cs
+++ b/Lite/Windows/QueryStatsHistoryWindow.xaml.cs
@@ -191,14 +191,14 @@ private static void ApplyTheme(ScottPlot.WPF.WpfPlot chart)
         {
             figureBackground = ScottPlot.Color.FromHex("#FFFFFF");
             dataBackground   = ScottPlot.Color.FromHex("#F5F7FA");
-            textColor        = ScottPlot.Color.FromHex("#4A5568");
+            textColor        = ScottPlot.Color.FromHex("#1A1D23");
             gridColor        = ScottPlot.Colors.Black.WithAlpha(20);
         }
         else
         {
             figureBackground = ScottPlot.Color.FromHex("#22252b");
             dataBackground   = ScottPlot.Color.FromHex("#111217");
-            textColor        = ScottPlot.Color.FromHex("#9DA5B4");
+            textColor        = ScottPlot.Color.FromHex("#E4E6EB");
             gridColor        = ScottPlot.Colors.White.WithAlpha(40);
         }
         chart.Plot.FigureBackground.Color = figureBackground;
diff --git a/Lite/Windows/QueryStoreHistoryWindow.xaml.cs b/Lite/Windows/QueryStoreHistoryWindow.xaml.cs
index d3ccf71..00c1fbb 100644
--- a/Lite/Windows/QueryStoreHistoryWindow.xaml.cs
+++ b/Lite/Windows/QueryStoreHistoryWindow.xaml.cs
@@ -172,14 +172,14 @@ private static void ApplyTheme(ScottPlot.WPF.WpfPlot chart)
         {
             figureBackground = ScottPlot.Color.FromHex("#FFFFFF");
             dataBackground   = ScottPlot.Color.FromHex("#F5F7FA");
-            textColor        = ScottPlot.Color.FromHex("#4A5568");
+            textColor        = ScottPlot.Color.FromHex("#1A1D23");
             gridColor        = ScottPlot.Colors.Black.WithAlpha(20);
         }
         else
         {
             figureBackground = ScottPlot.Color.FromHex("#22252b");
             dataBackground   = ScottPlot.Color.FromHex("#111217");
-            textColor        = ScottPlot.Color.FromHex("#9DA5B4");
+            textColor        = ScottPlot.Color.FromHex("#E4E6EB");
             gridColor        = ScottPlot.Colors.White.WithAlpha(40);
         }
         chart.Plot.FigureBackground.Color = figureBackground;

From 9acf4f60a2711b88ca2334bc8b2ca02f45ebc167 Mon Sep 17 00:00:00 2001
From: Erik Darling <2136037+erikdarlingdata@users.noreply.github.com>
Date: Mon, 6 Apr 2026 21:44:06 -0400
Subject: [PATCH 17/30] Add dynamic baselines and anomaly detection to Lite
 (#692, #693)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Phase 1-3 of the baselines plan for Lite:

Engine:
- BaselineProvider: 30-day rolling baselines bucketed by hour-of-day x day-of-week
  with bucket collapse (full → hour-only → flat) and hysteresis (10/15 thresholds)
- Restart poisoning exclusion for cumulative metrics (batch requests, wait stats,
  query duration) using QUALIFY + LAG heuristic in DuckDB
- 4 existing anomaly detectors upgraded from flat 24h lookback to time-bucketed
- 4 new detectors: batch requests/sec, session counts, query duration, memory
- Per-metric configurable deviation thresholds (default 2σ)
- Proportional stddev floor (max(stddev, mean*0.01)) for division-by-zero
- Fix BigInteger cast error on DuckDB SUM() for session/query duration detectors

MCP:
- analyze_server: baseline context in anomaly findings output
- compare_analysis: updated description noting time-bucketed baselines
- Anomaly fact metadata includes baseline_hour, baseline_dow, baseline_tier

UI (Overview tab):
- Baseline bands (mean ± 2σ) on CPU, Wait Stats, I/O Latency, Blocking lanes
- Red anomaly dots for values outside band (with absolute minimum thresholds)
- Tooltip ▲/▼ indicators (colored red/green) for anomalous values
- "Compare to" dropdown: overlay yesterday/last week as dashed ghost lines
- Right-side value labels removed, charts expanded to full width
- Memory lane renamed to "Buffer Pool MB"
- Blocking/Deadlocks shown on separate lines in tooltip

Tests:
- 15 BaselineProvider tests (buckets, collapse, hysteresis, restart poisoning,
  division-by-zero, cache, server isolation, memory)
- 10 AnomalyDetector tests (all new detectors, per-metric thresholds, metadata)
- 257/257 total tests passing

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
---
 Lite.Tests/AnomalyDetectorTests.cs            |  493 +++++++
 Lite.Tests/BaselineProviderTests.cs           |  481 ++++++
 Lite.Tests/ScenarioTests.cs                   |    2 +-
 Lite/Analysis/AnalysisModels.cs               |    7 +
 Lite/Analysis/AnalysisService.cs              |    6 +-
 Lite/Analysis/AnomalyDetector.cs              | 1308 ++++++++++-------
 Lite/Analysis/BaselineProvider.cs             |  544 +++++++
 Lite/Analysis/FactScorer.cs                   |    9 +-
 Lite/Analysis/FindingStore.cs                 |    3 +-
 Lite/Analysis/InferenceEngine.cs              |    3 +-
 .../CorrelatedTimelineLanesControl.xaml       |   24 +-
 .../CorrelatedTimelineLanesControl.xaml.cs    |  188 ++-
 Lite/Controls/ServerTab.xaml                  |   10 +
 Lite/Controls/ServerTab.xaml.cs               |   57 +-
 Lite/Helpers/CorrelatedCrosshairManager.cs    |  107 +-
 Lite/Mcp/McpAnalysisTools.cs                  |   48 +-
 Lite/Services/LocalDataService.Baselines.cs   |   32 +
 17 files changed, 2721 insertions(+), 601 deletions(-)
 create mode 100644 Lite.Tests/AnomalyDetectorTests.cs
 create mode 100644 Lite.Tests/BaselineProviderTests.cs
 create mode 100644 Lite/Analysis/BaselineProvider.cs
 create mode 100644 Lite/Services/LocalDataService.Baselines.cs

diff --git a/Lite.Tests/AnomalyDetectorTests.cs b/Lite.Tests/AnomalyDetectorTests.cs
new file mode 100644
index 0000000..1efdab9
--- /dev/null
+++ b/Lite.Tests/AnomalyDetectorTests.cs
@@ -0,0 +1,493 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Threading.Tasks;
+using DuckDB.NET.Data;
+using PerformanceMonitorLite.Analysis;
+using PerformanceMonitorLite.Database;
+using Xunit;
+
+namespace PerformanceMonitorLite.Tests;
+
+/// <summary>
+/// Tests for the upgraded AnomalyDetector: time-bucketed baselines, new detection
+/// methods (batch requests, sessions, query duration, memory), per-metric thresholds,
+/// and baseline context metadata.
+/// </summary>
+public class AnomalyDetectorTests : IDisposable
+{
+    private readonly string _tempDir;
+    private readonly DuckDbInitializer _duckDb;
+    private readonly BaselineProvider _baselineProvider;
+    private readonly AnomalyDetector _detector;
+
+    private const int ServerId = -999;
+    private const string ServerName = "TestServer";
+
+    // Fixed timestamps for deterministic testing
+    private static readonly DateTime _now = DateTime.UtcNow;
+    private static readonly DateTime _analysisEnd = _now;
+    private static readonly DateTime _analysisStart = _now.AddHours(-4);
+
+    private long _nextId = -1;
+
+    public AnomalyDetectorTests()
+    {
+        _tempDir = Path.Combine(Path.GetTempPath(), "AnomalyTests_" + Guid.NewGuid().ToString("N")[..8]);
+        Directory.CreateDirectory(_tempDir);
+        var dbPath = Path.Combine(_tempDir, "test.duckdb");
+        _duckDb = new DuckDbInitializer(dbPath);
+        _baselineProvider = new BaselineProvider(_duckDb);
+        _detector = new AnomalyDetector(_duckDb, _baselineProvider);
+        BaselineProvider.CacheTtl = TimeSpan.FromMilliseconds(1);
+    }
+
+    public void Dispose()
+    {
+        try
+        {
+            if (Directory.Exists(_tempDir))
+                Directory.Delete(_tempDir, recursive: true);
+        }
+        catch { }
+    }
+
+    private AnalysisContext CreateContext() => new()
+    {
+        ServerId = ServerId,
+        ServerName = ServerName,
+        TimeRangeStart = _analysisStart,
+        TimeRangeEnd = _analysisEnd
+    };
+
+    // ── Batch Requests ──
+
+    [Fact]
+    public async Task DetectBatchRequestAnomalies_Spike_DetectsAnomaly()
+    {
+        await _duckDb.InitializeAsync();
+
+        // Baseline: normal batch requests (~5000)
+        await SeedBaselinePerfmon("Batch Requests/sec", 5000, variance: 200);
+
+        // Analysis window: spike to 15000
+        for (int i = 0; i < 16; i++)
+            await SeedPerfmonAsync(_analysisStart.AddMinutes(i * 15), "Batch Requests/sec", 15000);
+
+        // Need wait/cpu data for HasBaselineDataAsync
+        await SeedBaselineCpu(10, variance: 2);
+
+        var anomalies = await _detector.DetectAnomaliesAsync(CreateContext());
+
+        Assert.Contains(anomalies, f => f.Key == "ANOMALY_BATCH_REQUESTS");
+        var fact = anomalies.First(f => f.Key == "ANOMALY_BATCH_REQUESTS");
+        Assert.True(fact.Metadata["deviation_sigma"] >= 2.0);
+        Assert.True(fact.Metadata.ContainsKey("baseline_hour"));
+        Assert.True(fact.Metadata.ContainsKey("baseline_dow"));
+        Assert.True(fact.Metadata.ContainsKey("baseline_tier"));
+    }
+
+    [Fact]
+    public async Task DetectBatchRequestAnomalies_Normal_NoAnomaly()
+    {
+        await _duckDb.InitializeAsync();
+
+        await SeedBaselinePerfmon("Batch Requests/sec", 5000, variance: 200);
+
+        // Analysis window: same as baseline
+        for (int i = 0; i < 16; i++)
+            await SeedPerfmonAsync(_analysisStart.AddMinutes(i * 15), "Batch Requests/sec", 5000);
+
+        await SeedBaselineCpu(10, variance: 2);
+
+        var anomalies = await _detector.DetectAnomaliesAsync(CreateContext());
+
+        Assert.DoesNotContain(anomalies, f => f.Key == "ANOMALY_BATCH_REQUESTS");
+    }
+
+    // ── Session Count ──
+
+    [Fact]
+    public async Task DetectSessionAnomalies_Spike_DetectsAnomaly()
+    {
+        await _duckDb.InitializeAsync();
+
+        // Baseline: ~20 connections
+        await SeedBaselineSessions(20, variance: 2);
+
+        // Analysis window: spike to 200 connections
+        for (int i = 0; i < 16; i++)
+        {
+            var t = _analysisStart.AddMinutes(i * 15);
+            await SeedSessionStatAsync(t, "App1", 150);
+            await SeedSessionStatAsync(t, "App2", 50);
+        }
+
+        await SeedBaselineCpu(10, variance: 2);
+        // CPU data in analysis window (needed for HasBaselineDataAsync and CPU detector to not exit early)
+        for (int i = 0; i < 4; i++)
+            await SeedCpuAsync(_analysisStart.AddMinutes(i * 15), 10);
+
+        var anomalies = await _detector.DetectAnomaliesAsync(CreateContext());
+
+        Assert.Contains(anomalies, f => f.Key == "ANOMALY_SESSION_SPIKE");
+    }
+
+    [Fact]
+    public async Task DetectSessionAnomalies_Normal_NoAnomaly()
+    {
+        await _duckDb.InitializeAsync();
+
+        await SeedBaselineSessions(20, variance: 2);
+
+        // Analysis window: same as baseline
+        for (int i = 0; i < 16; i++)
+        {
+            var t = _analysisStart.AddMinutes(i * 15);
+            await SeedSessionStatAsync(t, "App1", 15);
+            await SeedSessionStatAsync(t, "App2", 5);
+        }
+
+        await SeedBaselineCpu(10, variance: 2);
+
+        var anomalies = await _detector.DetectAnomaliesAsync(CreateContext());
+
+        Assert.DoesNotContain(anomalies, f => f.Key == "ANOMALY_SESSION_SPIKE");
+    }
+
+    // ── Query Duration ──
+
+    [Fact]
+    public async Task DetectQueryDurationAnomalies_Spike_DetectsAnomaly()
+    {
+        await _duckDb.InitializeAsync();
+
+        // Baseline: ~10000 microseconds total elapsed per collection
+        await SeedBaselineQueryStats(10_000, variance: 1000);
+
+        // Analysis window: spike to 500000 microseconds
+        for (int i = 0; i < 16; i++)
+            await SeedQueryStatAsync(_analysisStart.AddMinutes(i * 15), 500_000, 100);
+
+        await SeedBaselineCpu(10, variance: 2);
+        await SeedBaselineWaits();
+
+        var anomalies = await _detector.DetectAnomaliesAsync(CreateContext());
+
+        Assert.Contains(anomalies, f => f.Key == "ANOMALY_QUERY_DURATION");
+    }
+
+    // ── Memory Pressure ──
+
+    [Fact]
+    public async Task DetectMemoryAnomalies_HighPressure_DetectsAnomaly()
+    {
+        await _duckDb.InitializeAsync();
+
+        // Baseline: ~70% memory pressure
+        await SeedBaselineMemory(70_000, 100_000);
+
+        // Analysis window: spike to 99%
+        for (int i = 0; i < 16; i++)
+            await SeedMemoryStatAsync(_analysisStart.AddMinutes(i * 15), 99_000, 100_000);
+
+        await SeedBaselineCpu(10, variance: 2);
+
+        var anomalies = await _detector.DetectAnomaliesAsync(CreateContext());
+
+        Assert.Contains(anomalies, f => f.Key == "ANOMALY_MEMORY_PRESSURE");
+    }
+
+    [Fact]
+    public async Task DetectMemoryAnomalies_Normal_NoAnomaly()
+    {
+        await _duckDb.InitializeAsync();
+
+        await SeedBaselineMemory(70_000, 100_000);
+
+        // Analysis window: same as baseline
+        for (int i = 0; i < 16; i++)
+            await SeedMemoryStatAsync(_analysisStart.AddMinutes(i * 15), 70_000, 100_000);
+
+        await SeedBaselineCpu(10, variance: 2);
+
+        var anomalies = await _detector.DetectAnomaliesAsync(CreateContext());
+
+        Assert.DoesNotContain(anomalies, f => f.Key == "ANOMALY_MEMORY_PRESSURE");
+    }
+
+    // ── Per-metric threshold ──
+
+    [Fact]
+    public async Task SetDeviationThreshold_HigherThreshold_SuppressesAnomaly()
+    {
+        await _duckDb.InitializeAsync();
+
+        // Baseline: CPU ~10%
+        await SeedBaselineCpu(10, variance: 2);
+
+        // Analysis window: CPU spike to 60% (would normally be >2σ)
+        for (int i = 0; i < 16; i++)
+            await SeedCpuAsync(_analysisStart.AddMinutes(i * 15), 60);
+
+        // Default threshold (2σ) should detect it
+        var anomalies1 = await _detector.DetectAnomaliesAsync(CreateContext());
+        var hasCpu1 = anomalies1.Any(f => f.Key == "ANOMALY_CPU_SPIKE");
+
+        // Set very high threshold — should suppress it
+        _detector.SetDeviationThreshold(MetricNames.Cpu, 100.0);
+        _baselineProvider.ClearCache();
+        var anomalies2 = await _detector.DetectAnomaliesAsync(CreateContext());
+        var hasCpu2 = anomalies2.Any(f => f.Key == "ANOMALY_CPU_SPIKE");
+
+        // Reset
+        _detector.SetDeviationThreshold(MetricNames.Cpu, 2.0);
+
+        Assert.False(hasCpu2, "High threshold should suppress CPU anomaly");
+    }
+
+    // ── Baseline context metadata ──
+
+    [Fact]
+    public async Task AnomalyFacts_ContainBaselineContextMetadata()
+    {
+        await _duckDb.InitializeAsync();
+
+        await SeedBaselineCpu(10, variance: 2);
+
+        // Spike to trigger anomaly
+        for (int i = 0; i < 16; i++)
+            await SeedCpuAsync(_analysisStart.AddMinutes(i * 15), 90);
+
+        var anomalies = await _detector.DetectAnomaliesAsync(CreateContext());
+        var cpuAnomaly = anomalies.FirstOrDefault(f => f.Key == "ANOMALY_CPU_SPIKE");
+
+        if (cpuAnomaly != null)
+        {
+            Assert.True(cpuAnomaly.Metadata.ContainsKey("baseline_hour"), "Missing baseline_hour");
+            Assert.True(cpuAnomaly.Metadata.ContainsKey("baseline_dow"), "Missing baseline_dow");
+            Assert.True(cpuAnomaly.Metadata.ContainsKey("baseline_tier"), "Missing baseline_tier");
+            Assert.True(cpuAnomaly.Metadata.ContainsKey("baseline_mean"), "Missing baseline_mean");
+            Assert.True(cpuAnomaly.Metadata.ContainsKey("deviation_sigma"), "Missing deviation_sigma");
+        }
+    }
+
+    // ── No baseline = no anomalies ──
+
+    [Fact]
+    public async Task DetectAnomalies_NoBaselineData_ReturnsEmpty()
+    {
+        await _duckDb.InitializeAsync();
+
+        // Only analysis window data, no baseline
+        for (int i = 0; i < 16; i++)
+            await SeedCpuAsync(_analysisStart.AddMinutes(i * 15), 90);
+
+        var anomalies = await _detector.DetectAnomaliesAsync(CreateContext());
+
+        // Should not fire — no baseline to compare against
+        Assert.Empty(anomalies);
+    }
+
+    // ── Helpers: seed baseline data in the 30-day window before analysis ──
+
+    /// <summary>
+    /// Seeds baseline data across 14 days, keeping all samples within the same hour
+    /// as the analysis start so they land in the same time bucket. Uses 3-minute
+    /// intervals to stay within one hour (14 days × 4 samples = 56 total, enough
+    /// for flat/hour-only collapse).
+    /// </summary>
+    private async Task SeedBaselineCpu(int avgCpu, int variance)
+    {
+        var rng = new Random(42);
+        for (int day = 1; day <= 14; day++)
+        {
+            var baseDay = _analysisStart.AddDays(-day);
+            for (int i = 0; i < 4; i++)
+            {
+                var cpu = Math.Clamp(avgCpu + rng.Next(-variance, variance + 1), 0, 100);
+                await SeedCpuAsync(baseDay.AddMinutes(i * 3), cpu);
+            }
+        }
+    }
+
+    private async Task SeedBaselinePerfmon(string counterName, long avgValue, int variance)
+    {
+        var rng = new Random(42);
+        for (int day = 1; day <= 14; day++)
+        {
+            var baseDay = _analysisStart.AddDays(-day);
+            for (int i = 0; i < 4; i++)
+            {
+                var value = Math.Max(0, avgValue + rng.Next(-variance, variance + 1));
+                await SeedPerfmonAsync(baseDay.AddMinutes(i * 3), counterName, value);
+            }
+        }
+    }
+
+    private async Task SeedBaselineSessions(int avgConnections, int variance)
+    {
+        var rng = new Random(42);
+        for (int day = 1; day <= 14; day++)
+        {
+            var baseDay = _analysisStart.AddDays(-day);
+            for (int i = 0; i < 4; i++)
+            {
+                var count = Math.Max(1, avgConnections + rng.Next(-variance, variance + 1));
+                await SeedSessionStatAsync(baseDay.AddMinutes(i * 3), "App1", count);
+            }
+        }
+    }
+
+    private async Task SeedBaselineQueryStats(long avgElapsed, int variance)
+    {
+        var rng = new Random(42);
+        for (int day = 1; day <= 14; day++)
+        {
+            var baseDay = _analysisStart.AddDays(-day);
+            for (int i = 0; i < 4; i++)
+            {
+                var elapsed = Math.Max(0, avgElapsed + rng.Next(-variance, variance + 1));
+                await SeedQueryStatAsync(baseDay.AddMinutes(i * 3), elapsed, 100);
+            }
+        }
+    }
+
+    private async Task SeedBaselineWaits()
+    {
+        for (int day = 1; day <= 14; day++)
+        {
+            var baseDay = _analysisStart.AddDays(-day);
+            for (int i = 0; i < 4; i++)
+                await SeedWaitStatAsync(baseDay.AddMinutes(i * 3), "SOS_SCHEDULER_YIELD", 100);
+        }
+    }
+
+    private async Task SeedBaselineMemory(double avgTotalServerMb, double targetMb)
+    {
+        for (int day = 1; day <= 14; day++)
+        {
+            var baseDay = _analysisStart.AddDays(-day);
+            for (int i = 0; i < 4; i++)
+                await SeedMemoryStatAsync(baseDay.AddMinutes(i * 3), avgTotalServerMb, targetMb);
+        }
+    }
+
+    // ── Helpers: seed individual rows ──
+
+    private async Task SeedCpuAsync(DateTime time, int cpuValue)
+    {
+        using var readLock = _duckDb.AcquireReadLock();
+        using var conn = _duckDb.CreateConnection();
+        await conn.OpenAsync();
+        using var cmd = conn.CreateCommand();
+        cmd.CommandText = @"INSERT INTO cpu_utilization_stats
+            (collection_id, collection_time, server_id, server_name, sample_time,
+             sqlserver_cpu_utilization, other_process_cpu_utilization)
+            VALUES ($1, $2, $3, 'TestServer', $4, $5, 2)";
+        cmd.Parameters.Add(new DuckDBParameter { Value = _nextId-- });
+        cmd.Parameters.Add(new DuckDBParameter { Value = time });
+        cmd.Parameters.Add(new DuckDBParameter { Value = ServerId });
+        cmd.Parameters.Add(new DuckDBParameter { Value = time });
+        cmd.Parameters.Add(new DuckDBParameter { Value = cpuValue });
+        await cmd.ExecuteNonQueryAsync();
+    }
+
+    private async Task SeedPerfmonAsync(DateTime time, string counterName, long deltaValue)
+    {
+        using var readLock = _duckDb.AcquireReadLock();
+        using var conn = _duckDb.CreateConnection();
+        await conn.OpenAsync();
+        using var cmd = conn.CreateCommand();
+        cmd.CommandText = @"INSERT INTO perfmon_stats
+            (collection_id, collection_time, server_id, server_name,
+             object_name, counter_name, instance_name, cntr_value, delta_cntr_value, sample_interval_seconds)
+            VALUES ($1, $2, $3, 'TestServer', 'SQLServer:SQL Statistics', $4, '', $5, $5, 10)";
+        cmd.Parameters.Add(new DuckDBParameter { Value = _nextId-- });
+        cmd.Parameters.Add(new DuckDBParameter { Value = time });
+        cmd.Parameters.Add(new DuckDBParameter { Value = ServerId });
+        cmd.Parameters.Add(new DuckDBParameter { Value = counterName });
+        cmd.Parameters.Add(new DuckDBParameter { Value = deltaValue });
+        await cmd.ExecuteNonQueryAsync();
+    }
+
+    private async Task SeedWaitStatAsync(DateTime time, string waitType, long deltaWaitMs)
+    {
+        using var readLock = _duckDb.AcquireReadLock();
+        using var conn = _duckDb.CreateConnection();
+        await conn.OpenAsync();
+        using var cmd = conn.CreateCommand();
+        cmd.CommandText = @"INSERT INTO wait_stats
+            (collection_id, collection_time, server_id, server_name, wait_type,
+             waiting_tasks_count, wait_time_ms, signal_wait_time_ms,
+             delta_waiting_tasks, delta_wait_time_ms, delta_signal_wait_time_ms)
+            VALUES ($1, $2, $3, 'TestServer', $4, 0, 0, 0, 0, $5, 0)";
+        cmd.Parameters.Add(new DuckDBParameter { Value = _nextId-- });
+        cmd.Parameters.Add(new DuckDBParameter { Value = time });
+        cmd.Parameters.Add(new DuckDBParameter { Value = ServerId });
+        cmd.Parameters.Add(new DuckDBParameter { Value = waitType });
+        cmd.Parameters.Add(new DuckDBParameter { Value = deltaWaitMs });
+        await cmd.ExecuteNonQueryAsync();
+    }
+
+    private async Task SeedSessionStatAsync(DateTime time, string programName, long connectionCount)
+    {
+        using var readLock = _duckDb.AcquireReadLock();
+        using var conn = _duckDb.CreateConnection();
+        await conn.OpenAsync();
+        using var cmd = conn.CreateCommand();
+        cmd.CommandText = @"INSERT INTO session_stats
+            (collection_id, collection_time, server_id, server_name, program_name,
+             connection_count, running_count, sleeping_count, dormant_count)
+            VALUES ($1, $2, $3, 'TestServer', $4, $5, 0, 0, 0)";
+        cmd.Parameters.Add(new DuckDBParameter { Value = _nextId-- });
+        cmd.Parameters.Add(new DuckDBParameter { Value = time });
+        cmd.Parameters.Add(new DuckDBParameter { Value = ServerId });
+        cmd.Parameters.Add(new DuckDBParameter { Value = programName });
+        cmd.Parameters.Add(new DuckDBParameter { Value = connectionCount });
+        await cmd.ExecuteNonQueryAsync();
+    }
+
+    private async Task SeedQueryStatAsync(DateTime time, long deltaElapsed, long deltaExecCount)
+    {
+        using var readLock = _duckDb.AcquireReadLock();
+        using var conn = _duckDb.CreateConnection();
+        await conn.OpenAsync();
+        using var cmd = conn.CreateCommand();
+        cmd.CommandText = @"INSERT INTO query_stats
+            (collection_id, collection_time, server_id, server_name,
+             execution_count, total_elapsed_time, total_worker_time,
+             total_logical_reads, total_logical_writes, total_physical_reads,
+             delta_execution_count, delta_elapsed_time, delta_worker_time,
+             delta_logical_reads, delta_logical_writes, delta_physical_reads, delta_rows, delta_spills)
+            VALUES ($1, $2, $3, 'TestServer', $4, $5, 0, 0, 0, 0, $4, $5, 0, 0, 0, 0, 0, 0)";
+        cmd.Parameters.Add(new DuckDBParameter { Value = _nextId-- });
+        cmd.Parameters.Add(new DuckDBParameter { Value = time });
+        cmd.Parameters.Add(new DuckDBParameter { Value = ServerId });
+        cmd.Parameters.Add(new DuckDBParameter { Value = deltaExecCount });
+        cmd.Parameters.Add(new DuckDBParameter { Value = deltaElapsed });
+        await cmd.ExecuteNonQueryAsync();
+    }
+
+    private async Task SeedMemoryStatAsync(DateTime time, double totalServerMb, double targetMb)
+    {
+        using var readLock = _duckDb.AcquireReadLock();
+        using var conn = _duckDb.CreateConnection();
+        await conn.OpenAsync();
+        using var cmd = conn.CreateCommand();
+        cmd.CommandText = @"INSERT INTO memory_stats
+            (collection_id, collection_time, server_id, server_name,
+             total_physical_memory_mb, available_physical_memory_mb,
+             target_server_memory_mb, total_server_memory_mb, buffer_pool_mb)
+            VALUES ($1, $2, $3, 'TestServer', $4, $5, $6, $7, $7)";
+        cmd.Parameters.Add(new DuckDBParameter { Value = _nextId-- });
+        cmd.Parameters.Add(new DuckDBParameter { Value = time });
+        cmd.Parameters.Add(new DuckDBParameter { Value = ServerId });
+        cmd.Parameters.Add(new DuckDBParameter { Value = targetMb * 1.2 });
+        cmd.Parameters.Add(new DuckDBParameter { Value = targetMb * 0.2 });
+        cmd.Parameters.Add(new DuckDBParameter { Value = targetMb });
+        cmd.Parameters.Add(new DuckDBParameter { Value = totalServerMb });
+        await cmd.ExecuteNonQueryAsync();
+    }
+}
diff --git a/Lite.Tests/BaselineProviderTests.cs b/Lite.Tests/BaselineProviderTests.cs
new file mode 100644
index 0000000..cdf9cad
--- /dev/null
+++ b/Lite.Tests/BaselineProviderTests.cs
@@ -0,0 +1,481 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Threading.Tasks;
+using DuckDB.NET.Data;
+using PerformanceMonitorLite.Analysis;
+using PerformanceMonitorLite.Database;
+using Xunit;
+
+namespace PerformanceMonitorLite.Tests;
+
+/// <summary>
+/// Tests for BaselineProvider: time-bucketed baseline computation, bucket collapse
+/// with hysteresis, restart poisoning exclusion, and division-by-zero handling.
+/// </summary>
+public class BaselineProviderTests : IDisposable
+{
+    private readonly string _tempDir;
+    private readonly DuckDbInitializer _duckDb;
+    private readonly BaselineProvider _provider;
+
+    private const int ServerId = -999;
+
+    // Analysis time is pinned to a known hour+dow for deterministic bucket matching.
+    // Wednesday 14:00 UTC (dow=3 in DuckDB where Sunday=0)
+    private static readonly DateTime AnalysisTime = new(2026, 4, 1, 14, 0, 0, DateTimeKind.Utc);
+
+    private long _nextId = -1;
+
+    public BaselineProviderTests()
+    {
+        _tempDir = Path.Combine(Path.GetTempPath(), "BaselineTests_" + Guid.NewGuid().ToString("N")[..8]);
+        Directory.CreateDirectory(_tempDir);
+        var dbPath = Path.Combine(_tempDir, "test.duckdb");
+        _duckDb = new DuckDbInitializer(dbPath);
+        _provider = new BaselineProvider(_duckDb);
+        // Use very short TTL so cache doesn't interfere between tests
+        BaselineProvider.CacheTtl = TimeSpan.FromMilliseconds(1);
+    }
+
+    public void Dispose()
+    {
+        try
+        {
+            if (Directory.Exists(_tempDir))
+                Directory.Delete(_tempDir, recursive: true);
+        }
+        catch { /* Best-effort cleanup */ }
+    }
+
+    // ── Full bucket: enough samples in one hour+dow ──
+
+    [Fact]
+    public async Task GetBaseline_FullBucket_ReturnsMeanAndStdDev()
+    {
+        await _duckDb.InitializeAsync();
+
+        // Seed 20 CPU samples on Wednesdays at 14:xx over 4 weeks (well above RestoreThreshold=15)
+        for (int week = 0; week < 4; week++)
+        {
+            var wednesday = AnalysisTime.AddDays(-7 * (week + 1)); // Previous Wednesdays
+            for (int i = 0; i < 5; i++)
+            {
+                await SeedCpuAsync(wednesday.AddMinutes(i * 10), 50 + i * 2); // 50,52,54,56,58
+            }
+        }
+
+        var baseline = await _provider.GetBaselineAsync(ServerId, MetricNames.Cpu, AnalysisTime);
+
+        Assert.True(baseline.SampleCount >= 15); // Full bucket
+        Assert.Equal(BaselineTier.Full, baseline.Tier);
+        Assert.InRange(baseline.Mean, 50, 58); // Mean of 50,52,54,56,58 repeated
+        Assert.True(baseline.StdDev > 0);
+    }
+
+    // ── Bucket collapse: hour-only fallback ──
+
+    [Fact]
+    public async Task GetBaseline_SparseBucket_CollapsesToHourOnly()
+    {
+        await _duckDb.InitializeAsync();
+
+        // Seed only 5 samples on Wednesday 14:xx (below CollapseThreshold=10)
+        var wednesday = AnalysisTime.AddDays(-7);
+        for (int i = 0; i < 5; i++)
+            await SeedCpuAsync(wednesday.AddMinutes(i * 10), 40 + i);
+
+        // Seed 15 samples on other days at 14:xx (enough for hour-only)
+        for (int dow = 0; dow < 3; dow++) // Sun, Mon, Tue
+        {
+            var day = AnalysisTime.AddDays(-7 - dow - 4); // Different days, same hour
+            for (int i = 0; i < 5; i++)
+                await SeedCpuAsync(day.AddMinutes(i * 10), 60 + i);
+        }
+
+        _provider.ClearCache();
+        var baseline = await _provider.GetBaselineAsync(ServerId, MetricNames.Cpu, AnalysisTime);
+
+        Assert.True(baseline.SampleCount >= 10);
+        Assert.Equal(BaselineTier.HourOnly, baseline.Tier);
+        Assert.Equal(-1, baseline.DayOfWeek); // Indicates hour-only
+    }
+
+    // ── Bucket collapse: flat fallback ──
+
+    [Fact]
+    public async Task GetBaseline_VerySparseBucket_CollapsesToFlat()
+    {
+        await _duckDb.InitializeAsync();
+
+        // Seed only 2 samples at 14:xx (below threshold for hour-only)
+        var day = AnalysisTime.AddDays(-7);
+        await SeedCpuAsync(day.AddMinutes(0), 30);
+        await SeedCpuAsync(day.AddMinutes(15), 35);
+
+        // Seed 5 samples at other hours (enough for flat but not hour-only)
+        for (int h = 0; h < 5; h++)
+            await SeedCpuAsync(day.AddHours(-h - 1), 50 + h);
+
+        _provider.ClearCache();
+        var baseline = await _provider.GetBaselineAsync(ServerId, MetricNames.Cpu, AnalysisTime);
+
+        // Should fall through to flat (7 samples total, >= 3 minimum viable)
+        Assert.True(baseline.SampleCount >= 3);
+        Assert.Equal(BaselineTier.Flat, baseline.Tier);
+    }
+
+    // ── Empty baseline ──
+
+    [Fact]
+    public async Task GetBaseline_NoData_ReturnsEmpty()
+    {
+        await _duckDb.InitializeAsync();
+
+        var baseline = await _provider.GetBaselineAsync(ServerId, MetricNames.Cpu, AnalysisTime);
+
+        Assert.Equal(0, baseline.SampleCount);
+    }
+
+    // ── Hysteresis: between collapse and restore thresholds ──
+
+    [Fact]
+    public async Task GetBaseline_BetweenThresholds_UsesFullBucket()
+    {
+        await _duckDb.InitializeAsync();
+
+        // Seed exactly 12 samples on Wednesday 14:xx (between 10 and 15)
+        for (int week = 0; week < 3; week++)
+        {
+            var wednesday = AnalysisTime.AddDays(-7 * (week + 1));
+            for (int i = 0; i < 4; i++)
+                await SeedCpuAsync(wednesday.AddMinutes(i * 10), 45 + i);
+        }
+
+        _provider.ClearCache();
+        var baseline = await _provider.GetBaselineAsync(ServerId, MetricNames.Cpu, AnalysisTime);
+
+        // 12 samples >= CollapseThreshold(10), so full bucket is used (hysteresis)
+        Assert.Equal(12, baseline.SampleCount);
+        Assert.Equal(BaselineTier.Full, baseline.Tier);
+    }
+
+    // ── Division by zero: proportional floor ──
+
+    [Fact]
+    public void EffectiveStdDev_ZeroStdDev_UsesProportionalFloor()
+    {
+        // All identical values → stddev = 0, mean = 50
+        var bucket = new BaselineBucket
+        {
+            HourOfDay = 14, DayOfWeek = 3,
+            Mean = 50.0, StdDev = 0.0, SampleCount = 20,
+            Tier = BaselineTier.Full
+        };
+
+        // Should be max(0, 50 * 0.01) = 0.5
+        Assert.Equal(0.5, bucket.EffectiveStdDev);
+    }
+
+    [Fact]
+    public void EffectiveStdDev_ZeroMeanAndZeroStdDev_ReturnsZero()
+    {
+        // Zero activity → skip scoring
+        var bucket = new BaselineBucket
+        {
+            HourOfDay = 14, DayOfWeek = 3,
+            Mean = 0.0, StdDev = 0.0, SampleCount = 20,
+            Tier = BaselineTier.Full
+        };
+
+        Assert.Equal(0.0, bucket.EffectiveStdDev);
+    }
+
+    [Fact]
+    public void EffectiveStdDev_NormalStdDev_ReturnsActual()
+    {
+        var bucket = new BaselineBucket
+        {
+            HourOfDay = 14, DayOfWeek = 3,
+            Mean = 50.0, StdDev = 5.0, SampleCount = 20,
+            Tier = BaselineTier.Full
+        };
+
+        // StdDev (5.0) > Mean * 0.01 (0.5), so return actual
+        Assert.Equal(5.0, bucket.EffectiveStdDev);
+    }
+
+    // ── Restart poisoning: cumulative counter drop excluded ──
+
+    [Fact]
+    public async Task GetBaseline_BatchRequests_ExcludesRestartDrop()
+    {
+        await _duckDb.InitializeAsync();
+
+        // Seed batch requests with a restart-shaped drop in the middle
+        var baseDay = AnalysisTime.AddDays(-7);
+        var normalValues = new[] { 5000, 5100, 4900, 5200, 5050, 4950 };
+
+        for (int i = 0; i < normalValues.Length; i++)
+            await SeedPerfmonAsync(baseDay.AddMinutes(i * 10), "Batch Requests/sec", normalValues[i]);
+
+        // Restart drop: value falls to 0 then recovers
+        await SeedPerfmonAsync(baseDay.AddMinutes(60), "Batch Requests/sec", 0);     // Restart
+        await SeedPerfmonAsync(baseDay.AddMinutes(70), "Batch Requests/sec", 5100);  // Recovery
+
+        // Add enough more samples on other days to reach threshold
+        for (int d = 2; d <= 4; d++)
+        {
+            var day = AnalysisTime.AddDays(-7 * d);
+            for (int i = 0; i < 5; i++)
+                await SeedPerfmonAsync(day.AddMinutes(i * 10), "Batch Requests/sec", 5000 + i * 50);
+        }
+
+        _provider.ClearCache();
+        var baseline = await _provider.GetBaselineAsync(ServerId, MetricNames.BatchRequests, AnalysisTime);
+
+        // The restart drop (0) should be excluded, so mean should be near 5000, not pulled toward 0
+        Assert.True(baseline.Mean > 4000, $"Mean {baseline.Mean} should not be poisoned by restart drop");
+    }
+
+    // ── Wait stats: per-collection aggregation ──
+
+    [Fact]
+    public async Task GetBaseline_WaitStats_AggregatesPerCollection()
+    {
+        await _duckDb.InitializeAsync();
+
+        // Seed multiple wait types at each collection time — baseline should aggregate to total
+        for (int week = 0; week < 4; week++)
+        {
+            var day = AnalysisTime.AddDays(-7 * (week + 1));
+            for (int i = 0; i < 5; i++)
+            {
+                var t = day.AddMinutes(i * 10);
+                await SeedWaitStatAsync(t, "SOS_SCHEDULER_YIELD", 100);
+                await SeedWaitStatAsync(t, "WRITELOG", 50);
+                await SeedWaitStatAsync(t, "PAGEIOLATCH_SH", 30);
+            }
+        }
+
+        _provider.ClearCache();
+        var baseline = await _provider.GetBaselineAsync(ServerId, MetricNames.WaitStats, AnalysisTime);
+
+        Assert.True(baseline.SampleCount > 0);
+        // Mean should be ~180 (100+50+30 per collection)
+        Assert.InRange(baseline.Mean, 150, 210);
+    }
+
+    // ── Session count: per-collection aggregation ──
+
+    [Fact]
+    public async Task GetBaseline_SessionCount_AggregatesPerCollection()
+    {
+        await _duckDb.InitializeAsync();
+
+        // Seed multiple program_name rows per collection
+        for (int week = 0; week < 4; week++)
+        {
+            var day = AnalysisTime.AddDays(-7 * (week + 1));
+            for (int i = 0; i < 5; i++)
+            {
+                var t = day.AddMinutes(i * 10);
+                await SeedSessionStatAsync(t, "App1", 10);
+                await SeedSessionStatAsync(t, "App2", 5);
+            }
+        }
+
+        _provider.ClearCache();
+        var baseline = await _provider.GetBaselineAsync(ServerId, MetricNames.SessionCount, AnalysisTime);
+
+        Assert.True(baseline.SampleCount > 0);
+        // Mean should be ~15 (10+5 per collection)
+        Assert.InRange(baseline.Mean, 12, 18);
+    }
+
+    // ── Cache behavior ──
+
+    [Fact]
+    public async Task GetBaseline_CacheHit_ReturnsSameResult()
+    {
+        await _duckDb.InitializeAsync();
+
+        for (int i = 0; i < 20; i++)
+            await SeedCpuAsync(AnalysisTime.AddDays(-7).AddMinutes(i * 10), 50);
+
+        BaselineProvider.CacheTtl = TimeSpan.FromMinutes(5);
+        _provider.ClearCache();
+
+        var first = await _provider.GetBaselineAsync(ServerId, MetricNames.Cpu, AnalysisTime);
+        var second = await _provider.GetBaselineAsync(ServerId, MetricNames.Cpu, AnalysisTime);
+
+        Assert.Equal(first.Mean, second.Mean);
+        Assert.Equal(first.SampleCount, second.SampleCount);
+
+        // Restore short TTL
+        BaselineProvider.CacheTtl = TimeSpan.FromMilliseconds(1);
+    }
+
+    [Fact]
+    public async Task InvalidateCache_ClearsServerEntries()
+    {
+        await _duckDb.InitializeAsync();
+
+        for (int i = 0; i < 20; i++)
+            await SeedCpuAsync(AnalysisTime.AddDays(-7).AddMinutes(i * 10), 50);
+
+        BaselineProvider.CacheTtl = TimeSpan.FromMinutes(5);
+        _provider.ClearCache();
+
+        await _provider.GetBaselineAsync(ServerId, MetricNames.Cpu, AnalysisTime);
+        _provider.InvalidateCache(ServerId);
+
+        // After invalidation, should recompute (no error, same result)
+        var after = await _provider.GetBaselineAsync(ServerId, MetricNames.Cpu, AnalysisTime);
+        Assert.True(after.SampleCount > 0);
+
+        BaselineProvider.CacheTtl = TimeSpan.FromMilliseconds(1);
+    }
+
+    // ── Server isolation: no cross-contamination ──
+
+    [Fact]
+    public async Task GetBaseline_DifferentServers_NoCrossContamination()
+    {
+        await _duckDb.InitializeAsync();
+
+        int server1 = -998, server2 = -997;
+
+        // Seed different CPU values for two servers
+        for (int i = 0; i < 20; i++)
+        {
+            await SeedCpuAsync(AnalysisTime.AddDays(-7).AddMinutes(i * 10), 80, server1);
+            await SeedCpuAsync(AnalysisTime.AddDays(-7).AddMinutes(i * 10), 20, server2);
+        }
+
+        _provider.ClearCache();
+        var baseline1 = await _provider.GetBaselineAsync(server1, MetricNames.Cpu, AnalysisTime);
+        var baseline2 = await _provider.GetBaselineAsync(server2, MetricNames.Cpu, AnalysisTime);
+
+        Assert.InRange(baseline1.Mean, 75, 85);
+        Assert.InRange(baseline2.Mean, 15, 25);
+    }
+
+    // ── Memory metric (Lite-only) ──
+
+    [Fact]
+    public async Task GetBaseline_Memory_ComputesPressurePercent()
+    {
+        await _duckDb.InitializeAsync();
+
+        // 80% memory pressure: 80GB used of 100GB target
+        for (int week = 0; week < 4; week++)
+        {
+            var day = AnalysisTime.AddDays(-7 * (week + 1));
+            for (int i = 0; i < 5; i++)
+                await SeedMemoryStatAsync(day.AddMinutes(i * 10), totalServerMb: 80_000, targetMb: 100_000);
+        }
+
+        _provider.ClearCache();
+        var baseline = await _provider.GetBaselineAsync(ServerId, MetricNames.Memory, AnalysisTime);
+
+        Assert.True(baseline.SampleCount > 0);
+        Assert.InRange(baseline.Mean, 78, 82); // ~80%
+    }
+
+    // ── Helpers ──
+
+    private async Task SeedCpuAsync(DateTime time, int cpuValue, int serverId = ServerId)
+    {
+        using var readLock = _duckDb.AcquireReadLock();
+        using var conn = _duckDb.CreateConnection();
+        await conn.OpenAsync();
+        using var cmd = conn.CreateCommand();
+        cmd.CommandText = @"INSERT INTO cpu_utilization_stats
+            (collection_id, collection_time, server_id, server_name, sample_time,
+             sqlserver_cpu_utilization, other_process_cpu_utilization)
+            VALUES ($1, $2, $3, 'TestServer', $4, $5, 2)";
+        cmd.Parameters.Add(new DuckDBParameter { Value = _nextId-- });
+        cmd.Parameters.Add(new DuckDBParameter { Value = time });
+        cmd.Parameters.Add(new DuckDBParameter { Value = serverId });
+        cmd.Parameters.Add(new DuckDBParameter { Value = time });
+        cmd.Parameters.Add(new DuckDBParameter { Value = cpuValue });
+        await cmd.ExecuteNonQueryAsync();
+    }
+
+    private async Task SeedPerfmonAsync(DateTime time, string counterName, long deltaValue)
+    {
+        using var readLock = _duckDb.AcquireReadLock();
+        using var conn = _duckDb.CreateConnection();
+        await conn.OpenAsync();
+        using var cmd = conn.CreateCommand();
+        cmd.CommandText = @"INSERT INTO perfmon_stats
+            (collection_id, collection_time, server_id, server_name,
+             object_name, counter_name, instance_name, cntr_value, delta_cntr_value, sample_interval_seconds)
+            VALUES ($1, $2, $3, 'TestServer', 'SQLServer:SQL Statistics', $4, '', $5, $5, 10)";
+        cmd.Parameters.Add(new DuckDBParameter { Value = _nextId-- });
+        cmd.Parameters.Add(new DuckDBParameter { Value = time });
+        cmd.Parameters.Add(new DuckDBParameter { Value = ServerId });
+        cmd.Parameters.Add(new DuckDBParameter { Value = counterName });
+        cmd.Parameters.Add(new DuckDBParameter { Value = deltaValue });
+        await cmd.ExecuteNonQueryAsync();
+    }
+
+    private async Task SeedWaitStatAsync(DateTime time, string waitType, long deltaWaitMs)
+    {
+        using var readLock = _duckDb.AcquireReadLock();
+        using var conn = _duckDb.CreateConnection();
+        await conn.OpenAsync();
+        using var cmd = conn.CreateCommand();
+        cmd.CommandText = @"INSERT INTO wait_stats
+            (collection_id, collection_time, server_id, server_name, wait_type,
+             waiting_tasks_count, wait_time_ms, signal_wait_time_ms,
+             delta_waiting_tasks, delta_wait_time_ms, delta_signal_wait_time_ms)
+            VALUES ($1, $2, $3, 'TestServer', $4, 0, 0, 0, 0, $5, 0)";
+        cmd.Parameters.Add(new DuckDBParameter { Value = _nextId-- });
+        cmd.Parameters.Add(new DuckDBParameter { Value = time });
+        cmd.Parameters.Add(new DuckDBParameter { Value = ServerId });
+        cmd.Parameters.Add(new DuckDBParameter { Value = waitType });
+        cmd.Parameters.Add(new DuckDBParameter { Value = deltaWaitMs });
+        await cmd.ExecuteNonQueryAsync();
+    }
+
+    private async Task SeedSessionStatAsync(DateTime time, string programName, long connectionCount)
+    {
+        using var readLock = _duckDb.AcquireReadLock();
+        using var conn = _duckDb.CreateConnection();
+        await conn.OpenAsync();
+        using var cmd = conn.CreateCommand();
+        cmd.CommandText = @"INSERT INTO session_stats
+            (collection_id, collection_time, server_id, server_name, program_name,
+             connection_count, running_count, sleeping_count, dormant_count)
+            VALUES ($1, $2, $3, 'TestServer', $4, $5, 0, 0, 0)";
+        cmd.Parameters.Add(new DuckDBParameter { Value = _nextId-- });
+        cmd.Parameters.Add(new DuckDBParameter { Value = time });
+        cmd.Parameters.Add(new DuckDBParameter { Value = ServerId });
+        cmd.Parameters.Add(new DuckDBParameter { Value = programName });
+        cmd.Parameters.Add(new DuckDBParameter { Value = connectionCount });
+        await cmd.ExecuteNonQueryAsync();
+    }
+
+    private async Task SeedMemoryStatAsync(DateTime time, double totalServerMb, double targetMb)
+    {
+        using var readLock = _duckDb.AcquireReadLock();
+        using var conn = _duckDb.CreateConnection();
+        await conn.OpenAsync();
+        using var cmd = conn.CreateCommand();
+        cmd.CommandText = @"INSERT INTO memory_stats
+            (collection_id, collection_time, server_id, server_name,
+             total_physical_memory_mb, available_physical_memory_mb,
+             target_server_memory_mb, total_server_memory_mb, buffer_pool_mb)
+            VALUES ($1, $2, $3, 'TestServer', $4, $5, $6, $7, $7)";
+        cmd.Parameters.Add(new DuckDBParameter { Value = _nextId-- });
+        cmd.Parameters.Add(new DuckDBParameter { Value = time });
+        cmd.Parameters.Add(new DuckDBParameter { Value = ServerId });
+        cmd.Parameters.Add(new DuckDBParameter { Value = targetMb * 1.2 }); // total physical > target
+        cmd.Parameters.Add(new DuckDBParameter { Value = targetMb * 0.2 }); // some available
+        cmd.Parameters.Add(new DuckDBParameter { Value = targetMb });
+        cmd.Parameters.Add(new DuckDBParameter { Value = totalServerMb });
+        await cmd.ExecuteNonQueryAsync();
+    }
+}
diff --git a/Lite.Tests/ScenarioTests.cs b/Lite.Tests/ScenarioTests.cs
index dcadf1a..bc76481 100644
--- a/Lite.Tests/ScenarioTests.cs
+++ b/Lite.Tests/ScenarioTests.cs
@@ -445,7 +445,7 @@ public async Task WaitSpikeAnomaly_HighRatio()
         var facts = await collector.CollectFactsAsync(context);
 
         // Run anomaly detection (compares analysis window against baseline)
-        var anomalyDetector = new AnomalyDetector(_duckDb);
+        var anomalyDetector = new AnomalyDetector(_duckDb, new BaselineProvider(_duckDb));
         var anomalies = await anomalyDetector.DetectAnomaliesAsync(context);
         facts.AddRange(anomalies);
 
diff --git a/Lite/Analysis/AnalysisModels.cs b/Lite/Analysis/AnalysisModels.cs
index 022bfd7..3fb6fd2 100644
--- a/Lite/Analysis/AnalysisModels.cs
+++ b/Lite/Analysis/AnalysisModels.cs
@@ -72,6 +72,7 @@ public class AnalysisStory
     public double? LeafFactValue { get; set; }
     public int FactCount { get; set; }
     public bool IsAbsolution { get; set; }
+    public Dictionary<string, double>? RootFactMetadata { get; set; }
 }
 
 /// <summary>
@@ -104,6 +105,12 @@ public class AnalysisFinding
     /// Contains supporting detail keyed by category (e.g., "top_deadlocks", "queries_at_spike").
     /// </summary>
     public Dictionary<string, object>? DrillDown { get; set; }
+
+    /// <summary>
+    /// Root fact metadata from anomaly detection. Ephemeral — not persisted to DuckDB.
+    /// Contains baseline context (mean, stddev, tier, hour, dow) for anomaly findings.
+    /// </summary>
+    public Dictionary<string, double>? RootFactMetadata { get; set; }
 }
 
 /// <summary>
diff --git a/Lite/Analysis/AnalysisService.cs b/Lite/Analysis/AnalysisService.cs
index 43fd508..83fa23d 100644
--- a/Lite/Analysis/AnalysisService.cs
+++ b/Lite/Analysis/AnalysisService.cs
@@ -23,13 +23,14 @@ public class AnalysisService
     private readonly InferenceEngine _engine;
     private readonly DrillDownCollector _drillDown;
     private readonly AnomalyDetector _anomalyDetector;
+    private readonly BaselineProvider _baselineProvider;
     /// <summary>
     /// Minimum hours of collected data required before analysis will run.
     /// Short collection windows distort fraction-of-period calculations —
     /// 5 seconds of THREADPOOL looks alarming in a 16-minute window.
     /// Production: 72. Dev/testing: 0.5 (raise before release).
     /// </summary>
-    internal double MinimumDataHours { get; set; } = 72;
+    internal double MinimumDataHours { get; set; } = 24; // TODO: restore to 72 before release
 
     /// <summary>
     /// Raised after each analysis run completes, providing the findings for UI display.
@@ -60,7 +61,8 @@ public AnalysisService(DuckDbInitializer duckDb, IPlanFetcher? planFetcher = nul
         _graph = new RelationshipGraph();
         _engine = new InferenceEngine(_graph);
         _drillDown = new DrillDownCollector(duckDb, planFetcher);
-        _anomalyDetector = new AnomalyDetector(duckDb);
+        _baselineProvider = new BaselineProvider(duckDb);
+        _anomalyDetector = new AnomalyDetector(duckDb, _baselineProvider);
     }
 
     /// <summary>
diff --git a/Lite/Analysis/AnomalyDetector.cs b/Lite/Analysis/AnomalyDetector.cs
index ab520fd..1398b0e 100644
--- a/Lite/Analysis/AnomalyDetector.cs
+++ b/Lite/Analysis/AnomalyDetector.cs
@@ -1,528 +1,780 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Threading.Tasks;
-using DuckDB.NET.Data;
-using PerformanceMonitorLite.Database;
-using PerformanceMonitorLite.Services;
-
-namespace PerformanceMonitorLite.Analysis;
-
-/// <summary>
-/// Detects anomalies by comparing the analysis window's metrics against a
-/// baseline period. When a metric deviates significantly from baseline
-/// (mean + standard deviation), an ANOMALY fact is emitted.
-///
-/// This is the "oh shit" mode — detecting acute deviations that don't show
-/// up in aggregate analysis because they're brief. A 5-minute CPU spike
-/// that averages out over 4 hours is invisible to aggregate scoring but
-/// obvious when compared against "what was this metric doing before?"
-///
-/// Baseline selection: uses the 24 hours preceding the analysis window.
-/// If less data is available, uses whatever exists with lower confidence.
-/// </summary>
-public class AnomalyDetector
-{
-    private readonly DuckDbInitializer _duckDb;
-
-    /// <summary>
-    /// Minimum number of baseline samples needed for reliable detection.
-    /// Below this, anomalies are still detected but with reduced confidence.
-    /// </summary>
-    private const int MinBaselineSamples = 10;
-
-    /// <summary>
-    /// Number of standard deviations above baseline mean to flag as anomalous.
-    /// </summary>
-    private const double DeviationThreshold = 2.0;
-
-    public AnomalyDetector(DuckDbInitializer duckDb)
-    {
-        _duckDb = duckDb;
-    }
-
-    /// <summary>
-    /// Detects anomalies by comparing the analysis window against a baseline period.
-    /// Returns anomaly facts to be merged into the main fact list.
-    /// </summary>
-    public async Task<List<Fact>> DetectAnomaliesAsync(AnalysisContext context)
-    {
-        var anomalies = new List<Fact>();
-
-        // Baseline: 24 hours preceding the analysis window
-        var baselineEnd = context.TimeRangeStart;
-        var baselineStart = baselineEnd.AddHours(-24);
-
-        // Check if baseline period has any data at all — if not, skip all anomaly detection.
-        // Without baseline data, everything looks anomalous.
-        if (!await HasBaselineDataAsync(context.ServerId, baselineStart, baselineEnd))
-            return anomalies;
-
-        await DetectCpuAnomalies(context, baselineStart, baselineEnd, anomalies);
-        await DetectWaitAnomalies(context, baselineStart, baselineEnd, anomalies);
-        await DetectBlockingAnomalies(context, baselineStart, baselineEnd, anomalies);
-        await DetectIoAnomalies(context, baselineStart, baselineEnd, anomalies);
-
-        return anomalies;
-    }
-
-    /// <summary>
-    /// Checks if the baseline period has any collected data.
-    /// Uses wait_stats as canary — if waits are collected, other data is too.
-    /// </summary>
-    private async Task<bool> HasBaselineDataAsync(int serverId, DateTime baselineStart, DateTime baselineEnd)
-    {
-        try
-        {
-            using var readLock = _duckDb.AcquireReadLock();
-            using var connection = _duckDb.CreateConnection();
-            await connection.OpenAsync();
-
-            using var cmd = connection.CreateCommand();
-            cmd.CommandText = @"
-SELECT (SELECT COUNT(*) FROM v_wait_stats
-        WHERE server_id = $1 AND collection_time >= $2 AND collection_time < $3)
-     + (SELECT COUNT(*) FROM v_cpu_utilization_stats
-        WHERE server_id = $1 AND collection_time >= $2 AND collection_time < $3)";
-            cmd.Parameters.Add(new DuckDBParameter { Value = serverId });
-            cmd.Parameters.Add(new DuckDBParameter { Value = baselineStart });
-            cmd.Parameters.Add(new DuckDBParameter { Value = baselineEnd });
-
-            var count = Convert.ToInt64(await cmd.ExecuteScalarAsync() ?? 0);
-            return count > 0;
-        }
-        catch { return false; }
-    }
-
-    /// <summary>
-    /// Detects CPU utilization anomalies by comparing per-sample values
-    /// against the baseline distribution.
-    /// </summary>
-    private async Task DetectCpuAnomalies(AnalysisContext context,
-        DateTime baselineStart, DateTime baselineEnd, List<Fact> anomalies)
-    {
-        try
-        {
-            using var readLock = _duckDb.AcquireReadLock();
-            using var connection = _duckDb.CreateConnection();
-            await connection.OpenAsync();
-
-            // Get baseline stats
-            using var baselineCmd = connection.CreateCommand();
-            baselineCmd.CommandText = @"
-SELECT AVG(sqlserver_cpu_utilization) AS mean_cpu,
-       STDDEV_SAMP(sqlserver_cpu_utilization) AS stddev_cpu,
-       COUNT(*) AS sample_count
-FROM v_cpu_utilization_stats
-WHERE server_id = $1
-AND   collection_time >= $2 AND collection_time < $3";
-
-            baselineCmd.Parameters.Add(new DuckDBParameter { Value = context.ServerId });
-            baselineCmd.Parameters.Add(new DuckDBParameter { Value = baselineStart });
-            baselineCmd.Parameters.Add(new DuckDBParameter { Value = baselineEnd });
-
-            double baselineMean = 0, baselineStdDev = 0;
-            long baselineSamples = 0;
-
-            using (var reader = await baselineCmd.ExecuteReaderAsync())
-            {
-                if (await reader.ReadAsync())
-                {
-                    baselineMean = reader.IsDBNull(0) ? 0 : Convert.ToDouble(reader.GetValue(0));
-                    baselineStdDev = reader.IsDBNull(1) ? 0 : Convert.ToDouble(reader.GetValue(1));
-                    baselineSamples = reader.IsDBNull(2) ? 0 : Convert.ToInt64(reader.GetValue(2));
-                }
-            }
-
-            if (baselineSamples < 3 || baselineStdDev <= 0) return;
-
-            // Get peak and average in the analysis window
-            using var windowCmd = connection.CreateCommand();
-            windowCmd.CommandText = @"
-SELECT MAX(sqlserver_cpu_utilization) AS peak_cpu,
-       AVG(sqlserver_cpu_utilization) AS avg_cpu,
-       COUNT(*) AS sample_count,
-       (SELECT collection_time FROM v_cpu_utilization_stats
-        WHERE server_id = $1 AND collection_time >= $2 AND collection_time < $3
-        ORDER BY sqlserver_cpu_utilization DESC LIMIT 1) AS peak_time
-FROM v_cpu_utilization_stats
-WHERE server_id = $1
-AND   collection_time >= $2 AND collection_time < $3";
-
-            windowCmd.Parameters.Add(new DuckDBParameter { Value = context.ServerId });
-            windowCmd.Parameters.Add(new DuckDBParameter { Value = context.TimeRangeStart });
-            windowCmd.Parameters.Add(new DuckDBParameter { Value = context.TimeRangeEnd });
-
-            using var windowReader = await windowCmd.ExecuteReaderAsync();
-            if (!await windowReader.ReadAsync()) return;
-
-            var peakCpu = windowReader.IsDBNull(0) ? 0.0 : Convert.ToDouble(windowReader.GetValue(0));
-            var avgCpu = windowReader.IsDBNull(1) ? 0.0 : Convert.ToDouble(windowReader.GetValue(1));
-            var windowSamples = windowReader.IsDBNull(2) ? 0L : Convert.ToInt64(windowReader.GetValue(2));
-            var peakTime = windowReader.IsDBNull(3) ? (DateTime?)null : windowReader.GetDateTime(3);
-
-            if (windowSamples == 0) return;
-
-            // Check if peak deviates significantly from baseline
-            var deviation = (peakCpu - baselineMean) / baselineStdDev;
-            if (deviation < DeviationThreshold || peakCpu < 50) return; // Don't flag low absolute values
-
-            var confidence = baselineSamples >= MinBaselineSamples ? 1.0 : (double)baselineSamples / MinBaselineSamples;
-
-            anomalies.Add(new Fact
-            {
-                Source = "anomaly",
-                Key = "ANOMALY_CPU_SPIKE",
-                Value = peakCpu,
-                ServerId = context.ServerId,
-                Metadata = new Dictionary<string, double>
-                {
-                    ["peak_cpu"] = peakCpu,
-                    ["avg_cpu_in_window"] = avgCpu,
-                    ["baseline_mean"] = baselineMean,
-                    ["baseline_stddev"] = baselineStdDev,
-                    ["deviation_sigma"] = deviation,
-                    ["baseline_samples"] = baselineSamples,
-                    ["window_samples"] = windowSamples,
-                    ["confidence"] = confidence,
-                    ["peak_time_ticks"] = peakTime?.Ticks ?? 0
-                }
-            });
-        }
-        catch (Exception ex)
-        {
-            AppLogger.Error("AnomalyDetector", $"CPU anomaly detection failed: {ex.Message}");
-        }
-    }
-
-    /// <summary>
-    /// Detects wait stat anomalies — significant waits in the analysis window
-    /// that were absent or much lower in the baseline.
-    /// </summary>
-    private async Task DetectWaitAnomalies(AnalysisContext context,
-        DateTime baselineStart, DateTime baselineEnd, List<Fact> anomalies)
-    {
-        try
-        {
-            using var readLock = _duckDb.AcquireReadLock();
-            using var connection = _duckDb.CreateConnection();
-            await connection.OpenAsync();
-
-            // Check if baseline has any wait data at all — if not, skip
-            using var checkCmd = connection.CreateCommand();
-            checkCmd.CommandText = @"
-SELECT COUNT(*) FROM v_wait_stats
-WHERE server_id = $1 AND collection_time >= $2 AND collection_time < $3";
-            checkCmd.Parameters.Add(new DuckDBParameter { Value = context.ServerId });
-            checkCmd.Parameters.Add(new DuckDBParameter { Value = baselineStart });
-            checkCmd.Parameters.Add(new DuckDBParameter { Value = baselineEnd });
-            var baselineCount = Convert.ToInt64(await checkCmd.ExecuteScalarAsync() ?? 0);
-            if (baselineCount == 0) return;
-
-            // Get per-wait-type totals in both windows
-            using var cmd = connection.CreateCommand();
-            cmd.CommandText = @"
-WITH baseline AS (
-    SELECT wait_type,
-           SUM(delta_wait_time_ms)::BIGINT AS total_ms
-    FROM v_wait_stats
-    WHERE server_id = $1 AND collection_time >= $2 AND collection_time < $3
-    AND   delta_wait_time_ms > 0
-    GROUP BY wait_type
-),
-current_window AS (
-    SELECT wait_type,
-           SUM(delta_wait_time_ms)::BIGINT AS total_ms
-    FROM v_wait_stats
-    WHERE server_id = $1 AND collection_time >= $4 AND collection_time <= $5
-    AND   delta_wait_time_ms > 0
-    GROUP BY wait_type
-)
-SELECT c.wait_type,
-       c.total_ms AS current_ms,
-       COALESCE(b.total_ms, 0) AS baseline_ms
-FROM current_window c
-LEFT JOIN baseline b ON c.wait_type = b.wait_type
-WHERE c.total_ms > 10000  -- At least 10 seconds of wait time
-ORDER BY c.total_ms DESC
-LIMIT 10";
-
-            cmd.Parameters.Add(new DuckDBParameter { Value = context.ServerId });
-            cmd.Parameters.Add(new DuckDBParameter { Value = baselineStart });
-            cmd.Parameters.Add(new DuckDBParameter { Value = baselineEnd });
-            cmd.Parameters.Add(new DuckDBParameter { Value = context.TimeRangeStart });
-            cmd.Parameters.Add(new DuckDBParameter { Value = context.TimeRangeEnd });
-
-            using var reader = await cmd.ExecuteReaderAsync();
-            while (await reader.ReadAsync())
-            {
-                var waitType = reader.GetString(0);
-                var currentMs = Convert.ToInt64(reader.GetValue(1));
-                var baselineMs = Convert.ToInt64(reader.GetValue(2));
-
-                // Normalize to per-hour rates before comparing (windows are different lengths)
-                var baselineHours = (baselineEnd - baselineStart).TotalHours;
-                var currentHours = (context.TimeRangeEnd - context.TimeRangeStart).TotalHours;
-                if (baselineHours <= 0) baselineHours = 1;
-                if (currentHours <= 0) currentHours = 1;
-
-                double ratio;
-                string anomalyType;
-
-                if (baselineMs == 0)
-                {
-                    ratio = currentMs > 60_000 ? 100.0 : 0; // Only flag if > 1 minute total
-                    anomalyType = "new";
-                }
-                else
-                {
-                    var baselineRate = baselineMs / baselineHours;
-                    var currentRate = currentMs / currentHours;
-                    ratio = baselineRate > 0 ? currentRate / baselineRate : 100.0;
-                    anomalyType = "spike";
-                }
-
-                if (ratio < 5.0) continue; // Need at least 5x increase
-
-                anomalies.Add(new Fact
-                {
-                    Source = "anomaly",
-                    Key = $"ANOMALY_WAIT_{waitType}",
-                    Value = currentMs,
-                    ServerId = context.ServerId,
-                    Metadata = new Dictionary<string, double>
-                    {
-                        ["current_ms"] = currentMs,
-                        ["baseline_ms"] = baselineMs,
-                        ["ratio"] = ratio,
-                        ["is_new"] = anomalyType == "new" ? 1 : 0
-                    }
-                });
-            }
-        }
-        catch (Exception ex)
-        {
-            AppLogger.Error("AnomalyDetector", $"Wait anomaly detection failed: {ex.Message}");
-        }
-    }
-
-    /// <summary>
-    /// Detects blocking/deadlock anomalies — events in the analysis window
-    /// that are significantly above baseline rates.
-    /// </summary>
-    private async Task DetectBlockingAnomalies(AnalysisContext context,
-        DateTime baselineStart, DateTime baselineEnd, List<Fact> anomalies)
-    {
-        try
-        {
-            using var readLock = _duckDb.AcquireReadLock();
-            using var connection = _duckDb.CreateConnection();
-            await connection.OpenAsync();
-
-            // Check if baseline period has any data at all
-            using var checkCmd = connection.CreateCommand();
-            checkCmd.CommandText = @"
-SELECT (SELECT COUNT(*) FROM v_blocked_process_reports
-        WHERE server_id = $1 AND collection_time >= $2 AND collection_time < $3)
-     + (SELECT COUNT(*) FROM v_deadlocks
-        WHERE server_id = $1 AND collection_time >= $2 AND collection_time < $3)
-     + (SELECT COUNT(*) FROM v_wait_stats
-        WHERE server_id = $1 AND collection_time >= $2 AND collection_time < $3)";
-            checkCmd.Parameters.Add(new DuckDBParameter { Value = context.ServerId });
-            checkCmd.Parameters.Add(new DuckDBParameter { Value = baselineStart });
-            checkCmd.Parameters.Add(new DuckDBParameter { Value = baselineEnd });
-            var baselineDataCount = Convert.ToInt64(await checkCmd.ExecuteScalarAsync() ?? 0);
-            if (baselineDataCount == 0) return; // No baseline data = can't detect anomaly
-
-            using var cmd = connection.CreateCommand();
-            cmd.CommandText = @"
-SELECT
-    (SELECT COUNT(*) FROM v_blocked_process_reports
-     WHERE server_id = $1 AND collection_time >= $2 AND collection_time < $3) AS baseline_blocking,
-    (SELECT COUNT(*) FROM v_blocked_process_reports
-     WHERE server_id = $1 AND collection_time >= $4 AND collection_time <= $5) AS current_blocking,
-    (SELECT COUNT(*) FROM v_deadlocks
-     WHERE server_id = $1 AND collection_time >= $2 AND collection_time < $3) AS baseline_deadlocks,
-    (SELECT COUNT(*) FROM v_deadlocks
-     WHERE server_id = $1 AND collection_time >= $4 AND collection_time <= $5) AS current_deadlocks";
-
-            cmd.Parameters.Add(new DuckDBParameter { Value = context.ServerId });
-            cmd.Parameters.Add(new DuckDBParameter { Value = baselineStart });
-            cmd.Parameters.Add(new DuckDBParameter { Value = baselineEnd });
-            cmd.Parameters.Add(new DuckDBParameter { Value = context.TimeRangeStart });
-            cmd.Parameters.Add(new DuckDBParameter { Value = context.TimeRangeEnd });
-
-            using var reader = await cmd.ExecuteReaderAsync();
-            if (!await reader.ReadAsync()) return;
-
-            var baselineBlocking = Convert.ToInt64(reader.GetValue(0));
-            var currentBlocking = Convert.ToInt64(reader.GetValue(1));
-            var baselineDeadlocks = Convert.ToInt64(reader.GetValue(2));
-            var currentDeadlocks = Convert.ToInt64(reader.GetValue(3));
-
-            // Normalize to per-hour rates (windows are different lengths)
-            var baselineHours = (baselineEnd - baselineStart).TotalHours;
-            var currentHours = (context.TimeRangeEnd - context.TimeRangeStart).TotalHours;
-            if (baselineHours <= 0) baselineHours = 1;
-            if (currentHours <= 0) currentHours = 1;
-
-            var baselineBlockingRate = baselineBlocking / baselineHours;
-            var currentBlockingRate = currentBlocking / currentHours;
-            var blockingRatio = baselineBlocking > 0 ? currentBlockingRate / baselineBlockingRate : 100.0;
-
-            var baselineDeadlockRate = baselineDeadlocks / baselineHours;
-            var currentDeadlockRate = currentDeadlocks / currentHours;
-            var deadlockRatio = baselineDeadlocks > 0 ? currentDeadlockRate / baselineDeadlockRate : 100.0;
-
-            // Blocking spike: at least 5 events AND 3x baseline rate (or new)
-            if (currentBlocking >= 5 && (baselineBlocking == 0 || blockingRatio >= 3))
-            {
-                anomalies.Add(new Fact
-                {
-                    Source = "anomaly",
-                    Key = "ANOMALY_BLOCKING_SPIKE",
-                    Value = currentBlocking,
-                    ServerId = context.ServerId,
-                    Metadata = new Dictionary<string, double>
-                    {
-                        ["current_count"] = currentBlocking,
-                        ["baseline_count"] = baselineBlocking,
-                        ["ratio"] = blockingRatio
-                    }
-                });
-            }
-
-            // Deadlock spike: at least 3 events AND 3x baseline rate (or new)
-            if (currentDeadlocks >= 3 && (baselineDeadlocks == 0 || deadlockRatio >= 3))
-            {
-                anomalies.Add(new Fact
-                {
-                    Source = "anomaly",
-                    Key = "ANOMALY_DEADLOCK_SPIKE",
-                    Value = currentDeadlocks,
-                    ServerId = context.ServerId,
-                    Metadata = new Dictionary<string, double>
-                    {
-                        ["current_count"] = currentDeadlocks,
-                        ["baseline_count"] = baselineDeadlocks,
-                        ["ratio"] = deadlockRatio
-                    }
-                });
-            }
-        }
-        catch (Exception ex)
-        {
-            AppLogger.Error("AnomalyDetector", $"Blocking anomaly detection failed: {ex.Message}");
-        }
-    }
-
-    /// <summary>
-    /// Detects I/O latency anomalies — significant increase in read/write latency
-    /// compared to baseline.
-    /// </summary>
-    private async Task DetectIoAnomalies(AnalysisContext context,
-        DateTime baselineStart, DateTime baselineEnd, List<Fact> anomalies)
-    {
-        try
-        {
-            using var readLock = _duckDb.AcquireReadLock();
-            using var connection = _duckDb.CreateConnection();
-            await connection.OpenAsync();
-
-            using var cmd = connection.CreateCommand();
-            cmd.CommandText = @"
-WITH baseline AS (
-    SELECT AVG(delta_stall_read_ms * 1.0 / NULLIF(delta_reads, 0)) AS avg_read_lat,
-           AVG(delta_stall_write_ms * 1.0 / NULLIF(delta_writes, 0)) AS avg_write_lat,
-           STDDEV_SAMP(delta_stall_read_ms * 1.0 / NULLIF(delta_reads, 0)) AS stddev_read,
-           STDDEV_SAMP(delta_stall_write_ms * 1.0 / NULLIF(delta_writes, 0)) AS stddev_write,
-           COUNT(*) AS samples
-    FROM v_file_io_stats
-    WHERE server_id = $1 AND collection_time >= $2 AND collection_time < $3
-    AND   (delta_reads > 0 OR delta_writes > 0)
-),
-current_window AS (
-    SELECT AVG(delta_stall_read_ms * 1.0 / NULLIF(delta_reads, 0)) AS avg_read_lat,
-           AVG(delta_stall_write_ms * 1.0 / NULLIF(delta_writes, 0)) AS avg_write_lat
-    FROM v_file_io_stats
-    WHERE server_id = $1 AND collection_time >= $4 AND collection_time <= $5
-    AND   (delta_reads > 0 OR delta_writes > 0)
-)
-SELECT b.avg_read_lat, b.stddev_read, c.avg_read_lat,
-       b.avg_write_lat, b.stddev_write, c.avg_write_lat,
-       b.samples
-FROM baseline b, current_window c";
-
-            cmd.Parameters.Add(new DuckDBParameter { Value = context.ServerId });
-            cmd.Parameters.Add(new DuckDBParameter { Value = baselineStart });
-            cmd.Parameters.Add(new DuckDBParameter { Value = baselineEnd });
-            cmd.Parameters.Add(new DuckDBParameter { Value = context.TimeRangeStart });
-            cmd.Parameters.Add(new DuckDBParameter { Value = context.TimeRangeEnd });
-
-            using var reader = await cmd.ExecuteReaderAsync();
-            if (!await reader.ReadAsync()) return;
-
-            var baselineReadLat = reader.IsDBNull(0) ? 0.0 : Convert.ToDouble(reader.GetValue(0));
-            var stddevRead = reader.IsDBNull(1) ? 0.0 : Convert.ToDouble(reader.GetValue(1));
-            var currentReadLat = reader.IsDBNull(2) ? 0.0 : Convert.ToDouble(reader.GetValue(2));
-            var baselineWriteLat = reader.IsDBNull(3) ? 0.0 : Convert.ToDouble(reader.GetValue(3));
-            var stddevWrite = reader.IsDBNull(4) ? 0.0 : Convert.ToDouble(reader.GetValue(4));
-            var currentWriteLat = reader.IsDBNull(5) ? 0.0 : Convert.ToDouble(reader.GetValue(5));
-            var samples = reader.IsDBNull(6) ? 0L : Convert.ToInt64(reader.GetValue(6));
-
-            if (samples < 3) return;
-
-            // Read latency anomaly
-            if (stddevRead > 0 && currentReadLat > 10) // At least 10ms to matter
-            {
-                var readDeviation = (currentReadLat - baselineReadLat) / stddevRead;
-                if (readDeviation >= DeviationThreshold)
-                {
-                    anomalies.Add(new Fact
-                    {
-                        Source = "anomaly",
-                        Key = "ANOMALY_READ_LATENCY",
-                        Value = currentReadLat,
-                        ServerId = context.ServerId,
-                        Metadata = new Dictionary<string, double>
-                        {
-                            ["current_latency_ms"] = currentReadLat,
-                            ["baseline_mean_ms"] = baselineReadLat,
-                            ["baseline_stddev_ms"] = stddevRead,
-                            ["deviation_sigma"] = readDeviation,
-                            ["baseline_samples"] = samples
-                        }
-                    });
-                }
-            }
-
-            // Write latency anomaly
-            if (stddevWrite > 0 && currentWriteLat > 5) // At least 5ms to matter
-            {
-                var writeDeviation = (currentWriteLat - baselineWriteLat) / stddevWrite;
-                if (writeDeviation >= DeviationThreshold)
-                {
-                    anomalies.Add(new Fact
-                    {
-                        Source = "anomaly",
-                        Key = "ANOMALY_WRITE_LATENCY",
-                        Value = currentWriteLat,
-                        ServerId = context.ServerId,
-                        Metadata = new Dictionary<string, double>
-                        {
-                            ["current_latency_ms"] = currentWriteLat,
-                            ["baseline_mean_ms"] = baselineWriteLat,
-                            ["baseline_stddev_ms"] = stddevWrite,
-                            ["deviation_sigma"] = writeDeviation,
-                            ["baseline_samples"] = samples
-                        }
-                    });
-                }
-            }
-        }
-        catch (Exception ex)
-        {
-            AppLogger.Error("AnomalyDetector", $"I/O anomaly detection failed: {ex.Message}");
-        }
-    }
-}
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+using DuckDB.NET.Data;
+using PerformanceMonitorLite.Database;
+using PerformanceMonitorLite.Services;
+
+namespace PerformanceMonitorLite.Analysis;
+
+/// <summary>
+/// Detects anomalies by comparing the analysis window's metrics against
+/// time-bucketed baselines (hour-of-day x day-of-week, 30-day rolling window).
+///
+/// Two detection patterns:
+/// - Z-score: (observed - mean) / stddev — used for continuous metrics
+///   (CPU, batch requests, I/O latency, session counts, query duration, memory)
+/// - Ratio: currentRate / baselineRate — used for rate/event metrics
+///   (wait stats, blocking, deadlocks)
+///
+/// Baseline computation and caching are handled by BaselineProvider.
+/// </summary>
+public class AnomalyDetector
+{
+    private readonly DuckDbInitializer _duckDb;
+    private readonly BaselineProvider _baselineProvider;
+
+    /// <summary>
+    /// Default number of standard deviations above baseline mean to flag as anomalous.
+    /// </summary>
+    private const double DefaultDeviationThreshold = 2.0;
+
+    /// <summary>
+    /// Default ratio threshold for rate-based anomaly detection (wait stats).
+    /// </summary>
+    private const double DefaultRatioThreshold = 5.0;
+
+    /// <summary>
+    /// Default ratio threshold for event-based anomaly detection (blocking/deadlocks).
+    /// </summary>
+    private const double DefaultEventRatioThreshold = 3.0;
+
+    /// <summary>
+    /// Per-metric deviation thresholds. Metrics not listed use DefaultDeviationThreshold.
+    /// </summary>
+    private readonly Dictionary<string, double> _deviationThresholds = new();
+
+    public AnomalyDetector(DuckDbInitializer duckDb, BaselineProvider baselineProvider)
+    {
+        _duckDb = duckDb;
+        _baselineProvider = baselineProvider;
+    }
+
+    /// <summary>
+    /// Sets a custom deviation threshold for a specific metric.
+    /// </summary>
+    public void SetDeviationThreshold(string metricName, double threshold)
+    {
+        _deviationThresholds[metricName] = threshold;
+    }
+
+    private double GetDeviationThreshold(string metricName)
+    {
+        return _deviationThresholds.TryGetValue(metricName, out var threshold)
+            ? threshold
+            : DefaultDeviationThreshold;
+    }
+
+    /// <summary>
+    /// Adds baseline context metadata to an anomaly fact's metadata dictionary.
+    /// </summary>
+    private static void AddBaselineContext(Dictionary<string, double> metadata, BaselineBucket baseline)
+    {
+        metadata["baseline_hour"] = baseline.HourOfDay;
+        metadata["baseline_dow"] = baseline.DayOfWeek;
+        metadata["baseline_tier"] = (double)baseline.Tier;
+    }
+
+    /// <summary>
+    /// Detects anomalies by comparing the analysis window against time-bucketed baselines.
+    /// Returns anomaly facts to be merged into the main fact list.
+    /// </summary>
+    public async Task<List<Fact>> DetectAnomaliesAsync(AnalysisContext context)
+    {
+        var anomalies = new List<Fact>();
+
+        // Check if baseline period has any data at all — if not, skip all anomaly detection.
+        if (!await HasBaselineDataAsync(context.ServerId))
+            return anomalies;
+
+        // Existing detection methods (upgraded to time-bucketed baselines)
+        await DetectCpuAnomalies(context, anomalies);
+        await DetectWaitAnomalies(context, anomalies);
+        await DetectBlockingAnomalies(context, anomalies);
+        await DetectIoAnomalies(context, anomalies);
+
+        // New detection methods
+        await DetectBatchRequestAnomalies(context, anomalies);
+        await DetectSessionAnomalies(context, anomalies);
+        await DetectQueryDurationAnomalies(context, anomalies);
+        await DetectMemoryAnomalies(context, anomalies);
+
+        return anomalies;
+    }
+
+    /// <summary>
+    /// Checks if the server has enough historical data for meaningful baselines.
+    /// Uses wait_stats as canary — if waits are collected, other data is too.
+    /// </summary>
+    private async Task<bool> HasBaselineDataAsync(int serverId)
+    {
+        try
+        {
+            using var readLock = _duckDb.AcquireReadLock();
+            using var connection = _duckDb.CreateConnection();
+            await connection.OpenAsync();
+
+            using var cmd = connection.CreateCommand();
+            cmd.CommandText = @"
+SELECT (SELECT COUNT(*) FROM v_wait_stats
+        WHERE server_id = $1 AND collection_time >= $2)
+     + (SELECT COUNT(*) FROM v_cpu_utilization_stats
+        WHERE server_id = $1 AND collection_time >= $2)";
+            cmd.Parameters.Add(new DuckDBParameter { Value = serverId });
+            cmd.Parameters.Add(new DuckDBParameter { Value = DateTime.UtcNow.AddDays(-30) });
+
+            var count = Convert.ToInt64(await cmd.ExecuteScalarAsync() ?? 0);
+            return count > 0;
+        }
+        catch { return false; }
+    }
+
+    /// <summary>
+    /// Detects CPU utilization anomalies using z-score against time-bucketed baseline.
+    /// </summary>
+    private async Task DetectCpuAnomalies(AnalysisContext context, List<Fact> anomalies)
+    {
+        try
+        {
+            var baseline = await _baselineProvider.GetBaselineAsync(
+                context.ServerId, MetricNames.Cpu, context.TimeRangeStart);
+
+            if (baseline.SampleCount == 0) return;
+            var effectiveStdDev = baseline.EffectiveStdDev;
+            if (effectiveStdDev <= 0) return; // Zero mean + zero stddev — skip
+
+            using var readLock = _duckDb.AcquireReadLock();
+            using var connection = _duckDb.CreateConnection();
+            await connection.OpenAsync();
+
+            using var cmd = connection.CreateCommand();
+            cmd.CommandText = @"
+SELECT MAX(sqlserver_cpu_utilization) AS peak_cpu,
+       AVG(sqlserver_cpu_utilization) AS avg_cpu,
+       COUNT(*) AS sample_count,
+       (SELECT collection_time FROM v_cpu_utilization_stats
+        WHERE server_id = $1 AND collection_time >= $2 AND collection_time < $3
+        ORDER BY sqlserver_cpu_utilization DESC LIMIT 1) AS peak_time
+FROM v_cpu_utilization_stats
+WHERE server_id = $1
+AND   collection_time >= $2 AND collection_time < $3";
+
+            cmd.Parameters.Add(new DuckDBParameter { Value = context.ServerId });
+            cmd.Parameters.Add(new DuckDBParameter { Value = context.TimeRangeStart });
+            cmd.Parameters.Add(new DuckDBParameter { Value = context.TimeRangeEnd });
+
+            using var reader = await cmd.ExecuteReaderAsync();
+            if (!await reader.ReadAsync()) return;
+
+            var peakCpu = reader.IsDBNull(0) ? 0.0 : Convert.ToDouble(reader.GetValue(0));
+            var avgCpu = reader.IsDBNull(1) ? 0.0 : Convert.ToDouble(reader.GetValue(1));
+            var windowSamples = reader.IsDBNull(2) ? 0L : Convert.ToInt64(reader.GetValue(2));
+            var peakTime = reader.IsDBNull(3) ? (DateTime?)null : reader.GetDateTime(3);
+
+            if (windowSamples == 0) return;
+
+            var deviation = (peakCpu - baseline.Mean) / effectiveStdDev;
+            if (deviation < GetDeviationThreshold(MetricNames.Cpu) || peakCpu < 50) return;
+
+            var metadata = new Dictionary<string, double>
+            {
+                ["peak_cpu"] = peakCpu,
+                ["avg_cpu_in_window"] = avgCpu,
+                ["baseline_mean"] = baseline.Mean,
+                ["baseline_stddev"] = effectiveStdDev,
+                ["deviation_sigma"] = deviation,
+                ["baseline_samples"] = baseline.SampleCount,
+                ["window_samples"] = windowSamples,
+                ["confidence"] = 1.0,
+                ["peak_time_ticks"] = peakTime?.Ticks ?? 0
+            };
+            AddBaselineContext(metadata, baseline);
+
+            anomalies.Add(new Fact
+            {
+                Source = "anomaly",
+                Key = "ANOMALY_CPU_SPIKE",
+                Value = peakCpu,
+                ServerId = context.ServerId,
+                Metadata = metadata
+            });
+        }
+        catch (Exception ex)
+        {
+            AppLogger.Error("AnomalyDetector", $"CPU anomaly detection failed: {ex.Message}");
+        }
+    }
+
+    /// <summary>
+    /// Detects wait stat anomalies — total wait time significantly above
+    /// baseline rate for this time bucket. Uses ratio-based scoring.
+    /// </summary>
+    private async Task DetectWaitAnomalies(AnalysisContext context, List<Fact> anomalies)
+    {
+        try
+        {
+            var baseline = await _baselineProvider.GetBaselineAsync(
+                context.ServerId, MetricNames.WaitStats, context.TimeRangeStart);
+
+            // No baseline data at all — can't distinguish "new" waits from "always present."
+            // Skip rather than flagging everything as anomalous.
+            if (baseline.SampleCount == 0) return;
+
+            using var readLock = _duckDb.AcquireReadLock();
+            using var connection = _duckDb.CreateConnection();
+            await connection.OpenAsync();
+
+            // Get per-wait-type totals in the analysis window
+            using var cmd = connection.CreateCommand();
+            cmd.CommandText = @"
+SELECT wait_type,
+       SUM(delta_wait_time_ms)::BIGINT AS total_ms
+FROM v_wait_stats
+WHERE server_id = $1 AND collection_time >= $2 AND collection_time <= $3
+AND   delta_wait_time_ms > 0
+GROUP BY wait_type
+HAVING SUM(delta_wait_time_ms) > 10000
+ORDER BY total_ms DESC
+LIMIT 10";
+
+            cmd.Parameters.Add(new DuckDBParameter { Value = context.ServerId });
+            cmd.Parameters.Add(new DuckDBParameter { Value = context.TimeRangeStart });
+            cmd.Parameters.Add(new DuckDBParameter { Value = context.TimeRangeEnd });
+
+            var currentHours = (context.TimeRangeEnd - context.TimeRangeStart).TotalHours;
+            if (currentHours <= 0) currentHours = 1;
+
+            // Baseline mean is total wait ms per collection interval for this time bucket.
+            // If no baseline, use ratio=100 for significant new waits.
+            var baselineRate = baseline.SampleCount > 0 ? baseline.Mean : 0;
+
+            using var reader = await cmd.ExecuteReaderAsync();
+            while (await reader.ReadAsync())
+            {
+                var waitType = reader.GetString(0);
+                var currentMs = Convert.ToInt64(reader.GetValue(1));
+                var currentRate = currentMs / currentHours;
+
+                double ratio;
+                string anomalyType;
+
+                if (baselineRate <= 0 || baseline.SampleCount == 0)
+                {
+                    ratio = currentMs > 60_000 ? 100.0 : 0;
+                    anomalyType = "new";
+                }
+                else
+                {
+                    ratio = currentRate / baselineRate;
+                    anomalyType = "spike";
+                }
+
+                if (ratio < DefaultRatioThreshold) continue;
+
+                var metadata = new Dictionary<string, double>
+                {
+                    ["current_ms"] = currentMs,
+                    ["baseline_mean"] = baseline.Mean,
+                    ["ratio"] = ratio,
+                    ["is_new"] = anomalyType == "new" ? 1 : 0
+                };
+                AddBaselineContext(metadata, baseline);
+
+                anomalies.Add(new Fact
+                {
+                    Source = "anomaly",
+                    Key = $"ANOMALY_WAIT_{waitType}",
+                    Value = currentMs,
+                    ServerId = context.ServerId,
+                    Metadata = metadata
+                });
+            }
+        }
+        catch (Exception ex)
+        {
+            AppLogger.Error("AnomalyDetector", $"Wait anomaly detection failed: {ex.Message}");
+        }
+    }
+
+    /// <summary>
+    /// Detects blocking/deadlock anomalies — event rates significantly above
+    /// baseline for this time bucket. Uses ratio-based scoring.
+    /// </summary>
+    private async Task DetectBlockingAnomalies(AnalysisContext context, List<Fact> anomalies)
+    {
+        try
+        {
+            var blockingBaseline = await _baselineProvider.GetBaselineAsync(
+                context.ServerId, MetricNames.Blocking, context.TimeRangeStart);
+            var deadlockBaseline = await _baselineProvider.GetBaselineAsync(
+                context.ServerId, MetricNames.Deadlock, context.TimeRangeStart);
+
+            using var readLock = _duckDb.AcquireReadLock();
+            using var connection = _duckDb.CreateConnection();
+            await connection.OpenAsync();
+
+            using var cmd = connection.CreateCommand();
+            cmd.CommandText = @"
+SELECT
+    (SELECT COUNT(*) FROM v_blocked_process_reports
+     WHERE server_id = $1 AND collection_time >= $2 AND collection_time <= $3) AS current_blocking,
+    (SELECT COUNT(*) FROM v_deadlocks
+     WHERE server_id = $1 AND collection_time >= $2 AND collection_time <= $3) AS current_deadlocks";
+
+            cmd.Parameters.Add(new DuckDBParameter { Value = context.ServerId });
+            cmd.Parameters.Add(new DuckDBParameter { Value = context.TimeRangeStart });
+            cmd.Parameters.Add(new DuckDBParameter { Value = context.TimeRangeEnd });
+
+            using var reader = await cmd.ExecuteReaderAsync();
+            if (!await reader.ReadAsync()) return;
+
+            var currentBlocking = Convert.ToInt64(reader.GetValue(0));
+            var currentDeadlocks = Convert.ToInt64(reader.GetValue(1));
+
+            // Baseline mean = events per day for this hour+dow bucket
+            var baselineBlockingRate = blockingBaseline.SampleCount > 0 ? blockingBaseline.Mean : 0;
+            var baselineDeadlockRate = deadlockBaseline.SampleCount > 0 ? deadlockBaseline.Mean : 0;
+
+            // Blocking spike: at least 5 events AND 3x baseline rate (or no baseline)
+            if (currentBlocking >= 5 && (baselineBlockingRate <= 0 || currentBlocking / Math.Max(baselineBlockingRate, 1) >= DefaultEventRatioThreshold))
+            {
+                var metadata = new Dictionary<string, double>
+                {
+                    ["current_count"] = currentBlocking,
+                    ["baseline_rate"] = baselineBlockingRate,
+                    ["ratio"] = baselineBlockingRate > 0 ? currentBlocking / baselineBlockingRate : 100.0
+                };
+                AddBaselineContext(metadata, blockingBaseline);
+
+                anomalies.Add(new Fact
+                {
+                    Source = "anomaly",
+                    Key = "ANOMALY_BLOCKING_SPIKE",
+                    Value = currentBlocking,
+                    ServerId = context.ServerId,
+                    Metadata = metadata
+                });
+            }
+
+            // Deadlock spike: at least 3 events AND 3x baseline rate (or no baseline)
+            if (currentDeadlocks >= 3 && (baselineDeadlockRate <= 0 || currentDeadlocks / Math.Max(baselineDeadlockRate, 1) >= DefaultEventRatioThreshold))
+            {
+                var metadata = new Dictionary<string, double>
+                {
+                    ["current_count"] = currentDeadlocks,
+                    ["baseline_rate"] = baselineDeadlockRate,
+                    ["ratio"] = baselineDeadlockRate > 0 ? currentDeadlocks / baselineDeadlockRate : 100.0
+                };
+                AddBaselineContext(metadata, deadlockBaseline);
+
+                anomalies.Add(new Fact
+                {
+                    Source = "anomaly",
+                    Key = "ANOMALY_DEADLOCK_SPIKE",
+                    Value = currentDeadlocks,
+                    ServerId = context.ServerId,
+                    Metadata = metadata
+                });
+            }
+        }
+        catch (Exception ex)
+        {
+            AppLogger.Error("AnomalyDetector", $"Blocking anomaly detection failed: {ex.Message}");
+        }
+    }
+
+    /// <summary>
+    /// Detects I/O latency anomalies using z-score against time-bucketed baseline.
+    /// </summary>
+    private async Task DetectIoAnomalies(AnalysisContext context, List<Fact> anomalies)
+    {
+        try
+        {
+            var baseline = await _baselineProvider.GetBaselineAsync(
+                context.ServerId, MetricNames.IoLatency, context.TimeRangeStart);
+
+            if (baseline.SampleCount == 0) return;
+            var effectiveStdDev = baseline.EffectiveStdDev;
+            if (effectiveStdDev <= 0) return;
+
+            using var readLock = _duckDb.AcquireReadLock();
+            using var connection = _duckDb.CreateConnection();
+            await connection.OpenAsync();
+
+            using var cmd = connection.CreateCommand();
+            cmd.CommandText = @"
+SELECT AVG(delta_stall_read_ms * 1.0 / NULLIF(delta_reads, 0)) AS avg_read_lat,
+       AVG(delta_stall_write_ms * 1.0 / NULLIF(delta_writes, 0)) AS avg_write_lat
+FROM v_file_io_stats
+WHERE server_id = $1 AND collection_time >= $2 AND collection_time <= $3
+AND   (delta_reads > 0 OR delta_writes > 0)";
+
+            cmd.Parameters.Add(new DuckDBParameter { Value = context.ServerId });
+            cmd.Parameters.Add(new DuckDBParameter { Value = context.TimeRangeStart });
+            cmd.Parameters.Add(new DuckDBParameter { Value = context.TimeRangeEnd });
+
+            using var reader = await cmd.ExecuteReaderAsync();
+            if (!await reader.ReadAsync()) return;
+
+            var currentReadLat = reader.IsDBNull(0) ? 0.0 : Convert.ToDouble(reader.GetValue(0));
+            var currentWriteLat = reader.IsDBNull(1) ? 0.0 : Convert.ToDouble(reader.GetValue(1));
+
+            var ioThreshold = GetDeviationThreshold(MetricNames.IoLatency);
+
+            // Read latency anomaly
+            if (currentReadLat > 10)
+            {
+                var readDeviation = (currentReadLat - baseline.Mean) / effectiveStdDev;
+                if (readDeviation >= ioThreshold)
+                {
+                    var metadata = new Dictionary<string, double>
+                    {
+                        ["current_latency_ms"] = currentReadLat,
+                        ["baseline_mean_ms"] = baseline.Mean,
+                        ["baseline_stddev_ms"] = effectiveStdDev,
+                        ["deviation_sigma"] = readDeviation,
+                        ["baseline_samples"] = baseline.SampleCount
+                    };
+                    AddBaselineContext(metadata, baseline);
+
+                    anomalies.Add(new Fact
+                    {
+                        Source = "anomaly",
+                        Key = "ANOMALY_READ_LATENCY",
+                        Value = currentReadLat,
+                        ServerId = context.ServerId,
+                        Metadata = metadata
+                    });
+                }
+            }
+
+            // Write latency anomaly
+            if (currentWriteLat > 5)
+            {
+                var writeDeviation = (currentWriteLat - baseline.Mean) / effectiveStdDev;
+                if (writeDeviation >= ioThreshold)
+                {
+                    var metadata = new Dictionary<string, double>
+                    {
+                        ["current_latency_ms"] = currentWriteLat,
+                        ["baseline_mean_ms"] = baseline.Mean,
+                        ["baseline_stddev_ms"] = effectiveStdDev,
+                        ["deviation_sigma"] = writeDeviation,
+                        ["baseline_samples"] = baseline.SampleCount
+                    };
+                    AddBaselineContext(metadata, baseline);
+
+                    anomalies.Add(new Fact
+                    {
+                        Source = "anomaly",
+                        Key = "ANOMALY_WRITE_LATENCY",
+                        Value = currentWriteLat,
+                        ServerId = context.ServerId,
+                        Metadata = metadata
+                    });
+                }
+            }
+        }
+        catch (Exception ex)
+        {
+            AppLogger.Error("AnomalyDetector", $"I/O anomaly detection failed: {ex.Message}");
+        }
+    }
+
+    /// <summary>
+    /// Detects batch requests/sec anomalies using z-score against time-bucketed baseline.
+    /// </summary>
+    private async Task DetectBatchRequestAnomalies(AnalysisContext context, List<Fact> anomalies)
+    {
+        try
+        {
+            var baseline = await _baselineProvider.GetBaselineAsync(
+                context.ServerId, MetricNames.BatchRequests, context.TimeRangeStart);
+
+            if (baseline.SampleCount == 0) return;
+            var effectiveStdDev = baseline.EffectiveStdDev;
+            if (effectiveStdDev <= 0) return;
+
+            using var readLock = _duckDb.AcquireReadLock();
+            using var connection = _duckDb.CreateConnection();
+            await connection.OpenAsync();
+
+            using var cmd = connection.CreateCommand();
+            cmd.CommandText = @"
+SELECT AVG(delta_cntr_value) AS avg_batch,
+       MAX(delta_cntr_value) AS peak_batch,
+       COUNT(*) AS sample_count
+FROM v_perfmon_stats
+WHERE server_id = $1 AND collection_time >= $2 AND collection_time <= $3
+AND   counter_name = 'Batch Requests/sec'
+AND   delta_cntr_value >= 0";
+
+            cmd.Parameters.Add(new DuckDBParameter { Value = context.ServerId });
+            cmd.Parameters.Add(new DuckDBParameter { Value = context.TimeRangeStart });
+            cmd.Parameters.Add(new DuckDBParameter { Value = context.TimeRangeEnd });
+
+            using var reader = await cmd.ExecuteReaderAsync();
+            if (!await reader.ReadAsync()) return;
+
+            var avgBatch = reader.IsDBNull(0) ? 0.0 : Convert.ToDouble(reader.GetValue(0));
+            var peakBatch = reader.IsDBNull(1) ? 0.0 : Convert.ToDouble(reader.GetValue(1));
+            var windowSamples = reader.IsDBNull(2) ? 0L : Convert.ToInt64(reader.GetValue(2));
+
+            if (windowSamples == 0) return;
+
+            var deviation = (peakBatch - baseline.Mean) / effectiveStdDev;
+            if (deviation < GetDeviationThreshold(MetricNames.BatchRequests)) return;
+
+            var metadata = new Dictionary<string, double>
+            {
+                ["peak_batch_requests"] = peakBatch,
+                ["avg_batch_requests"] = avgBatch,
+                ["baseline_mean"] = baseline.Mean,
+                ["baseline_stddev"] = effectiveStdDev,
+                ["deviation_sigma"] = deviation,
+                ["baseline_samples"] = baseline.SampleCount,
+                ["window_samples"] = windowSamples
+            };
+            AddBaselineContext(metadata, baseline);
+
+            anomalies.Add(new Fact
+            {
+                Source = "anomaly",
+                Key = "ANOMALY_BATCH_REQUESTS",
+                Value = peakBatch,
+                ServerId = context.ServerId,
+                Metadata = metadata
+            });
+        }
+        catch (Exception ex)
+        {
+            AppLogger.Error("AnomalyDetector", $"Batch request anomaly detection failed: {ex.Message}");
+        }
+    }
+
+    /// <summary>
+    /// Detects session/connection count anomalies using z-score against time-bucketed baseline.
+    /// </summary>
+    private async Task DetectSessionAnomalies(AnalysisContext context, List<Fact> anomalies)
+    {
+        try
+        {
+            var baseline = await _baselineProvider.GetBaselineAsync(
+                context.ServerId, MetricNames.SessionCount, context.TimeRangeStart);
+
+            if (baseline.SampleCount == 0) return;
+            var effectiveStdDev = baseline.EffectiveStdDev;
+            if (effectiveStdDev <= 0) return;
+
+            using var readLock = _duckDb.AcquireReadLock();
+            using var connection = _duckDb.CreateConnection();
+            await connection.OpenAsync();
+
+            using var cmd = connection.CreateCommand();
+            cmd.CommandText = @"
+WITH per_collection AS (
+    SELECT collection_time,
+           SUM(connection_count)::DOUBLE AS total_connections
+    FROM v_session_stats
+    WHERE server_id = $1 AND collection_time >= $2 AND collection_time <= $3
+    GROUP BY collection_time
+)
+SELECT AVG(total_connections) AS avg_connections,
+       MAX(total_connections) AS peak_connections,
+       COUNT(*) AS sample_count
+FROM per_collection";
+
+            cmd.Parameters.Add(new DuckDBParameter { Value = context.ServerId });
+            cmd.Parameters.Add(new DuckDBParameter { Value = context.TimeRangeStart });
+            cmd.Parameters.Add(new DuckDBParameter { Value = context.TimeRangeEnd });
+
+            using var reader = await cmd.ExecuteReaderAsync();
+            if (!await reader.ReadAsync()) return;
+
+            var avgConnections = reader.IsDBNull(0) ? 0.0 : Convert.ToDouble(reader.GetValue(0));
+            var peakConnections = reader.IsDBNull(1) ? 0.0 : Convert.ToDouble(reader.GetValue(1));
+            var windowSamples = reader.IsDBNull(2) ? 0L : Convert.ToInt64(reader.GetValue(2));
+
+            if (windowSamples == 0) return;
+
+            var deviation = (peakConnections - baseline.Mean) / effectiveStdDev;
+            if (deviation < GetDeviationThreshold(MetricNames.SessionCount)) return;
+
+            var metadata = new Dictionary<string, double>
+            {
+                ["peak_connections"] = peakConnections,
+                ["avg_connections"] = avgConnections,
+                ["baseline_mean"] = baseline.Mean,
+                ["baseline_stddev"] = effectiveStdDev,
+                ["deviation_sigma"] = deviation,
+                ["baseline_samples"] = baseline.SampleCount,
+                ["window_samples"] = windowSamples
+            };
+            AddBaselineContext(metadata, baseline);
+
+            anomalies.Add(new Fact
+            {
+                Source = "anomaly",
+                Key = "ANOMALY_SESSION_SPIKE",
+                Value = peakConnections,
+                ServerId = context.ServerId,
+                Metadata = metadata
+            });
+        }
+        catch (Exception ex)
+        {
+            AppLogger.Error("AnomalyDetector", $"Session anomaly detection failed: {ex.Message}");
+        }
+    }
+
+    /// <summary>
+    /// Detects query duration aggregate anomalies using z-score against time-bucketed baseline.
+    /// Measures total elapsed time across all queries per collection interval.
+    /// </summary>
+    private async Task DetectQueryDurationAnomalies(AnalysisContext context, List<Fact> anomalies)
+    {
+        try
+        {
+            var baseline = await _baselineProvider.GetBaselineAsync(
+                context.ServerId, MetricNames.QueryDuration, context.TimeRangeStart);
+
+            if (baseline.SampleCount == 0) return;
+            var effectiveStdDev = baseline.EffectiveStdDev;
+            if (effectiveStdDev <= 0) return;
+
+            using var readLock = _duckDb.AcquireReadLock();
+            using var connection = _duckDb.CreateConnection();
+            await connection.OpenAsync();
+
+            using var cmd = connection.CreateCommand();
+            cmd.CommandText = @"
+WITH per_collection AS (
+    SELECT collection_time,
+           SUM(delta_elapsed_time)::DOUBLE AS total_elapsed
+    FROM v_query_stats
+    WHERE server_id = $1 AND collection_time >= $2 AND collection_time <= $3
+    AND   delta_execution_count > 0
+    AND   delta_elapsed_time >= 0
+    GROUP BY collection_time
+)
+SELECT AVG(total_elapsed) AS avg_elapsed,
+       MAX(total_elapsed) AS peak_elapsed,
+       COUNT(*) AS sample_count
+FROM per_collection";
+
+            cmd.Parameters.Add(new DuckDBParameter { Value = context.ServerId });
+            cmd.Parameters.Add(new DuckDBParameter { Value = context.TimeRangeStart });
+            cmd.Parameters.Add(new DuckDBParameter { Value = context.TimeRangeEnd });
+
+            using var reader = await cmd.ExecuteReaderAsync();
+            if (!await reader.ReadAsync()) return;
+
+            var avgElapsed = reader.IsDBNull(0) ? 0.0 : Convert.ToDouble(reader.GetValue(0));
+            var peakElapsed = reader.IsDBNull(1) ? 0.0 : Convert.ToDouble(reader.GetValue(1));
+            var windowSamples = reader.IsDBNull(2) ? 0L : Convert.ToInt64(reader.GetValue(2));
+
+            if (windowSamples == 0) return;
+
+            var deviation = (peakElapsed - baseline.Mean) / effectiveStdDev;
+            if (deviation < GetDeviationThreshold(MetricNames.QueryDuration)) return;
+
+            var metadata = new Dictionary<string, double>
+            {
+                ["peak_total_elapsed_us"] = peakElapsed,
+                ["avg_total_elapsed_us"] = avgElapsed,
+                ["baseline_mean"] = baseline.Mean,
+                ["baseline_stddev"] = effectiveStdDev,
+                ["deviation_sigma"] = deviation,
+                ["baseline_samples"] = baseline.SampleCount,
+                ["window_samples"] = windowSamples
+            };
+            AddBaselineContext(metadata, baseline);
+
+            anomalies.Add(new Fact
+            {
+                Source = "anomaly",
+                Key = "ANOMALY_QUERY_DURATION",
+                Value = peakElapsed,
+                ServerId = context.ServerId,
+                Metadata = metadata
+            });
+        }
+        catch (Exception ex)
+        {
+            AppLogger.Error("AnomalyDetector", $"Query duration anomaly detection failed: {ex.Message}");
+        }
+    }
+
+    /// <summary>
+    /// Detects memory utilization anomalies using z-score against time-bucketed baseline.
+    /// Lite-only — Dashboard does not collect memory metrics.
+    /// Measures total_server_memory_mb / target_server_memory_mb as memory pressure %.
+    /// </summary>
+    private async Task DetectMemoryAnomalies(AnalysisContext context, List<Fact> anomalies)
+    {
+        try
+        {
+            var baseline = await _baselineProvider.GetBaselineAsync(
+                context.ServerId, MetricNames.Memory, context.TimeRangeStart);
+
+            if (baseline.SampleCount == 0) return;
+            var effectiveStdDev = baseline.EffectiveStdDev;
+            if (effectiveStdDev <= 0) return;
+
+            using var readLock = _duckDb.AcquireReadLock();
+            using var connection = _duckDb.CreateConnection();
+            await connection.OpenAsync();
+
+            using var cmd = connection.CreateCommand();
+            cmd.CommandText = @"
+SELECT AVG(total_server_memory_mb::DOUBLE / NULLIF(target_server_memory_mb::DOUBLE, 0) * 100) AS avg_pressure,
+       MAX(total_server_memory_mb::DOUBLE / NULLIF(target_server_memory_mb::DOUBLE, 0) * 100) AS peak_pressure,
+       COUNT(*) AS sample_count
+FROM v_memory_stats
+WHERE server_id = $1 AND collection_time >= $2 AND collection_time <= $3
+AND   target_server_memory_mb > 0";
+
+            cmd.Parameters.Add(new DuckDBParameter { Value = context.ServerId });
+            cmd.Parameters.Add(new DuckDBParameter { Value = context.TimeRangeStart });
+            cmd.Parameters.Add(new DuckDBParameter { Value = context.TimeRangeEnd });
+
+            using var reader = await cmd.ExecuteReaderAsync();
+            if (!await reader.ReadAsync()) return;
+
+            var avgPressure = reader.IsDBNull(0) ? 0.0 : Convert.ToDouble(reader.GetValue(0));
+            var peakPressure = reader.IsDBNull(1) ? 0.0 : Convert.ToDouble(reader.GetValue(1));
+            var windowSamples = reader.IsDBNull(2) ? 0L : Convert.ToInt64(reader.GetValue(2));
+
+            if (windowSamples == 0) return;
+
+            var deviation = (peakPressure - baseline.Mean) / effectiveStdDev;
+            if (deviation < GetDeviationThreshold(MetricNames.Memory)) return;
+
+            var metadata = new Dictionary<string, double>
+            {
+                ["peak_memory_pressure_pct"] = peakPressure,
+                ["avg_memory_pressure_pct"] = avgPressure,
+                ["baseline_mean"] = baseline.Mean,
+                ["baseline_stddev"] = effectiveStdDev,
+                ["deviation_sigma"] = deviation,
+                ["baseline_samples"] = baseline.SampleCount,
+                ["window_samples"] = windowSamples
+            };
+            AddBaselineContext(metadata, baseline);
+
+            anomalies.Add(new Fact
+            {
+                Source = "anomaly",
+                Key = "ANOMALY_MEMORY_PRESSURE",
+                Value = peakPressure,
+                ServerId = context.ServerId,
+                Metadata = metadata
+            });
+        }
+        catch (Exception ex)
+        {
+            AppLogger.Error("AnomalyDetector", $"Memory anomaly detection failed: {ex.Message}");
+        }
+    }
+}
diff --git a/Lite/Analysis/BaselineProvider.cs b/Lite/Analysis/BaselineProvider.cs
new file mode 100644
index 0000000..fc40d2b
--- /dev/null
+++ b/Lite/Analysis/BaselineProvider.cs
@@ -0,0 +1,544 @@
+using System;
+using System.Collections.Concurrent;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+using DuckDB.NET.Data;
+using PerformanceMonitorLite.Database;
+using PerformanceMonitorLite.Services;
+
+namespace PerformanceMonitorLite.Analysis;
+
+/// <summary>
+/// Provides time-bucketed baselines (hour-of-day x day-of-week) computed from
+/// 30-day rolling history in DuckDB. Replaces the flat 24-hour lookback used
+/// by the previous anomaly detection implementation.
+///
+/// Each baseline bucket contains mean, stddev, and sample count for a metric
+/// at a specific (hour, day-of-week) combination. When a bucket has insufficient
+/// samples, the provider collapses to less-specific tiers:
+///   Full (hour+dow) -> Hour-only -> Flat (global mean/stddev)
+///
+/// Baselines are cached in memory with a 1-hour TTL to avoid redundant
+/// recomputation during rapid re-analysis.
+/// </summary>
+public class BaselineProvider
+{
+    private readonly DuckDbInitializer _duckDb;
+
+    /// <summary>Rolling window for baseline computation.</summary>
+    private const int BaselineWindowDays = 30;
+
+    /// <summary>Collapse to hour-only when full bucket has fewer than this many samples.</summary>
+    private const int CollapseThreshold = 10;
+
+    /// <summary>Restore to full bucket when sample count reaches this level (hysteresis).</summary>
+    private const int RestoreThreshold = 15;
+
+    /// <summary>Cache TTL — baselines are recomputed after this interval.</summary>
+    public static TimeSpan CacheTtl { get; set; } = TimeSpan.FromHours(1);
+
+    private readonly ConcurrentDictionary<string, CachedBaseline> _cache = new();
+
+    public BaselineProvider(DuckDbInitializer duckDb)
+    {
+        _duckDb = duckDb;
+    }
+
+    /// <summary>
+    /// Gets the baseline for a specific metric, server, and time bucket.
+    /// Returns the most specific bucket available, collapsing as needed.
+    /// </summary>
+    public async Task<BaselineBucket> GetBaselineAsync(
+        int serverId, string metricName, DateTime analysisTime)
+    {
+        var hourOfDay = analysisTime.Hour;
+        var dayOfWeek = (int)analysisTime.DayOfWeek; // Sunday=0
+
+        var baselines = await GetOrComputeBaselinesAsync(serverId, metricName, analysisTime);
+        if (baselines == null || baselines.Count == 0)
+            return BaselineBucket.Empty;
+
+        // Try full bucket (hour + day-of-week)
+        var fullKey = (hourOfDay, dayOfWeek);
+        if (baselines.TryGetValue(fullKey, out var fullBucket) && fullBucket.SampleCount >= RestoreThreshold)
+            return fullBucket;
+
+        // If full bucket exists but below restore threshold, check if it's above collapse threshold
+        // (hysteresis: don't collapse if we're between 10-14 samples and were previously using full)
+        if (fullBucket != null && fullBucket.SampleCount >= CollapseThreshold)
+            return fullBucket;
+
+        // Collapse to hour-only: aggregate all days for this hour
+        var hourBuckets = baselines
+            .Where(kvp => kvp.Key.HourOfDay == hourOfDay)
+            .Select(kvp => kvp.Value)
+            .ToList();
+
+        if (hourBuckets.Count > 0)
+        {
+            var collapsed = CollapseToHourOnly(hourBuckets);
+            if (collapsed.SampleCount >= CollapseThreshold)
+                return collapsed;
+        }
+
+        // Collapse to flat: aggregate everything
+        var allBuckets = baselines.Values.ToList();
+        if (allBuckets.Count > 0)
+        {
+            var flat = CollapseToFlat(allBuckets);
+            if (flat.SampleCount >= 3) // Minimum viable baseline
+                return flat;
+        }
+
+        return BaselineBucket.Empty;
+    }
+
+    /// <summary>
+    /// Gets all baseline buckets for a metric/server. Used by UI for rendering
+    /// expected-range bands across all time slots.
+    /// </summary>
+    public async Task<Dictionary<(int HourOfDay, int DayOfWeek), BaselineBucket>?> GetAllBaselinesAsync(
+        int serverId, string metricName, DateTime analysisTime)
+    {
+        return await GetOrComputeBaselinesAsync(serverId, metricName, analysisTime);
+    }
+
+    /// <summary>Forces cache eviction for a server — used during testing.</summary>
+    public void InvalidateCache(int serverId)
+    {
+        var keysToRemove = _cache.Keys.Where(k => k.StartsWith($"{serverId}:", StringComparison.Ordinal)).ToList();
+        foreach (var key in keysToRemove)
+            _cache.TryRemove(key, out _);
+    }
+
+    /// <summary>Forces full cache clear — used during testing.</summary>
+    public void ClearCache() => _cache.Clear();
+
+    private async Task<Dictionary<(int HourOfDay, int DayOfWeek), BaselineBucket>?> GetOrComputeBaselinesAsync(
+        int serverId, string metricName, DateTime analysisTime)
+    {
+        var cacheKey = $"{serverId}:{metricName}";
+        var roundedHour = new DateTime(analysisTime.Year, analysisTime.Month, analysisTime.Day, analysisTime.Hour, 0, 0);
+
+        if (_cache.TryGetValue(cacheKey, out var cached) &&
+            cached.ComputedAt == roundedHour &&
+            (DateTime.UtcNow - cached.RealTime) < CacheTtl)
+        {
+            return cached.Buckets;
+        }
+
+        var buckets = await ComputeBaselinesAsync(serverId, metricName, analysisTime);
+
+        _cache[cacheKey] = new CachedBaseline
+        {
+            ComputedAt = roundedHour,
+            RealTime = DateTime.UtcNow,
+            Buckets = buckets
+        };
+
+        return buckets;
+    }
+
+    private async Task<Dictionary<(int HourOfDay, int DayOfWeek), BaselineBucket>?> ComputeBaselinesAsync(
+        int serverId, string metricName, DateTime analysisTime)
+    {
+        var query = GetBaselineQuery(metricName);
+        if (query == null) return null;
+
+        var windowStart = analysisTime.AddDays(-BaselineWindowDays);
+
+        try
+        {
+            using var readLock = _duckDb.AcquireReadLock();
+            using var connection = _duckDb.CreateConnection();
+            await connection.OpenAsync();
+
+            using var cmd = connection.CreateCommand();
+            cmd.CommandText = query;
+            cmd.Parameters.Add(new DuckDBParameter { Value = serverId });
+            cmd.Parameters.Add(new DuckDBParameter { Value = windowStart });
+            cmd.Parameters.Add(new DuckDBParameter { Value = analysisTime });
+
+            var buckets = new Dictionary<(int, int), BaselineBucket>();
+
+            using var reader = await cmd.ExecuteReaderAsync();
+            while (await reader.ReadAsync())
+            {
+                var hour = Convert.ToInt32(reader.GetValue(0));
+                var dow = Convert.ToInt32(reader.GetValue(1));
+                var mean = reader.IsDBNull(2) ? 0.0 : Convert.ToDouble(reader.GetValue(2));
+                var stddev = reader.IsDBNull(3) ? 0.0 : Convert.ToDouble(reader.GetValue(3));
+                var count = reader.IsDBNull(4) ? 0L : Convert.ToInt64(reader.GetValue(4));
+
+                buckets[(hour, dow)] = new BaselineBucket
+                {
+                    HourOfDay = hour,
+                    DayOfWeek = dow,
+                    Mean = mean,
+                    StdDev = stddev,
+                    SampleCount = count,
+                    Tier = count >= RestoreThreshold ? BaselineTier.Full
+                         : count >= CollapseThreshold ? BaselineTier.Full
+                         : BaselineTier.HourOnly
+                };
+            }
+
+            return buckets;
+        }
+        catch (Exception ex)
+        {
+            AppLogger.Error("BaselineProvider", $"Failed to compute baselines for {metricName}: {ex.Message}");
+            return null;
+        }
+    }
+
+    private static string? GetBaselineQuery(string metricName)
+    {
+        // All queries return: hour_of_day, day_of_week, mean_val, stddev_val, sample_count
+        // Cumulative metrics (batch requests, wait stats, query duration) use CTEs for
+        // restart poisoning exclusion — exclude samples where value drops to near-zero
+        // when the prior sample was significantly higher.
+        // Multi-row-per-collection metrics (waits, sessions, queries) aggregate per
+        // collection_time first, then bucket by hour+dow.
+        return metricName switch
+        {
+            // Point-in-time metric — no restart exclusion needed
+            MetricNames.Cpu => @"
+SELECT EXTRACT(HOUR FROM collection_time)::INT AS hour_of_day,
+       EXTRACT(DOW FROM collection_time)::INT AS day_of_week,
+       AVG(sqlserver_cpu_utilization) AS mean_val,
+       STDDEV_SAMP(sqlserver_cpu_utilization) AS stddev_val,
+       COUNT(*) AS sample_count
+FROM v_cpu_utilization_stats
+WHERE server_id = $1 AND collection_time >= $2 AND collection_time < $3
+GROUP BY hour_of_day, day_of_week",
+
+            // Cumulative counter — restart exclusion via subquery with QUALIFY.
+            // Excludes samples where delta drops to 0 when prior sample was > 1000
+            // (restart signature for cumulative counters).
+            MetricNames.BatchRequests => @"
+SELECT EXTRACT(HOUR FROM collection_time)::INT AS hour_of_day,
+       EXTRACT(DOW FROM collection_time)::INT AS day_of_week,
+       AVG(delta_cntr_value) AS mean_val,
+       STDDEV_SAMP(delta_cntr_value) AS stddev_val,
+       COUNT(*) AS sample_count
+FROM (
+    SELECT collection_time, delta_cntr_value
+    FROM v_perfmon_stats
+    WHERE server_id = $1 AND collection_time >= $2 AND collection_time < $3
+    AND   counter_name = 'Batch Requests/sec'
+    AND   delta_cntr_value >= 0
+    QUALIFY NOT (delta_cntr_value = 0
+        AND COALESCE(LAG(delta_cntr_value) OVER (ORDER BY collection_time), 0) > 1000)
+)
+GROUP BY hour_of_day, day_of_week",
+
+            // Cumulative counter, multiple rows per collection (per wait type) —
+            // aggregate to total wait ms per collection first, then QUALIFY for restart exclusion
+            MetricNames.WaitStats => @"
+WITH per_collection AS (
+    SELECT collection_time,
+           SUM(delta_wait_time_ms) AS total_wait_ms
+    FROM v_wait_stats
+    WHERE server_id = $1 AND collection_time >= $2 AND collection_time < $3
+    AND   delta_wait_time_ms >= 0
+    GROUP BY collection_time
+    QUALIFY NOT (total_wait_ms = 0
+        AND COALESCE(LAG(total_wait_ms) OVER (ORDER BY collection_time), 0) > 10000)
+)
+SELECT EXTRACT(HOUR FROM collection_time)::INT AS hour_of_day,
+       EXTRACT(DOW FROM collection_time)::INT AS day_of_week,
+       AVG(total_wait_ms) AS mean_val,
+       STDDEV_SAMP(total_wait_ms) AS stddev_val,
+       COUNT(*) AS sample_count
+FROM per_collection
+GROUP BY hour_of_day, day_of_week",
+
+            // Point-in-time, multiple rows per collection (per program_name) —
+            // aggregate to total connections per collection first
+            MetricNames.SessionCount => @"
+WITH per_collection AS (
+    SELECT collection_time,
+           SUM(connection_count) AS total_connections
+    FROM v_session_stats
+    WHERE server_id = $1 AND collection_time >= $2 AND collection_time < $3
+    GROUP BY collection_time
+)
+SELECT EXTRACT(HOUR FROM collection_time)::INT AS hour_of_day,
+       EXTRACT(DOW FROM collection_time)::INT AS day_of_week,
+       AVG(total_connections) AS mean_val,
+       STDDEV_SAMP(total_connections) AS stddev_val,
+       COUNT(*) AS sample_count
+FROM per_collection
+GROUP BY hour_of_day, day_of_week",
+
+            // Cumulative (plan cache), multiple rows per collection (per query) —
+            // use delta columns, aggregate total elapsed per collection, QUALIFY for restart exclusion
+            MetricNames.QueryDuration => @"
+WITH per_collection AS (
+    SELECT collection_time,
+           SUM(delta_elapsed_time) AS total_elapsed
+    FROM v_query_stats
+    WHERE server_id = $1 AND collection_time >= $2 AND collection_time < $3
+    AND   delta_execution_count > 0
+    AND   delta_elapsed_time >= 0
+    GROUP BY collection_time
+    QUALIFY NOT (total_elapsed = 0
+        AND COALESCE(LAG(total_elapsed) OVER (ORDER BY collection_time), 0) > 100000)
+)
+SELECT EXTRACT(HOUR FROM collection_time)::INT AS hour_of_day,
+       EXTRACT(DOW FROM collection_time)::INT AS day_of_week,
+       AVG(total_elapsed) AS mean_val,
+       STDDEV_SAMP(total_elapsed) AS stddev_val,
+       COUNT(*) AS sample_count
+FROM per_collection
+GROUP BY hour_of_day, day_of_week",
+
+            // Point-in-time metric — no restart exclusion needed
+            MetricNames.IoLatency => @"
+SELECT EXTRACT(HOUR FROM collection_time)::INT AS hour_of_day,
+       EXTRACT(DOW FROM collection_time)::INT AS day_of_week,
+       AVG(delta_stall_read_ms * 1.0 / NULLIF(delta_reads, 0)) AS mean_val,
+       STDDEV_SAMP(delta_stall_read_ms * 1.0 / NULLIF(delta_reads, 0)) AS stddev_val,
+       COUNT(*) AS sample_count
+FROM v_file_io_stats
+WHERE server_id = $1 AND collection_time >= $2 AND collection_time < $3
+AND   (delta_reads > 0 OR delta_writes > 0)
+GROUP BY hour_of_day, day_of_week",
+
+            // Event-based — mean = events per day for this bucket, sample_count = distinct days observed.
+            // No restart exclusion needed (event counts, not cumulative).
+            MetricNames.Blocking => @"
+SELECT EXTRACT(HOUR FROM collection_time)::INT AS hour_of_day,
+       EXTRACT(DOW FROM collection_time)::INT AS day_of_week,
+       COUNT(*)::DOUBLE / GREATEST(COUNT(DISTINCT collection_time::DATE), 1) AS mean_val,
+       0::DOUBLE AS stddev_val,
+       COUNT(DISTINCT collection_time::DATE) AS sample_count
+FROM v_blocked_process_reports
+WHERE server_id = $1 AND collection_time >= $2 AND collection_time < $3
+GROUP BY hour_of_day, day_of_week",
+
+            // Event-based — same approach as blocking
+            MetricNames.Deadlock => @"
+SELECT EXTRACT(HOUR FROM collection_time)::INT AS hour_of_day,
+       EXTRACT(DOW FROM collection_time)::INT AS day_of_week,
+       COUNT(*)::DOUBLE / GREATEST(COUNT(DISTINCT collection_time::DATE), 1) AS mean_val,
+       0::DOUBLE AS stddev_val,
+       COUNT(DISTINCT collection_time::DATE) AS sample_count
+FROM v_deadlocks
+WHERE server_id = $1 AND collection_time >= $2 AND collection_time < $3
+GROUP BY hour_of_day, day_of_week",
+
+            // Point-in-time metric (memory pressure %) — no restart exclusion needed
+            MetricNames.Memory => @"
+SELECT EXTRACT(HOUR FROM collection_time)::INT AS hour_of_day,
+       EXTRACT(DOW FROM collection_time)::INT AS day_of_week,
+       AVG(total_server_memory_mb::DOUBLE / NULLIF(target_server_memory_mb::DOUBLE, 0) * 100) AS mean_val,
+       STDDEV_SAMP(total_server_memory_mb::DOUBLE / NULLIF(target_server_memory_mb::DOUBLE, 0) * 100) AS stddev_val,
+       COUNT(*) AS sample_count
+FROM v_memory_stats
+WHERE server_id = $1 AND collection_time >= $2 AND collection_time < $3
+AND   target_server_memory_mb > 0
+GROUP BY hour_of_day, day_of_week",
+
+            // ── Chart-unit baselines (for UI bands — units match what the chart displays) ──
+
+            // Buffer pool MB (chart shows this, not pressure %)
+            MetricNames.MemoryBufferPoolMb => @"
+SELECT EXTRACT(HOUR FROM collection_time)::INT AS hour_of_day,
+       EXTRACT(DOW FROM collection_time)::INT AS day_of_week,
+       AVG(buffer_pool_mb::DOUBLE) AS mean_val,
+       STDDEV_SAMP(buffer_pool_mb::DOUBLE) AS stddev_val,
+       COUNT(*) AS sample_count
+FROM v_memory_stats
+WHERE server_id = $1 AND collection_time >= $2 AND collection_time < $3
+AND   buffer_pool_mb > 0
+GROUP BY hour_of_day, day_of_week",
+
+            // Wait ms per second (chart shows this, not total ms per collection)
+            MetricNames.WaitMsPerSec => @"
+WITH per_collection AS (
+    SELECT collection_time,
+           SUM(delta_wait_time_ms)::DOUBLE AS total_wait_ms,
+           date_diff('second', LAG(collection_time) OVER (ORDER BY collection_time), collection_time) AS interval_sec
+    FROM v_wait_stats
+    WHERE server_id = $1 AND collection_time >= $2 AND collection_time < $3
+    AND   delta_wait_time_ms >= 0
+    GROUP BY collection_time
+),
+with_rate AS (
+    SELECT collection_time,
+           CASE WHEN interval_sec > 0 THEN total_wait_ms / interval_sec ELSE 0 END AS ms_per_sec
+    FROM per_collection
+    WHERE interval_sec IS NOT NULL
+    QUALIFY NOT (ms_per_sec = 0
+        AND COALESCE(LAG(ms_per_sec) OVER (ORDER BY collection_time), 0) > 100)
+)
+SELECT EXTRACT(HOUR FROM collection_time)::INT AS hour_of_day,
+       EXTRACT(DOW FROM collection_time)::INT AS day_of_week,
+       AVG(ms_per_sec) AS mean_val,
+       STDDEV_SAMP(ms_per_sec) AS stddev_val,
+       COUNT(*) AS sample_count
+FROM with_rate
+GROUP BY hour_of_day, day_of_week",
+
+            // Blocking events per minute (chart shows event bars bucketed by minute)
+            MetricNames.BlockingPerMinute => @"
+WITH per_minute AS (
+    SELECT DATE_TRUNC('minute', collection_time) AS minute_bucket,
+           COUNT(*)::DOUBLE AS event_count
+    FROM v_blocked_process_reports
+    WHERE server_id = $1 AND collection_time >= $2 AND collection_time < $3
+    GROUP BY minute_bucket
+)
+SELECT EXTRACT(HOUR FROM minute_bucket)::INT AS hour_of_day,
+       EXTRACT(DOW FROM minute_bucket)::INT AS day_of_week,
+       AVG(event_count) AS mean_val,
+       STDDEV_SAMP(event_count) AS stddev_val,
+       COUNT(*) AS sample_count
+FROM per_minute
+GROUP BY hour_of_day, day_of_week",
+
+            _ => null
+        };
+    }
+
+    /// <summary>
+    /// Collapses multiple day-of-week buckets for the same hour into a single
+    /// hour-only bucket using pooled statistics.
+    /// </summary>
+    private static BaselineBucket CollapseToHourOnly(List<BaselineBucket> hourBuckets)
+    {
+        var totalSamples = hourBuckets.Sum(b => b.SampleCount);
+        if (totalSamples == 0)
+            return BaselineBucket.Empty;
+
+        // Weighted mean across all day-of-week buckets for this hour
+        var weightedMean = hourBuckets.Sum(b => b.Mean * b.SampleCount) / totalSamples;
+
+        // Pooled standard deviation
+        var pooledVariance = PoolVariance(hourBuckets, weightedMean);
+
+        return new BaselineBucket
+        {
+            HourOfDay = hourBuckets[0].HourOfDay,
+            DayOfWeek = -1, // Indicates hour-only
+            Mean = weightedMean,
+            StdDev = Math.Sqrt(pooledVariance),
+            SampleCount = totalSamples,
+            Tier = BaselineTier.HourOnly
+        };
+    }
+
+    /// <summary>
+    /// Collapses all buckets into a single flat baseline (equivalent to old 24h behavior).
+    /// </summary>
+    private static BaselineBucket CollapseToFlat(List<BaselineBucket> allBuckets)
+    {
+        var totalSamples = allBuckets.Sum(b => b.SampleCount);
+        if (totalSamples == 0)
+            return BaselineBucket.Empty;
+
+        var weightedMean = allBuckets.Sum(b => b.Mean * b.SampleCount) / totalSamples;
+        var pooledVariance = PoolVariance(allBuckets, weightedMean);
+
+        return new BaselineBucket
+        {
+            HourOfDay = -1,
+            DayOfWeek = -1,
+            Mean = weightedMean,
+            StdDev = Math.Sqrt(pooledVariance),
+            SampleCount = totalSamples,
+            Tier = BaselineTier.Flat
+        };
+    }
+
+    /// <summary>
+    /// Computes pooled variance from multiple buckets, accounting for both
+    /// within-bucket variance and between-bucket mean differences.
+    /// </summary>
+    private static double PoolVariance(List<BaselineBucket> buckets, double grandMean)
+    {
+        var totalSamples = buckets.Sum(b => b.SampleCount);
+        if (totalSamples <= 1) return 0;
+
+        double totalSumSq = 0;
+        foreach (var b in buckets)
+        {
+            if (b.SampleCount <= 0) continue;
+            // Within-bucket variance contribution
+            totalSumSq += (b.StdDev * b.StdDev) * (b.SampleCount - 1);
+            // Between-bucket mean difference contribution
+            totalSumSq += b.SampleCount * (b.Mean - grandMean) * (b.Mean - grandMean);
+        }
+
+        return totalSumSq / (totalSamples - 1);
+    }
+
+    private class CachedBaseline
+    {
+        public DateTime ComputedAt { get; init; }
+        public DateTime RealTime { get; init; }
+        public Dictionary<(int HourOfDay, int DayOfWeek), BaselineBucket>? Buckets { get; init; }
+    }
+}
+
+/// <summary>
+/// Represents the computed baseline statistics for a single time bucket.
+/// </summary>
+public class BaselineBucket
+{
+    public int HourOfDay { get; init; }
+    public int DayOfWeek { get; init; }
+    public double Mean { get; init; }
+    public double StdDev { get; init; }
+    public long SampleCount { get; init; }
+    public BaselineTier Tier { get; init; }
+
+    public static BaselineBucket Empty => new()
+    {
+        HourOfDay = -1, DayOfWeek = -1, Mean = 0, StdDev = 0,
+        SampleCount = 0, Tier = BaselineTier.Flat
+    };
+
+    /// <summary>
+    /// Returns the effective stddev with a proportional minimum floor to prevent
+    /// division-by-zero in z-score calculations. When both mean and stddev are 0
+    /// (zero activity), returns 0 — callers should skip scoring.
+    /// </summary>
+    public double EffectiveStdDev
+    {
+        get
+        {
+            if (Mean == 0 && StdDev <= 0) return 0; // Zero activity — skip scoring
+            return Math.Max(StdDev, Mean * 0.01);
+        }
+    }
+}
+
+public enum BaselineTier
+{
+    Full,     // hour + day-of-week (168 buckets)
+    HourOnly, // hour only (24 buckets)
+    Flat      // global mean/stddev
+}
+
+/// <summary>Metric name constants used as baseline cache keys.</summary>
+public static class MetricNames
+{
+    public const string Cpu = "cpu";
+    public const string BatchRequests = "batch_requests";
+    public const string WaitStats = "wait_stats";
+    public const string SessionCount = "session_count";
+    public const string QueryDuration = "query_duration";
+    public const string IoLatency = "io_latency";
+    public const string Blocking = "blocking";
+    public const string Deadlock = "deadlock";
+    public const string Memory = "memory";
+
+    // Chart-unit metrics (for UI bands — units match what the chart displays)
+    public const string MemoryBufferPoolMb = "memory_buffer_pool_mb";
+    public const string WaitMsPerSec = "wait_ms_per_sec";
+    public const string BlockingPerMinute = "blocking_per_minute";
+}
diff --git a/Lite/Analysis/FactScorer.cs b/Lite/Analysis/FactScorer.cs
index 1ec47f7..e42b4e9 100644
--- a/Lite/Analysis/FactScorer.cs
+++ b/Lite/Analysis/FactScorer.cs
@@ -308,8 +308,13 @@ private static double ScoreBadActorFact(Fact fact)
     /// </summary>
     private static double ScoreAnomalyFact(Fact fact)
     {
-        if (fact.Key.StartsWith("ANOMALY_CPU_SPIKE", StringComparison.OrdinalIgnoreCase) || fact.Key.StartsWith("ANOMALY_READ_LATENCY", StringComparison.OrdinalIgnoreCase)
-            || fact.Key.StartsWith("ANOMALY_WRITE_LATENCY", StringComparison.OrdinalIgnoreCase))
+        if (fact.Key.StartsWith("ANOMALY_CPU_SPIKE", StringComparison.OrdinalIgnoreCase)
+            || fact.Key.StartsWith("ANOMALY_READ_LATENCY", StringComparison.OrdinalIgnoreCase)
+            || fact.Key.StartsWith("ANOMALY_WRITE_LATENCY", StringComparison.OrdinalIgnoreCase)
+            || fact.Key.StartsWith("ANOMALY_BATCH_REQUESTS", StringComparison.OrdinalIgnoreCase)
+            || fact.Key.StartsWith("ANOMALY_SESSION_SPIKE", StringComparison.OrdinalIgnoreCase)
+            || fact.Key.StartsWith("ANOMALY_QUERY_DURATION", StringComparison.OrdinalIgnoreCase)
+            || fact.Key.StartsWith("ANOMALY_MEMORY_PRESSURE", StringComparison.OrdinalIgnoreCase))
         {
             // Deviation-based scoring: 2σ = 0.5, 4σ = 1.0
             var deviation = fact.Metadata.GetValueOrDefault("deviation_sigma");
diff --git a/Lite/Analysis/FindingStore.cs b/Lite/Analysis/FindingStore.cs
index 6724445..7611e51 100644
--- a/Lite/Analysis/FindingStore.cs
+++ b/Lite/Analysis/FindingStore.cs
@@ -60,7 +60,8 @@ public async Task<List<AnalysisFinding>> SaveFindingsAsync(
                 RootFactValue = story.RootFactValue,
                 LeafFactKey = story.LeafFactKey,
                 LeafFactValue = story.LeafFactValue,
-                FactCount = story.FactCount
+                FactCount = story.FactCount,
+                RootFactMetadata = story.RootFactMetadata
             };
 
             await InsertFindingAsync(finding);
diff --git a/Lite/Analysis/InferenceEngine.cs b/Lite/Analysis/InferenceEngine.cs
index 4ef4dc8..fdc7985 100644
--- a/Lite/Analysis/InferenceEngine.cs
+++ b/Lite/Analysis/InferenceEngine.cs
@@ -150,7 +150,8 @@ private static AnalysisStory BuildStory(List<string> path, Dictionary<string, Fa
             LeafFactKey = leafKey,
             LeafFactValue = leafFact?.Severity,
             FactCount = path.Count,
-            IsAbsolution = false
+            IsAbsolution = false,
+            RootFactMetadata = rootFact?.Metadata
         };
     }
 
diff --git a/Lite/Controls/CorrelatedTimelineLanesControl.xaml b/Lite/Controls/CorrelatedTimelineLanesControl.xaml
index ef273ba..f0f1871 100644
--- a/Lite/Controls/CorrelatedTimelineLanesControl.xaml
+++ b/Lite/Controls/CorrelatedTimelineLanesControl.xaml
@@ -18,15 +18,11 @@
             <Grid.ColumnDefinitions>
                 <ColumnDefinition Width="100"/>
                 <ColumnDefinition Width="*"/>
-                <ColumnDefinition Width="80"/>
             </Grid.ColumnDefinitions>
             <TextBlock Grid.Column="0" Text="CPU %" VerticalAlignment="Center"
                        FontSize="12" FontWeight="SemiBold"
                        Foreground="{DynamicResource ForegroundBrush}" Margin="4,0"/>
             <ScottPlot:WpfPlot Grid.Column="1" x:Name="CpuChart"/>
-            <TextBlock Grid.Column="2" x:Name="CpuValueLabel" VerticalAlignment="Center"
-                       HorizontalAlignment="Right" FontSize="11"
-                       Foreground="{DynamicResource ForegroundBrush}" Margin="4,0"/>
         </Grid>
 
         <!-- Lane 2: Wait Stats -->
@@ -34,15 +30,11 @@
             <Grid.ColumnDefinitions>
                 <ColumnDefinition Width="100"/>
                 <ColumnDefinition Width="*"/>
-                <ColumnDefinition Width="80"/>
             </Grid.ColumnDefinitions>
             <TextBlock Grid.Column="0" Text="Wait ms/sec" VerticalAlignment="Center"
                        FontSize="12" FontWeight="SemiBold"
                        Foreground="{DynamicResource ForegroundBrush}" Margin="4,0"/>
             <ScottPlot:WpfPlot Grid.Column="1" x:Name="WaitStatsChart"/>
-            <TextBlock Grid.Column="2" x:Name="WaitStatsValueLabel" VerticalAlignment="Center"
-                       HorizontalAlignment="Right" FontSize="11"
-                       Foreground="{DynamicResource ForegroundBrush}" Margin="4,0"/>
         </Grid>
 
         <!-- Lane 3: Blocking -->
@@ -50,7 +42,6 @@
             <Grid.ColumnDefinitions>
                 <ColumnDefinition Width="100"/>
                 <ColumnDefinition Width="*"/>
-                <ColumnDefinition Width="80"/>
             </Grid.ColumnDefinitions>
             <TextBlock Grid.Column="0" VerticalAlignment="Center"
                        FontSize="12" FontWeight="SemiBold"
@@ -60,25 +51,18 @@
                 <Run Text="Deadlocking"/>
             </TextBlock>
             <ScottPlot:WpfPlot Grid.Column="1" x:Name="BlockingChart"/>
-            <TextBlock Grid.Column="2" x:Name="BlockingValueLabel" VerticalAlignment="Center"
-                       HorizontalAlignment="Right" FontSize="11"
-                       Foreground="{DynamicResource ForegroundBrush}" Margin="4,0"/>
         </Grid>
 
-        <!-- Lane 4: Memory -->
+        <!-- Lane 4: Buffer Pool -->
         <Grid Grid.Row="3" Margin="0,2,0,2">
             <Grid.ColumnDefinitions>
                 <ColumnDefinition Width="100"/>
                 <ColumnDefinition Width="*"/>
-                <ColumnDefinition Width="80"/>
             </Grid.ColumnDefinitions>
-            <TextBlock Grid.Column="0" Text="Memory MB" VerticalAlignment="Center"
+            <TextBlock Grid.Column="0" Text="Buffer Pool MB" VerticalAlignment="Center"
                        FontSize="12" FontWeight="SemiBold"
                        Foreground="{DynamicResource ForegroundBrush}" Margin="4,0"/>
             <ScottPlot:WpfPlot Grid.Column="1" x:Name="MemoryChart"/>
-            <TextBlock Grid.Column="2" x:Name="MemoryValueLabel" VerticalAlignment="Center"
-                       HorizontalAlignment="Right" FontSize="11"
-                       Foreground="{DynamicResource ForegroundBrush}" Margin="4,0"/>
         </Grid>
 
         <!-- Lane 5: File I/O -->
@@ -86,15 +70,11 @@
             <Grid.ColumnDefinitions>
                 <ColumnDefinition Width="100"/>
                 <ColumnDefinition Width="*"/>
-                <ColumnDefinition Width="80"/>
             </Grid.ColumnDefinitions>
             <TextBlock Grid.Column="0" Text="I/O Latency" VerticalAlignment="Center"
                        FontSize="12" FontWeight="SemiBold"
                        Foreground="{DynamicResource ForegroundBrush}" Margin="4,0"/>
             <ScottPlot:WpfPlot Grid.Column="1" x:Name="FileIoChart"/>
-            <TextBlock Grid.Column="2" x:Name="FileIoValueLabel" VerticalAlignment="Center"
-                       HorizontalAlignment="Right" FontSize="11"
-                       Foreground="{DynamicResource ForegroundBrush}" Margin="4,0"/>
         </Grid>
     </Grid>
 </UserControl>
diff --git a/Lite/Controls/CorrelatedTimelineLanesControl.xaml.cs b/Lite/Controls/CorrelatedTimelineLanesControl.xaml.cs
index 04cfc77..d42a7bc 100644
--- a/Lite/Controls/CorrelatedTimelineLanesControl.xaml.cs
+++ b/Lite/Controls/CorrelatedTimelineLanesControl.xaml.cs
@@ -15,6 +15,7 @@
 using System.Threading.Tasks;
 using System.Windows;
 using System.Windows.Controls;
+using PerformanceMonitorLite.Analysis;
 using PerformanceMonitorLite.Helpers;
 using PerformanceMonitorLite.Services;
 
@@ -51,17 +52,18 @@ public void Initialize(LocalDataService dataService, int serverId)
         }
 
         _crosshairManager = new CorrelatedCrosshairManager();
-        _crosshairManager.AddLane(CpuChart, "CPU", "%", CpuValueLabel);
-        _crosshairManager.AddLane(WaitStatsChart, "Wait Stats", "ms/sec", WaitStatsValueLabel);
-        _crosshairManager.AddLane(BlockingChart, "Blocking", "events", BlockingValueLabel);
-        _crosshairManager.AddLane(MemoryChart, "Memory", "MB", MemoryValueLabel);
-        _crosshairManager.AddLane(FileIoChart, "I/O Latency", "ms", FileIoValueLabel);
+        _crosshairManager.AddLane(CpuChart, "CPU", "%");
+        _crosshairManager.AddLane(WaitStatsChart, "Wait Stats", "ms/sec");
+        _crosshairManager.AddLane(BlockingChart, "Blocking", "events");
+        _crosshairManager.AddLane(MemoryChart, "Buffer Pool", "MB");
+        _crosshairManager.AddLane(FileIoChart, "I/O Latency", "ms");
     }
 
     /// <summary>
     /// Refreshes all lane data for the given time range.
     /// </summary>
-    public async Task RefreshAsync(int hoursBack, DateTime? fromDate, DateTime? toDate)
+    public async Task RefreshAsync(int hoursBack, DateTime? fromDate, DateTime? toDate,
+        (DateTime From, DateTime To)? comparisonRange = null)
     {
         if (_dataService == null || _isRefreshing) return;
         _isRefreshing = true;
@@ -77,28 +79,43 @@ public async Task RefreshAsync(int hoursBack, DateTime? fromDate, DateTime? toDa
             var memoryTask = _dataService.GetMemoryTrendAsync(_serverId, hoursBack, fromDate, toDate);
             var fileIoTask = _dataService.GetFileIoLatencyTrendAsync(_serverId, hoursBack, fromDate, toDate);
 
+            // Fetch baselines for band rendering — chart-unit-matched metrics
+            var referenceTime = fromDate ?? DateTime.UtcNow.AddHours(-hoursBack);
+            var cpuBaselineTask = _dataService.GetBaselineForLaneAsync(_serverId, MetricNames.Cpu, referenceTime);
+            var waitBaselineTask = _dataService.GetBaselineForLaneAsync(_serverId, MetricNames.WaitMsPerSec, referenceTime);
+            var ioBaselineTask = _dataService.GetBaselineForLaneAsync(_serverId, MetricNames.IoLatency, referenceTime);
+            var blockingBaselineTask = _dataService.GetBaselineForLaneAsync(_serverId, MetricNames.BlockingPerMinute, referenceTime);
+
             try
             {
-                await Task.WhenAll(cpuTask, waitTask, blockingTask, deadlockTask, memoryTask, fileIoTask);
+                await Task.WhenAll(cpuTask, waitTask, blockingTask, deadlockTask, memoryTask, fileIoTask,
+                    cpuBaselineTask, waitBaselineTask, ioBaselineTask, blockingBaselineTask);
             }
             catch (Exception ex)
             {
                 AppLogger.Info("CorrelatedLanes", $"Data fetch failed: {ex.Message}");
             }
 
+            var cpuBaseline = cpuBaselineTask.IsCompletedSuccessfully ? cpuBaselineTask.Result : null;
+            var waitBaseline = waitBaselineTask.IsCompletedSuccessfully ? waitBaselineTask.Result : null;
+            var ioBaseline = ioBaselineTask.IsCompletedSuccessfully ? ioBaselineTask.Result : null;
+            var blockingBaseline = blockingBaselineTask.IsCompletedSuccessfully ? blockingBaselineTask.Result : null;
+
             var utcOffset = ServerTimeHelper.UtcOffsetMinutes;
 
+            // minAnomalyValue: absolute floor below which dots/arrows are suppressed even if outside band.
+            // Prevents "1% CPU above 0.5% baseline" false alarms on idle servers.
             if (cpuTask.IsCompletedSuccessfully)
                 UpdateLane(CpuChart, "CPU %",
                     cpuTask.Result.Select(d => (d.SampleTime.ToOADate(), (double)d.SqlServerCpu)).ToList(),
-                    "#4FC3F7", 0, 105);
+                    "#4FC3F7", 0, 105, cpuBaseline, minAnomalyValue: 10);
             else
                 ShowEmpty(CpuChart, "CPU %");
 
             if (waitTask.IsCompletedSuccessfully)
                 UpdateLane(WaitStatsChart, "Wait ms/sec",
                     waitTask.Result.Select(d => (d.CollectionTime.AddMinutes(utcOffset).ToOADate(), d.WaitTimeMsPerSecond)).ToList(),
-                    "#FFB74D");
+                    "#FFB74D", baseline: waitBaseline, minAnomalyValue: 100);
             else
                 ShowEmpty(WaitStatsChart, "Wait ms/sec");
 
@@ -109,11 +126,11 @@ public async Task RefreshAsync(int hoursBack, DateTime? fromDate, DateTime? toDa
                 var deadlockData = deadlockTask.IsCompletedSuccessfully
                     ? deadlockTask.Result.Select(d => (d.Time.AddMinutes(utcOffset).ToOADate(), (double)d.Count)).ToList()
                     : new List<(double, double)>();
-                UpdateBlockingLane(blockingData, deadlockData);
+                UpdateBlockingLane(blockingData, deadlockData, blockingBaseline);
             }
 
             if (memoryTask.IsCompletedSuccessfully)
-                UpdateLane(MemoryChart, "Memory MB",
+                UpdateLane(MemoryChart, "Buffer Pool MB",
                     memoryTask.Result.Select(d => (d.CollectionTime.AddMinutes(utcOffset).ToOADate(), d.BufferPoolMb)).ToList(),
                     "#CE93D8");
             else
@@ -126,11 +143,66 @@ public async Task RefreshAsync(int hoursBack, DateTime? fromDate, DateTime? toDa
                     .OrderBy(g => g.Key)
                     .Select(g => (g.Key.AddMinutes(utcOffset).ToOADate(), g.Average(x => x.AvgReadLatencyMs)))
                     .ToList();
-                UpdateLane(FileIoChart, "I/O ms", ioGrouped, "#81C784");
+                UpdateLane(FileIoChart, "I/O ms", ioGrouped, "#81C784", baseline: ioBaseline, minAnomalyValue: 2);
             }
             else
                 ShowEmpty(FileIoChart, "I/O ms");
 
+            // Comparison overlay — fetch reference period data and render as ghost lines
+            if (comparisonRange.HasValue)
+            {
+                var refFrom = comparisonRange.Value.From;
+                var refTo = comparisonRange.Value.To;
+                // Time shift: offset to align reference data with current chart X axis
+                var timeShift = (fromDate ?? DateTime.UtcNow.AddHours(-hoursBack)) - refFrom;
+
+                var refCpuTask = _dataService.GetCpuUtilizationAsync(_serverId, 0, refFrom, refTo);
+                var refWaitTask = _dataService.GetTotalWaitTrendAsync(_serverId, 0, refFrom, refTo);
+                var refBlockingTask = _dataService.GetBlockingTrendAsync(_serverId, 0, refFrom, refTo);
+                var refMemoryTask = _dataService.GetMemoryTrendAsync(_serverId, 0, refFrom, refTo);
+                var refIoTask = _dataService.GetFileIoLatencyTrendAsync(_serverId, 0, refFrom, refTo);
+
+                try { await Task.WhenAll(refCpuTask, refWaitTask, refBlockingTask, refMemoryTask, refIoTask); }
+                catch (Exception ex) { AppLogger.Info("CorrelatedLanes", $"Comparison fetch failed: {ex.Message}"); }
+
+                AppLogger.Info("CorrelatedLanes",
+                    $"Comparison: refFrom={refFrom:o}, refTo={refTo:o}, shift={timeShift.TotalHours:F1}h, " +
+                    $"cpuRows={refCpuTask.Result?.Count ?? 0}, waitRows={refWaitTask.Result?.Count ?? 0}");
+
+                if (refCpuTask.IsCompletedSuccessfully)
+                    AddGhostLine(CpuChart, refCpuTask.Result
+                        .Select(d => (d.SampleTime.Add(timeShift).ToOADate(), (double)d.SqlServerCpu)).ToList(), "#4FC3F7");
+
+                if (refWaitTask.IsCompletedSuccessfully)
+                    AddGhostLine(WaitStatsChart, refWaitTask.Result
+                        .Select(d => (d.CollectionTime.AddMinutes(utcOffset).Add(timeShift).ToOADate(), d.WaitTimeMsPerSecond)).ToList(), "#FFB74D");
+
+                if (refBlockingTask.IsCompletedSuccessfully)
+                {
+                    var refBlocking = refBlockingTask.Result
+                        .Select(d => (d.Time.AddMinutes(utcOffset).Add(timeShift).ToOADate(), (double)d.Count)).ToList();
+                    if (refBlocking.Count > 0)
+                        AddGhostLine(BlockingChart, refBlocking, "#E57373");
+                }
+
+                if (refMemoryTask.IsCompletedSuccessfully)
+                    AddGhostLine(MemoryChart, refMemoryTask.Result
+                        .Select(d => (d.CollectionTime.AddMinutes(utcOffset).Add(timeShift).ToOADate(), d.BufferPoolMb)).ToList(), "#CE93D8");
+
+                if (refIoTask.IsCompletedSuccessfully)
+                {
+                    var refIo = refIoTask.Result
+                        .GroupBy(d => d.CollectionTime)
+                        .OrderBy(g => g.Key)
+                        .Select(g => (g.Key.AddMinutes(utcOffset).Add(timeShift).ToOADate(), g.Average(x => x.AvgReadLatencyMs)))
+                        .ToList();
+                    AddGhostLine(FileIoChart, refIo, "#81C784");
+                }
+
+                // Register reference data with crosshair manager for tooltip
+                _crosshairManager?.SetComparisonLabel(ComparisonLabel(comparisonRange.Value, fromDate, hoursBack));
+            }
+
             _crosshairManager?.ReattachVLines();
             SyncXAxes(hoursBack, fromDate, toDate, utcOffset);
         }
@@ -141,7 +213,7 @@ public async Task RefreshAsync(int hoursBack, DateTime? fromDate, DateTime? toDa
     }
 
     private void UpdateBlockingLane(List<(double Time, double Value)> blockingData,
-        List<(double Time, double Value)> deadlockData)
+        List<(double Time, double Value)> deadlockData, BaselineBucket? baseline = null)
     {
         ClearChart(BlockingChart);
         ApplyTheme(BlockingChart);
@@ -197,6 +269,24 @@ private void UpdateBlockingLane(List<(double Time, double Value)> blockingData,
             maxCount = Math.Max(maxCount, deadlockData.Max(d => d.Value));
         }
 
+        // Baseline band for blocking
+        if (baseline != null && baseline.SampleCount > 0 && baseline.EffectiveStdDev > 0)
+        {
+            var upper = baseline.Mean + 2 * baseline.EffectiveStdDev;
+            var lower = Math.Max(0, baseline.Mean - 2 * baseline.EffectiveStdDev);
+
+            _crosshairManager?.SetLaneBaseline(BlockingChart, lower, upper);
+
+            var band = BlockingChart.Plot.Add.HorizontalSpan(lower, upper);
+            band.FillStyle.Color = ScottPlot.Color.FromHex("#E57373").WithAlpha(25);
+            band.LineStyle.Width = 0;
+
+            var meanLine = BlockingChart.Plot.Add.HorizontalLine(baseline.Mean);
+            meanLine.Color = ScottPlot.Color.FromHex("#E57373").WithAlpha(60);
+            meanLine.LinePattern = ScottPlot.LinePattern.Dashed;
+            meanLine.LineWidth = 1;
+        }
+
         BlockingChart.Plot.Axes.DateTimeTicksBottom();
         BlockingChart.Plot.Axes.Bottom.TickLabelStyle.IsVisible = false;
         ReapplyAxisColors(BlockingChart);
@@ -212,7 +302,8 @@ private void UpdateBlockingLane(List<(double Time, double Value)> blockingData,
 
     private void UpdateLane(ScottPlot.WPF.WpfPlot chart, string title,
         List<(double Time, double Value)> data, string colorHex,
-        double? yMin = null, double? yMax = null)
+        double? yMin = null, double? yMax = null, BaselineBucket? baseline = null,
+        double minAnomalyValue = 0)
     {
         ClearChart(chart);
         ApplyTheme(chart);
@@ -226,6 +317,43 @@ private void UpdateLane(ScottPlot.WPF.WpfPlot chart, string title,
         var times = data.Select(d => d.Time).ToArray();
         var values = data.Select(d => d.Value).ToArray();
 
+        // Render baseline band FIRST (behind the data line)
+        if (baseline != null && baseline.SampleCount > 0 && baseline.EffectiveStdDev > 0)
+        {
+            var upper = baseline.Mean + 2 * baseline.EffectiveStdDev;
+            var lower = Math.Max(0, baseline.Mean - 2 * baseline.EffectiveStdDev);
+
+            _crosshairManager?.SetLaneBaseline(chart, lower, upper, minAnomalyValue);
+
+            var band = chart.Plot.Add.HorizontalSpan(lower, upper);
+            band.FillStyle.Color = ScottPlot.Color.FromHex(colorHex).WithAlpha(25);
+            band.LineStyle.Width = 0;
+
+            var meanLine = chart.Plot.Add.HorizontalLine(baseline.Mean);
+            meanLine.Color = ScottPlot.Color.FromHex(colorHex).WithAlpha(60);
+            meanLine.LinePattern = ScottPlot.LinePattern.Dashed;
+            meanLine.LineWidth = 1;
+
+            // Highlight anomalous points (outside ± 2σ band AND above absolute minimum)
+            var anomalyIndices = new List<int>();
+            for (int i = 0; i < values.Length; i++)
+            {
+                if ((values[i] > upper && values[i] >= minAnomalyValue) || values[i] < lower)
+                    anomalyIndices.Add(i);
+            }
+
+            if (anomalyIndices.Count > 0)
+            {
+                var anomalyTimes = anomalyIndices.Select(i => times[i]).ToArray();
+                var anomalyValues = anomalyIndices.Select(i => values[i]).ToArray();
+                var anomalyScatter = chart.Plot.Add.Scatter(anomalyTimes, anomalyValues);
+                anomalyScatter.Color = ScottPlot.Color.FromHex("#FF5252");
+                anomalyScatter.MarkerSize = 6;
+                anomalyScatter.MarkerShape = ScottPlot.MarkerShape.FilledCircle;
+                anomalyScatter.LineWidth = 0;
+            }
+        }
+
         var scatter = chart.Plot.Add.Scatter(times, values);
         scatter.Color = ScottPlot.Color.FromHex(colorHex);
         scatter.MarkerSize = 0;
@@ -289,6 +417,38 @@ private void SyncXAxes(int hoursBack, DateTime? fromDate, DateTime? toDate, doub
         }
     }
 
+    /// <summary>
+    /// Renders a semi-transparent dashed ghost line for comparison overlay.
+    /// </summary>
+    private static void AddGhostLine(ScottPlot.WPF.WpfPlot chart,
+        List<(double Time, double Value)> data, string colorHex)
+    {
+        if (data.Count == 0) return;
+
+        var times = data.Select(d => d.Time).ToArray();
+        var values = data.Select(d => d.Value).ToArray();
+
+        var scatter = chart.Plot.Add.Scatter(times, values);
+        // White-ish ghost line — distinct from the primary colored line
+        scatter.Color = ScottPlot.Colors.White.WithAlpha(140);
+        scatter.MarkerSize = 0;
+        scatter.LineWidth = 1.5f;
+        scatter.LinePattern = ScottPlot.LinePattern.Dashed;
+
+        chart.Refresh();
+    }
+
+    private static string ComparisonLabel((DateTime From, DateTime To) range,
+        DateTime? fromDate, int hoursBack)
+    {
+        var currentStart = fromDate ?? DateTime.UtcNow.AddHours(-hoursBack);
+        var daysBack = (currentStart - range.From).TotalDays;
+
+        if (Math.Abs(daysBack - 1) < 0.5) return "yesterday";
+        if (Math.Abs(daysBack - 7) < 0.5) return "last week";
+        return $"{daysBack:N0}d ago";
+    }
+
     private static void ClearChart(ScottPlot.WPF.WpfPlot chart)
     {
         chart.Reset();
diff --git a/Lite/Controls/ServerTab.xaml b/Lite/Controls/ServerTab.xaml
index a845687..6202f64 100644
--- a/Lite/Controls/ServerTab.xaml
+++ b/Lite/Controls/ServerTab.xaml
@@ -103,6 +103,16 @@
                               SelectionChanged="CustomTimeCombo_Changed" ToolTip="Minute"/>
                     <Button Content="Apply to All" Click="ApplyTimeRangeToAll_Click" Padding="8,4" Margin="0,0,8,0"
                             ToolTip="Apply this time range to all open server tabs"/>
+                    <TextBlock Text="Compare:" VerticalAlignment="Center" Margin="0,0,4,0"
+                               Foreground="{DynamicResource ForegroundBrush}"/>
+                    <ComboBox x:Name="CompareToCombo" SelectedIndex="0" Width="130" Margin="0,0,8,0"
+                              SelectionChanged="CompareToCombo_SelectionChanged"
+                              ToolTip="Overlay a reference period on the Overview charts">
+                        <ComboBoxItem Content="None"/>
+                        <ComboBoxItem Content="Yesterday"/>
+                        <ComboBoxItem Content="Last week"/>
+                        <ComboBoxItem Content="Same day last week"/>
+                    </ComboBox>
                     <Button x:Name="RefreshDataButton" Content="Refresh" Click="RefreshDataButton_Click" Padding="12,4"/>
                     <Separator Style="{StaticResource {x:Static ToolBar.SeparatorStyleKey}}" Margin="8,2"/>
                     <CheckBox x:Name="AutoRefreshCheckBox" Content="Auto-refresh" VerticalAlignment="Center" Margin="0,0,4,0"
diff --git a/Lite/Controls/ServerTab.xaml.cs b/Lite/Controls/ServerTab.xaml.cs
index 19cc0c8..a3c8a9d 100644
--- a/Lite/Controls/ServerTab.xaml.cs
+++ b/Lite/Controls/ServerTab.xaml.cs
@@ -618,6 +618,60 @@ private async void TimeRangeCombo_SelectionChanged(object sender, SelectionChang
         }
     }
 
+    private async void CompareToCombo_SelectionChanged(object sender, SelectionChangedEventArgs e)
+    {
+        if (!IsLoaded || _isRefreshing) return;
+
+        var hoursBack = GetHoursBack();
+        DateTime? fromDate = null, toDate = null;
+        if (IsCustomRange)
+        {
+            var fromLocal = GetDateTimeFromPickers(FromDatePicker!, FromHourCombo, FromMinuteCombo);
+            var toLocal = GetDateTimeFromPickers(ToDatePicker!, ToHourCombo, ToMinuteCombo);
+            if (fromLocal.HasValue && toLocal.HasValue)
+            {
+                fromDate = ServerTimeHelper.DisplayTimeToServerTime(fromLocal.Value, ServerTimeHelper.CurrentDisplayMode);
+                toDate = ServerTimeHelper.DisplayTimeToServerTime(toLocal.Value, ServerTimeHelper.CurrentDisplayMode);
+            }
+        }
+
+        await RefreshOverviewAsync(hoursBack, fromDate, toDate);
+    }
+
+    /// <summary>
+    /// Computes the reference time range for the comparison overlay based on the
+    /// current Compare dropdown selection and the active time range.
+    /// Returns null if "None" is selected.
+    /// </summary>
+    private (DateTime From, DateTime To)? GetComparisonRange()
+    {
+        if (CompareToCombo == null || CompareToCombo.SelectedIndex <= 0) return null;
+
+        var hoursBack = GetHoursBack();
+        DateTime? fromDate = null, toDate = null;
+        if (IsCustomRange)
+        {
+            var fromLocal = GetDateTimeFromPickers(FromDatePicker!, FromHourCombo, FromMinuteCombo);
+            var toLocal = GetDateTimeFromPickers(ToDatePicker!, ToHourCombo, ToMinuteCombo);
+            if (fromLocal.HasValue && toLocal.HasValue)
+            {
+                fromDate = ServerTimeHelper.DisplayTimeToServerTime(fromLocal.Value, ServerTimeHelper.CurrentDisplayMode);
+                toDate = ServerTimeHelper.DisplayTimeToServerTime(toLocal.Value, ServerTimeHelper.CurrentDisplayMode);
+            }
+        }
+
+        var currentEnd = toDate ?? DateTime.UtcNow;
+        var currentStart = fromDate ?? currentEnd.AddHours(-hoursBack);
+
+        return CompareToCombo.SelectedIndex switch
+        {
+            1 => (currentStart.AddDays(-1), currentEnd.AddDays(-1)),   // Yesterday
+            2 => (currentStart.AddDays(-7), currentEnd.AddDays(-7)),   // Last week
+            3 => (currentStart.AddDays(-7), currentEnd.AddDays(-7)),   // Same day last week
+            _ => null
+        };
+    }
+
     private async void CustomDateRange_Changed(object sender, SelectionChangedEventArgs e)
     {
         if (!IsLoaded || _isRefreshing) return;
@@ -1098,7 +1152,8 @@ private async System.Threading.Tasks.Task RefreshOverviewAsync(int hoursBack, Da
     {
         try
         {
-            await CorrelatedLanes.RefreshAsync(hoursBack, fromDate, toDate);
+            var comparison = GetComparisonRange();
+            await CorrelatedLanes.RefreshAsync(hoursBack, fromDate, toDate, comparison);
         }
         catch (Exception ex)
         {
diff --git a/Lite/Helpers/CorrelatedCrosshairManager.cs b/Lite/Helpers/CorrelatedCrosshairManager.cs
index da7267c..1cb52a1 100644
--- a/Lite/Helpers/CorrelatedCrosshairManager.cs
+++ b/Lite/Helpers/CorrelatedCrosshairManager.cs
@@ -15,6 +15,7 @@
 using System.Windows;
 using System.Windows.Controls;
 using System.Windows.Controls.Primitives;
+using System.Windows.Documents;
 using System.Windows.Input;
 using System.Windows.Media;
 using PerformanceMonitorLite.Services;
@@ -62,14 +63,13 @@ public CorrelatedCrosshairManager()
     /// <summary>
     /// Registers a chart lane for crosshair synchronization.
     /// </summary>
-    public void AddLane(ScottPlot.WPF.WpfPlot chart, string label, string unit, TextBlock valueLabel)
+    public void AddLane(ScottPlot.WPF.WpfPlot chart, string label, string unit)
     {
         var lane = new LaneInfo
         {
             Chart = chart,
             Label = label,
-            Unit = unit,
-            ValueLabel = valueLabel
+            Unit = unit
         };
 
         chart.MouseMove += (s, e) => OnMouseMove(lane, e);
@@ -78,6 +78,20 @@ public void AddLane(ScottPlot.WPF.WpfPlot chart, string label, string unit, Text
         _lanes.Add(lane);
     }
 
+    /// <summary>
+    /// Sets the expected baseline range for a lane (upper/lower bounds).
+    /// Values outside this range get ▲/▼ indicators in the tooltip.
+    /// </summary>
+    public void SetLaneBaseline(ScottPlot.WPF.WpfPlot chart, double lower, double upper,
+        double minAnomalyValue = 0)
+    {
+        var lane = _lanes.Find(l => l.Chart == chart);
+        if (lane == null) return;
+        lane.BaselineLower = lower;
+        lane.BaselineUpper = upper;
+        lane.MinAnomalyValue = minAnomalyValue;
+    }
+
     /// <summary>
     /// Sets a single data series for a lane (most lanes have one series).
     /// </summary>
@@ -117,6 +131,16 @@ public void AddLaneSeries(ScottPlot.WPF.WpfPlot chart, string name, string unit,
         });
     }
 
+    /// <summary>
+    /// Sets the label shown in the tooltip for comparison data (e.g., "yesterday").
+    /// </summary>
+    public void SetComparisonLabel(string label)
+    {
+        _comparisonLabel = label;
+    }
+
+    private string? _comparisonLabel;
+
     /// <summary>
     /// Clears data and VLines. Call before re-populating charts.
     /// </summary>
@@ -124,10 +148,14 @@ public void PrepareForRefresh()
     {
         _isRefreshing = true;
         _tooltip.IsOpen = false;
+        _comparisonLabel = null;
         foreach (var lane in _lanes)
         {
             lane.Series.Clear();
             lane.VLine = null;
+            lane.BaselineUpper = null;
+            lane.BaselineLower = null;
+            lane.MinAnomalyValue = 0;
         }
     }
 
@@ -165,10 +193,14 @@ private void OnMouseMove(LaneInfo sourceLane, MouseEventArgs e)
         var mouseCoords = sourceLane.Chart.Plot.GetCoordinates(pixel);
         double xValue = mouseCoords.X;
 
-        var tooltipLines = new List<string>();
+        _tooltipText.Inlines.Clear();
         var time = DateTime.FromOADate(xValue);
         var displayTime = ServerTimeHelper.ConvertForDisplay(time, ServerTimeHelper.CurrentDisplayMode);
-        tooltipLines.Add(displayTime.ToString("yyyy-MM-dd HH:mm:ss"));
+        _tooltipText.Inlines.Add(new Run(displayTime.ToString("yyyy-MM-dd HH:mm:ss")));
+        if (_comparisonLabel != null)
+            _tooltipText.Inlines.Add(new Run($"  (dashed = {_comparisonLabel})") { Foreground = DimBrush });
+
+        var defaultBrush = new SolidColorBrush(Color.FromRgb(0xE0, 0xE0, 0xE0));
 
         foreach (var lane in _lanes)
         {
@@ -179,51 +211,47 @@ private void OnMouseMove(LaneInfo sourceLane, MouseEventArgs e)
 
             if (lane.Series.Count == 1)
             {
-                // Single series — use lane label and unit
                 var series = lane.Series[0];
                 double? value = FindNearestValue(series, xValue);
 
                 if (value.HasValue)
                 {
-                    lane.ValueLabel.Text = $"{value.Value:N1} {lane.Unit}";
-                    tooltipLines.Add($"{lane.Label}: {value.Value:N1} {lane.Unit}");
+                    var indicator = GetBaselineIndicator(lane, value.Value);
+
+                    // Tooltip: value + arrow + "30d avg" context
+                    _tooltipText.Inlines.Add(new Run($"\n{lane.Label}: {value.Value:N1} {lane.Unit}") { Foreground = defaultBrush });
+                    if (indicator != null)
+                    {
+                        _tooltipText.Inlines.Add(new Run($" {indicator.Value.Symbol}") { Foreground = indicator.Value.Brush });
+                        var ctx = FormatBaselineContext(lane);
+                        if (ctx != null)
+                            _tooltipText.Inlines.Add(new Run($" ({ctx})") { Foreground = DimBrush });
+                    }
                 }
                 else
                 {
-                    lane.ValueLabel.Text = "";
-                    tooltipLines.Add($"{lane.Label}: —");
+                    _tooltipText.Inlines.Add(new Run($"\n{lane.Label}: —") { Foreground = defaultBrush });
                 }
             }
             else if (lane.Series.Count > 1)
             {
-                // Multiple series — show each with its own name
-                var valueParts = new List<string>();
                 foreach (var series in lane.Series)
                 {
                     double? value = FindNearestValue(series, xValue);
                     string unit = series.Unit ?? lane.Unit;
                     if (value.HasValue)
-                    {
-                        valueParts.Add($"{value.Value:N0}");
-                        tooltipLines.Add($"{series.Name}: {value.Value:N0} {unit}");
-                    }
+                        _tooltipText.Inlines.Add(new Run($"\n{series.Name}: {value.Value:N0} {unit}") { Foreground = defaultBrush });
                     else
-                    {
-                        tooltipLines.Add($"{series.Name}: —");
-                    }
+                        _tooltipText.Inlines.Add(new Run($"\n{series.Name}: —") { Foreground = defaultBrush });
                 }
-                lane.ValueLabel.Text = valueParts.Count > 0 ? string.Join("/", valueParts) : "";
             }
             else
             {
-                lane.ValueLabel.Text = "";
-                tooltipLines.Add($"{lane.Label}: —");
+                _tooltipText.Inlines.Add(new Run($"\n{lane.Label}: —") { Foreground = defaultBrush });
             }
 
             lane.Chart.Refresh();
         }
-
-        _tooltipText.Text = string.Join("\n", tooltipLines);
         _tooltip.PlacementTarget = sourceLane.Chart;
         _tooltip.HorizontalOffset = pos.X + 15;
         _tooltip.VerticalOffset = pos.Y + 15;
@@ -265,6 +293,32 @@ private void OnMouseMove(LaneInfo sourceLane, MouseEventArgs e)
         return val;
     }
 
+    private static readonly SolidColorBrush RedBrush = new(Color.FromRgb(0xFF, 0x52, 0x52));
+    private static readonly SolidColorBrush GreenBrush = new(Color.FromRgb(0x69, 0xF0, 0x69));
+    private static readonly SolidColorBrush DimBrush = new(Color.FromRgb(0x90, 0x96, 0xA0));
+
+    private record struct BaselineIndicator(string Symbol, SolidColorBrush Brush);
+
+    private static string? FormatBaselineContext(LaneInfo lane)
+    {
+        if (lane.BaselineUpper == null || lane.BaselineLower == null) return null;
+        var mean = (lane.BaselineUpper.Value + lane.BaselineLower.Value) / 2.0;
+        var formatted = mean >= 1000 ? $"{mean:N0}" : mean >= 10 ? $"{mean:N1}" : $"{mean:N2}";
+        return $"30d avg: ~{formatted}";
+    }
+
+    private static BaselineIndicator? GetBaselineIndicator(LaneInfo lane, double value)
+    {
+        if (lane.BaselineUpper == null || lane.BaselineLower == null) return null;
+        // ▲ requires both: outside band AND above absolute minimum (prevents 1% CPU false alarms)
+        if (value > lane.BaselineUpper.Value && value >= lane.MinAnomalyValue)
+            return new BaselineIndicator("▲", RedBrush);
+        // ▼ always shown when below band (drops are always interesting — tuning feedback)
+        if (value < lane.BaselineLower.Value)
+            return new BaselineIndicator("▼", GreenBrush);
+        return null;
+    }
+
     private void OnMouseLeave()
     {
         _tooltip.IsOpen = false;
@@ -272,7 +326,6 @@ private void OnMouseLeave()
         {
             if (lane.VLine != null)
                 lane.VLine.IsVisible = false;
-            lane.ValueLabel.Text = "";
             lane.Chart.Refresh();
         }
     }
@@ -303,7 +356,9 @@ private class LaneInfo
         public string Label { get; set; } = "";
         public string Unit { get; set; } = "";
         public ScottPlot.Plottables.VerticalLine? VLine { get; set; }
-        public TextBlock ValueLabel { get; set; } = null!;
         public List<DataSeries> Series { get; set; } = new();
+        public double? BaselineUpper { get; set; }
+        public double? BaselineLower { get; set; }
+        public double MinAnomalyValue { get; set; }
     }
 }
diff --git a/Lite/Mcp/McpAnalysisTools.cs b/Lite/Mcp/McpAnalysisTools.cs
index 9544b46..c29dca0 100644
--- a/Lite/Mcp/McpAnalysisTools.cs
+++ b/Lite/Mcp/McpAnalysisTools.cs
@@ -9,7 +9,7 @@ namespace PerformanceMonitorLite.Mcp;
 [McpServerToolType]
 public sealed class McpAnalysisTools
 {
-    [McpServerTool(Name = "analyze_server"), Description("Runs the diagnostic inference engine against a server's collected data. Scores wait stats, blocking, memory, config, and other facts, then traverses a relationship graph to build evidence-backed stories about what's wrong and why. Returns structured findings with severity scores, evidence chains, and recommended next tools to call. The AI client should interpret the findings and provide recommendations — the engine provides the reasoning, not the prose.")]
+    [McpServerTool(Name = "analyze_server"), Description("Runs the diagnostic inference engine against a server's collected data. Scores wait stats, blocking, memory, config, and other facts, then traverses a relationship graph to build evidence-backed stories about what's wrong and why. Anomaly detection compares the analysis window against 30-day time-bucketed baselines (hour-of-day x day-of-week) to identify deviations that are unusual for this specific time slot, not just unusual overall. Returns structured findings with severity scores, evidence chains, baseline context for anomalies, and recommended next tools to call.")]
     public static async Task<string> AnalyzeServer(
         AnalysisService analysisService,
         ServerManager serverManager,
@@ -162,13 +162,13 @@ public static async Task<string> GetAnalysisFacts(
         }
     }
 
-    [McpServerTool(Name = "compare_analysis"), Description("Compares two time periods by running the inference engine's fact collection and scoring on each, then showing what changed. Use this to compare peak vs off-peak, before vs after a change, or yesterday vs today. Returns facts from both periods side-by-side with severity deltas.")]
+    [McpServerTool(Name = "compare_analysis"), Description("Compares two time periods by running the inference engine's fact collection and scoring on each, then showing what changed. Use this to compare peak vs off-peak, before vs after a change, or yesterday vs today. Returns facts from both periods side-by-side with severity deltas. Note: for routine anomaly detection, use analyze_server instead — it automatically compares against 30-day time-bucketed baselines (hour-of-day x day-of-week). This tool is for explicit window-to-window comparisons.")]
     public static async Task<string> CompareAnalysis(
         AnalysisService analysisService,
         ServerManager serverManager,
         [Description("Server name or display name.")] string? server_name = null,
         [Description("Hours back for the comparison (recent) period. Default 4.")] int hours_back = 4,
-        [Description("Hours back for the baseline period start, measured from now. Default 28 (yesterday same time, assuming 4-hour windows). The baseline period will be the same duration as the comparison period.")] int baseline_hours_back = 28)
+        [Description("Hours back for the baseline period start, measured from now. Default 28 (yesterday same time). The baseline period will be the same duration as the comparison period.")] int baseline_hours_back = 28)
     {
         var resolved = ServerResolver.Resolve(serverManager, server_name);
         if (resolved == null)
@@ -833,6 +833,48 @@ public static List<object> GetForStoryPath(string storyPath)
 
         return result;
     }
+
+    private static readonly string[] DayNames = ["Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"];
+
+    /// <summary>
+    /// Formats baseline context from anomaly fact metadata into a human-readable object
+    /// for MCP output. Example: "4.1σ above baseline for Tue 14:00, mean 68.2"
+    /// </summary>
+    private static object? FormatBaselineContext(Dictionary<string, double> metadata)
+    {
+        var result = new Dictionary<string, object>();
+
+        if (metadata.TryGetValue("deviation_sigma", out var sigma))
+            result["deviation"] = $"{sigma:F1}σ";
+
+        if (metadata.TryGetValue("ratio", out var ratio))
+            result["ratio"] = $"{ratio:F1}x";
+
+        if (metadata.TryGetValue("baseline_mean", out var mean))
+            result["baseline_mean"] = Math.Round(mean, 2);
+
+        if (metadata.TryGetValue("baseline_mean_ms", out var meanMs))
+            result["baseline_mean"] = Math.Round(meanMs, 2);
+
+        if (metadata.TryGetValue("baseline_stddev", out var stddev))
+            result["baseline_stddev"] = Math.Round(stddev, 2);
+
+        if (metadata.TryGetValue("baseline_hour", out var hour) &&
+            metadata.TryGetValue("baseline_dow", out var dow))
+        {
+            var dowIdx = (int)dow;
+            var dayName = dowIdx >= 0 && dowIdx < DayNames.Length ? DayNames[dowIdx] : "?";
+            result["bucket"] = hour >= 0 ? $"{dayName} {(int)hour:00}:00" : "flat";
+        }
+
+        if (metadata.TryGetValue("baseline_tier", out var tier))
+            result["tier"] = tier switch { 0 => "full", 1 => "hour_only", _ => "flat" };
+
+        if (metadata.TryGetValue("baseline_samples", out var samples))
+            result["baseline_samples"] = (int)samples;
+
+        return result.Count > 0 ? result : null;
+    }
 }
 
 internal record ToolRecommendation(
diff --git a/Lite/Services/LocalDataService.Baselines.cs b/Lite/Services/LocalDataService.Baselines.cs
new file mode 100644
index 0000000..93fd344
--- /dev/null
+++ b/Lite/Services/LocalDataService.Baselines.cs
@@ -0,0 +1,32 @@
+/*
+ * 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 PerformanceMonitorLite.Analysis;
+
+namespace PerformanceMonitorLite.Services;
+
+public partial class LocalDataService
+{
+    private BaselineProvider? _baselineProvider;
+
+    private BaselineProvider GetBaselineProvider()
+    {
+        return _baselineProvider ??= new BaselineProvider(_duckDb);
+    }
+
+    /// <summary>
+    /// Gets the baseline (mean ± stddev) for a metric at a specific time.
+    /// Returns null if no baseline data is available.
+    /// </summary>
+    public async Task<BaselineBucket> GetBaselineForLaneAsync(
+        int serverId, string metricName, DateTime referenceTime)
+    {
+        var baseline = await GetBaselineProvider().GetBaselineAsync(serverId, metricName, referenceTime);
+        return baseline.SampleCount > 0 ? baseline : BaselineBucket.Empty;
+    }
+}

From e2dfcdb06c7a00b48e3f1cf53d94f51e52ca172a Mon Sep 17 00:00:00 2001
From: Erik Darling <2136037+erikdarlingdata@users.noreply.github.com>
Date: Mon, 6 Apr 2026 23:32:00 -0400
Subject: [PATCH 18/30] Port baseline engine and anomaly detection to Dashboard
 (Phases 5-8)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

- Add SqlServerBaselineProvider: time-bucketed baselines from SQL Server
  collect.* tables with @@DATEFIRST normalization, CTE restart exclusion,
  bucket collapse hierarchy (full → hour-only → flat), 1-hour TTL cache
- Upgrade SqlServerAnomalyDetector: inject baseline provider, upgrade 4
  existing detectors to time-bucketed baselines, add 3 new detectors
  (batch requests, sessions, query duration)
- Update FactScorer: score ANOMALY_BATCH_REQUESTS, ANOMALY_SESSION_SPIKE,
  ANOMALY_QUERY_DURATION (deviation-based)
- Port correlated timeline lanes UI: baseline bands, anomaly dots,
  Compare dropdown with ghost line overlay, remove right-side value labels,
  rename Memory MB → Buffer Pool MB, fix auto-refresh flicker
- Port crosshair manager: ▲/▼ baseline indicators, comparison label,
  event-based spike detection for blocking/deadlocks
- Fix pre-existing CPU tooltip bug: data returned DESC, binary search
  assumed ASC — added OrderBy
- Fix event-based baseline: use wait_stats spine for zero-inclusive
  baselines, handle zero-mean EffectiveStdDev for event metrics
- Cross-server validated on sql2016–sql2025, all queries < 250ms

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
---
 Dashboard/Analysis/AnalysisService.cs         |    4 +-
 Dashboard/Analysis/FactScorer.cs              |    9 +-
 .../Analysis/SqlServerAnomalyDetector.cs      | 1251 ++++++++++-------
 .../Analysis/SqlServerBaselineProvider.cs     |  525 +++++++
 .../CorrelatedTimelineLanesControl.xaml       |   24 +-
 .../CorrelatedTimelineLanesControl.xaml.cs    |  244 +++-
 .../Controls/ResourceMetricsContent.xaml      |   16 +-
 .../Controls/ResourceMetricsContent.xaml.cs   |   36 +-
 .../Helpers/CorrelatedCrosshairManager.cs     |  115 +-
 Dashboard/ServerTab.xaml.cs                   |    3 +-
 .../CorrelatedTimelineLanesControl.xaml.cs    |    2 +-
 Lite/Helpers/CorrelatedCrosshairManager.cs    |   18 +-
 12 files changed, 1609 insertions(+), 638 deletions(-)
 create mode 100644 Dashboard/Analysis/SqlServerBaselineProvider.cs

diff --git a/Dashboard/Analysis/AnalysisService.cs b/Dashboard/Analysis/AnalysisService.cs
index a0d7b2f..e982c19 100644
--- a/Dashboard/Analysis/AnalysisService.cs
+++ b/Dashboard/Analysis/AnalysisService.cs
@@ -23,6 +23,7 @@ public class AnalysisService
     private readonly InferenceEngine _engine;
     private readonly SqlServerDrillDownCollector _drillDown;
     private readonly SqlServerAnomalyDetector _anomalyDetector;
+    private readonly SqlServerBaselineProvider _baselineProvider;
 
     /// <summary>
     /// Minimum hours of collected data required before analysis will run.
@@ -60,7 +61,8 @@ public AnalysisService(string connectionString, IPlanFetcher? planFetcher = null
         _graph = new RelationshipGraph();
         _engine = new InferenceEngine(_graph);
         _drillDown = new SqlServerDrillDownCollector(connectionString, planFetcher);
-        _anomalyDetector = new SqlServerAnomalyDetector(connectionString);
+        _baselineProvider = new SqlServerBaselineProvider(connectionString);
+        _anomalyDetector = new SqlServerAnomalyDetector(connectionString, _baselineProvider);
     }
 
     /// <summary>
diff --git a/Dashboard/Analysis/FactScorer.cs b/Dashboard/Analysis/FactScorer.cs
index 7834795..5605a88 100644
--- a/Dashboard/Analysis/FactScorer.cs
+++ b/Dashboard/Analysis/FactScorer.cs
@@ -308,9 +308,12 @@ private static double ScoreBadActorFact(Fact fact)
     /// </summary>
     private static double ScoreAnomalyFact(Fact fact)
     {
-        if (   fact.Key.StartsWith("ANOMALY_CPU_SPIKE"    , StringComparison.OrdinalIgnoreCase)
-            || fact.Key.StartsWith("ANOMALY_READ_LATENCY" , StringComparison.OrdinalIgnoreCase)
-            || fact.Key.StartsWith("ANOMALY_WRITE_LATENCY", StringComparison.OrdinalIgnoreCase)
+        if (   fact.Key.StartsWith("ANOMALY_CPU_SPIKE"      , StringComparison.OrdinalIgnoreCase)
+            || fact.Key.StartsWith("ANOMALY_READ_LATENCY"  , StringComparison.OrdinalIgnoreCase)
+            || fact.Key.StartsWith("ANOMALY_WRITE_LATENCY" , StringComparison.OrdinalIgnoreCase)
+            || fact.Key.StartsWith("ANOMALY_BATCH_REQUESTS", StringComparison.OrdinalIgnoreCase)
+            || fact.Key.StartsWith("ANOMALY_SESSION_SPIKE" , StringComparison.OrdinalIgnoreCase)
+            || fact.Key.StartsWith("ANOMALY_QUERY_DURATION", StringComparison.OrdinalIgnoreCase)
             )
         {
             // Deviation-based scoring: 2σ = 0.5, 4σ = 1.0
diff --git a/Dashboard/Analysis/SqlServerAnomalyDetector.cs b/Dashboard/Analysis/SqlServerAnomalyDetector.cs
index bdf6664..82d2629 100644
--- a/Dashboard/Analysis/SqlServerAnomalyDetector.cs
+++ b/Dashboard/Analysis/SqlServerAnomalyDetector.cs
@@ -1,543 +1,708 @@
-using System;
-using System.Collections.Generic;
-using System.Threading.Tasks;
-using Microsoft.Data.SqlClient;
-using PerformanceMonitorDashboard.Helpers;
-
-namespace PerformanceMonitorDashboard.Analysis;
-
-/// <summary>
-/// Detects anomalies by comparing the analysis window's metrics against a
-/// baseline period. When a metric deviates significantly from baseline
-/// (mean + standard deviation), an ANOMALY fact is emitted.
-///
-/// This is the "oh shit" mode -- detecting acute deviations that don't show
-/// up in aggregate analysis because they're brief. A 5-minute CPU spike
-/// that averages out over 4 hours is invisible to aggregate scoring but
-/// obvious when compared against "what was this metric doing before?"
-///
-/// Baseline selection: uses the 24 hours preceding the analysis window.
-/// If less data is available, uses whatever exists with lower confidence.
-///
-/// Port of Lite's AnomalyDetector -- uses SQL Server collect.* tables instead of DuckDB views.
-/// No server_id filtering -- Dashboard monitors one server per database.
-/// </summary>
-public class SqlServerAnomalyDetector
-{
-    private readonly string _connectionString;
-
-    /// <summary>
-    /// Minimum number of baseline samples needed for reliable detection.
-    /// Below this, anomalies are still detected but with reduced confidence.
-    /// </summary>
-    private const int MinBaselineSamples = 10;
-
-    /// <summary>
-    /// Number of standard deviations above baseline mean to flag as anomalous.
-    /// </summary>
-    private const double DeviationThreshold = 2.0;
-
-    public SqlServerAnomalyDetector(string connectionString)
-    {
-        _connectionString = connectionString;
-    }
-
-    /// <summary>
-    /// Detects anomalies by comparing the analysis window against a baseline period.
-    /// Returns anomaly facts to be merged into the main fact list.
-    /// </summary>
-    public async Task<List<Fact>> DetectAnomaliesAsync(AnalysisContext context)
-    {
-        var anomalies = new List<Fact>();
-
-        // Baseline: 24 hours preceding the analysis window
-        var baselineEnd = context.TimeRangeStart;
-        var baselineStart = baselineEnd.AddHours(-24);
-
-        // Check if baseline period has any data at all -- if not, skip all anomaly detection.
-        // Without baseline data, everything looks anomalous.
-        if (!await HasBaselineDataAsync(baselineStart, baselineEnd))
-            return anomalies;
-
-        await DetectCpuAnomalies(context, baselineStart, baselineEnd, anomalies);
-        await DetectWaitAnomalies(context, baselineStart, baselineEnd, anomalies);
-        await DetectBlockingAnomalies(context, baselineStart, baselineEnd, anomalies);
-        await DetectIoAnomalies(context, baselineStart, baselineEnd, anomalies);
-
-        return anomalies;
-    }
-
-    /// <summary>
-    /// Checks if the baseline period has any collected data.
-    /// Uses wait_stats as canary -- if waits are collected, other data is too.
-    /// </summary>
-    private async Task<bool> HasBaselineDataAsync(DateTime baselineStart, DateTime baselineEnd)
-    {
-        try
-        {
-            using var connection = new SqlConnection(_connectionString);
-            await connection.OpenAsync();
-
-            using var cmd = connection.CreateCommand();
-            cmd.CommandText = @"
-SET TRANSACTION ISOLATION LEVEL READ UNCOMMITTED;
-
-SELECT
-    (SELECT COUNT(*) FROM collect.wait_stats
-     WHERE collection_time >= @baselineStart AND collection_time < @baselineEnd)
-  + (SELECT COUNT(*) FROM collect.cpu_utilization_stats
-     WHERE collection_time >= @baselineStart AND collection_time < @baselineEnd);";
-
-            cmd.Parameters.Add(new SqlParameter("@baselineStart", baselineStart));
-            cmd.Parameters.Add(new SqlParameter("@baselineEnd", baselineEnd));
-
-            var count = Convert.ToInt64(await cmd.ExecuteScalarAsync() ?? 0);
-            return count > 0;
-        }
-        catch { return false; }
-    }
-
-    /// <summary>
-    /// Detects CPU utilization anomalies by comparing per-sample values
-    /// against the baseline distribution.
-    /// </summary>
-    private async Task DetectCpuAnomalies(AnalysisContext context,
-        DateTime baselineStart, DateTime baselineEnd, List<Fact> anomalies)
-    {
-        try
-        {
-            using var connection = new SqlConnection(_connectionString);
-            await connection.OpenAsync();
-
-            // Get baseline stats
-            using var baselineCmd = connection.CreateCommand();
-            baselineCmd.CommandText = @"
-SET TRANSACTION ISOLATION LEVEL READ UNCOMMITTED;
-
-SELECT
-    AVG(CAST(sqlserver_cpu_utilization AS FLOAT)) AS mean_cpu,
-    STDEV(CAST(sqlserver_cpu_utilization AS FLOAT)) AS stddev_cpu,
-    COUNT(*) AS sample_count
-FROM collect.cpu_utilization_stats
-WHERE collection_time >= @baselineStart
-AND   collection_time < @baselineEnd;";
-
-            baselineCmd.Parameters.Add(new SqlParameter("@baselineStart", baselineStart));
-            baselineCmd.Parameters.Add(new SqlParameter("@baselineEnd", baselineEnd));
-
-            double baselineMean = 0, baselineStdDev = 0;
-            long baselineSamples = 0;
-
-            using (var reader = await baselineCmd.ExecuteReaderAsync())
-            {
-                if (await reader.ReadAsync())
-                {
-                    baselineMean = reader.IsDBNull(0) ? 0 : Convert.ToDouble(reader.GetValue(0));
-                    baselineStdDev = reader.IsDBNull(1) ? 0 : Convert.ToDouble(reader.GetValue(1));
-                    baselineSamples = reader.IsDBNull(2) ? 0 : Convert.ToInt64(reader.GetValue(2));
-                }
-            }
-
-            if (baselineSamples < 3 || baselineStdDev <= 0) return;
-
-            // Get peak and average in the analysis window
-            using var windowCmd = connection.CreateCommand();
-            windowCmd.CommandText = @"
-SET TRANSACTION ISOLATION LEVEL READ UNCOMMITTED;
-
-SELECT
-    MAX(sqlserver_cpu_utilization) AS peak_cpu,
-    AVG(CAST(sqlserver_cpu_utilization AS FLOAT)) AS avg_cpu,
-    COUNT(*) AS sample_count,
-    (SELECT TOP 1 collection_time FROM collect.cpu_utilization_stats
-     WHERE collection_time >= @windowStart AND collection_time < @windowEnd
-     ORDER BY sqlserver_cpu_utilization DESC) AS peak_time
-FROM collect.cpu_utilization_stats
-WHERE collection_time >= @windowStart
-AND   collection_time < @windowEnd;";
-
-            windowCmd.Parameters.Add(new SqlParameter("@windowStart", context.TimeRangeStart));
-            windowCmd.Parameters.Add(new SqlParameter("@windowEnd", context.TimeRangeEnd));
-
-            using var windowReader = await windowCmd.ExecuteReaderAsync();
-            if (!await windowReader.ReadAsync()) return;
-
-            var peakCpu = windowReader.IsDBNull(0) ? 0.0 : Convert.ToDouble(windowReader.GetValue(0));
-            var avgCpu = windowReader.IsDBNull(1) ? 0.0 : Convert.ToDouble(windowReader.GetValue(1));
-            var windowSamples = windowReader.IsDBNull(2) ? 0L : Convert.ToInt64(windowReader.GetValue(2));
-            var peakTime = windowReader.IsDBNull(3) ? (DateTime?)null : windowReader.GetDateTime(3);
-
-            if (windowSamples == 0) return;
-
-            // Check if peak deviates significantly from baseline
-            var deviation = (peakCpu - baselineMean) / baselineStdDev;
-            if (deviation < DeviationThreshold || peakCpu < 50) return; // Don't flag low absolute values
-
-            var confidence = baselineSamples >= MinBaselineSamples ? 1.0 : (double)baselineSamples / MinBaselineSamples;
-
-            anomalies.Add(new Fact
-            {
-                Source = "anomaly",
-                Key = "ANOMALY_CPU_SPIKE",
-                Value = peakCpu,
-                ServerId = context.ServerId,
-                Metadata = new Dictionary<string, double>
-                {
-                    ["peak_cpu"] = peakCpu,
-                    ["avg_cpu_in_window"] = avgCpu,
-                    ["baseline_mean"] = baselineMean,
-                    ["baseline_stddev"] = baselineStdDev,
-                    ["deviation_sigma"] = deviation,
-                    ["baseline_samples"] = baselineSamples,
-                    ["window_samples"] = windowSamples,
-                    ["confidence"] = confidence,
-                    ["peak_time_ticks"] = peakTime?.Ticks ?? 0
-                }
-            });
-        }
-        catch (Exception ex)
-        {
-            Logger.Error($"[SqlServerAnomalyDetector] CPU anomaly detection failed: {ex.Message}");
-        }
-    }
-
-    /// <summary>
-    /// Detects wait stat anomalies -- significant waits in the analysis window
-    /// that were absent or much lower in the baseline.
-    /// </summary>
-    private async Task DetectWaitAnomalies(AnalysisContext context,
-        DateTime baselineStart, DateTime baselineEnd, List<Fact> anomalies)
-    {
-        try
-        {
-            using var connection = new SqlConnection(_connectionString);
-            await connection.OpenAsync();
-
-            // Check if baseline has any wait data at all -- if not, skip
-            using var checkCmd = connection.CreateCommand();
-            checkCmd.CommandText = @"
-SET TRANSACTION ISOLATION LEVEL READ UNCOMMITTED;
-
-SELECT COUNT(*) FROM collect.wait_stats
-WHERE collection_time >= @baselineStart AND collection_time < @baselineEnd;";
-
-            checkCmd.Parameters.Add(new SqlParameter("@baselineStart", baselineStart));
-            checkCmd.Parameters.Add(new SqlParameter("@baselineEnd", baselineEnd));
-
-            var baselineCount = Convert.ToInt64(await checkCmd.ExecuteScalarAsync() ?? 0);
-            if (baselineCount == 0) return;
-
-            // Get per-wait-type totals in both windows
-            using var cmd = connection.CreateCommand();
-            cmd.CommandText = @"
-SET TRANSACTION ISOLATION LEVEL READ UNCOMMITTED;
-
-;WITH baseline AS (
-    SELECT wait_type,
-           CAST(SUM(wait_time_ms_delta) AS BIGINT) AS total_ms
-    FROM collect.wait_stats
-    WHERE collection_time >= @baselineStart AND collection_time < @baselineEnd
-    AND   wait_time_ms_delta > 0
-    GROUP BY wait_type
-),
-current_window AS (
-    SELECT wait_type,
-           CAST(SUM(wait_time_ms_delta) AS BIGINT) AS total_ms
-    FROM collect.wait_stats
-    WHERE collection_time >= @windowStart AND collection_time <= @windowEnd
-    AND   wait_time_ms_delta > 0
-    GROUP BY wait_type
-)
-SELECT TOP 10
-    c.wait_type,
-    c.total_ms AS current_ms,
-    COALESCE(b.total_ms, 0) AS baseline_ms
-FROM current_window c
-LEFT JOIN baseline b ON c.wait_type = b.wait_type
-WHERE c.total_ms > 10000  -- At least 10 seconds of wait time
-ORDER BY c.total_ms DESC;";
-
-            cmd.Parameters.Add(new SqlParameter("@baselineStart", baselineStart));
-            cmd.Parameters.Add(new SqlParameter("@baselineEnd", baselineEnd));
-            cmd.Parameters.Add(new SqlParameter("@windowStart", context.TimeRangeStart));
-            cmd.Parameters.Add(new SqlParameter("@windowEnd", context.TimeRangeEnd));
-
-            using var reader = await cmd.ExecuteReaderAsync();
-            while (await reader.ReadAsync())
-            {
-                var waitType = reader.GetString(0);
-                var currentMs = Convert.ToInt64(reader.GetValue(1));
-                var baselineMs = Convert.ToInt64(reader.GetValue(2));
-
-                // Normalize to per-hour rates before comparing (windows are different lengths)
-                var baselineHours = (baselineEnd - baselineStart).TotalHours;
-                var currentHours = (context.TimeRangeEnd - context.TimeRangeStart).TotalHours;
-                if (baselineHours <= 0) baselineHours = 1;
-                if (currentHours <= 0) currentHours = 1;
-
-                double ratio;
-                string anomalyType;
-
-                if (baselineMs == 0)
-                {
-                    ratio = currentMs > 60_000 ? 100.0 : 0; // Only flag if > 1 minute total
-                    anomalyType = "new";
-                }
-                else
-                {
-                    var baselineRate = baselineMs / baselineHours;
-                    var currentRate = currentMs / currentHours;
-                    ratio = baselineRate > 0 ? currentRate / baselineRate : 100.0;
-                    anomalyType = "spike";
-                }
-
-                if (ratio < 5.0) continue; // Need at least 5x increase
-
-                anomalies.Add(new Fact
-                {
-                    Source = "anomaly",
-                    Key = $"ANOMALY_WAIT_{waitType}",
-                    Value = currentMs,
-                    ServerId = context.ServerId,
-                    Metadata = new Dictionary<string, double>
-                    {
-                        ["current_ms"] = currentMs,
-                        ["baseline_ms"] = baselineMs,
-                        ["ratio"] = ratio,
-                        ["is_new"] = anomalyType == "new" ? 1 : 0
-                    }
-                });
-            }
-        }
-        catch (Exception ex)
-        {
-            Logger.Error($"[SqlServerAnomalyDetector] Wait anomaly detection failed: {ex.Message}");
-        }
-    }
-
-    /// <summary>
-    /// Detects blocking/deadlock anomalies -- events in the analysis window
-    /// that are significantly above baseline rates.
-    /// </summary>
-    private async Task DetectBlockingAnomalies(AnalysisContext context,
-        DateTime baselineStart, DateTime baselineEnd, List<Fact> anomalies)
-    {
-        try
-        {
-            using var connection = new SqlConnection(_connectionString);
-            await connection.OpenAsync();
-
-            // Check if baseline period has any data at all
-            using var checkCmd = connection.CreateCommand();
-            checkCmd.CommandText = @"
-SET TRANSACTION ISOLATION LEVEL READ UNCOMMITTED;
-
-SELECT
-    (SELECT COUNT(*) FROM collect.blocking_BlockedProcessReport
-     WHERE collection_time >= @baselineStart AND collection_time < @baselineEnd)
-  + (SELECT COUNT(*) FROM collect.deadlocks
-     WHERE collection_time >= @baselineStart AND collection_time < @baselineEnd)
-  + (SELECT COUNT(*) FROM collect.wait_stats
-     WHERE collection_time >= @baselineStart AND collection_time < @baselineEnd);";
-
-            checkCmd.Parameters.Add(new SqlParameter("@baselineStart", baselineStart));
-            checkCmd.Parameters.Add(new SqlParameter("@baselineEnd", baselineEnd));
-
-            var baselineDataCount = Convert.ToInt64(await checkCmd.ExecuteScalarAsync() ?? 0);
-            if (baselineDataCount == 0) return; // No baseline data = can't detect anomaly
-
-            using var cmd = connection.CreateCommand();
-            cmd.CommandText = @"
-SET TRANSACTION ISOLATION LEVEL READ UNCOMMITTED;
-
-SELECT
-    (SELECT COUNT(*) FROM collect.blocking_BlockedProcessReport
-     WHERE collection_time >= @baselineStart AND collection_time < @baselineEnd) AS baseline_blocking,
-    (SELECT COUNT(*) FROM collect.blocking_BlockedProcessReport
-     WHERE collection_time >= @windowStart AND collection_time <= @windowEnd) AS current_blocking,
-    (SELECT COUNT(*) FROM collect.deadlocks
-     WHERE collection_time >= @baselineStart AND collection_time < @baselineEnd) AS baseline_deadlocks,
-    (SELECT COUNT(*) FROM collect.deadlocks
-     WHERE collection_time >= @windowStart AND collection_time <= @windowEnd) AS current_deadlocks;";
-
-            cmd.Parameters.Add(new SqlParameter("@baselineStart", baselineStart));
-            cmd.Parameters.Add(new SqlParameter("@baselineEnd", baselineEnd));
-            cmd.Parameters.Add(new SqlParameter("@windowStart", context.TimeRangeStart));
-            cmd.Parameters.Add(new SqlParameter("@windowEnd", context.TimeRangeEnd));
-
-            using var reader = await cmd.ExecuteReaderAsync();
-            if (!await reader.ReadAsync()) return;
-
-            var baselineBlocking = Convert.ToInt64(reader.GetValue(0));
-            var currentBlocking = Convert.ToInt64(reader.GetValue(1));
-            var baselineDeadlocks = Convert.ToInt64(reader.GetValue(2));
-            var currentDeadlocks = Convert.ToInt64(reader.GetValue(3));
-
-            // Normalize to per-hour rates (windows are different lengths)
-            var baselineHours = (baselineEnd - baselineStart).TotalHours;
-            var currentHours = (context.TimeRangeEnd - context.TimeRangeStart).TotalHours;
-            if (baselineHours <= 0) baselineHours = 1;
-            if (currentHours <= 0) currentHours = 1;
-
-            var baselineBlockingRate = baselineBlocking / baselineHours;
-            var currentBlockingRate = currentBlocking / currentHours;
-            var blockingRatio = baselineBlocking > 0 ? currentBlockingRate / baselineBlockingRate : 100.0;
-
-            var baselineDeadlockRate = baselineDeadlocks / baselineHours;
-            var currentDeadlockRate = currentDeadlocks / currentHours;
-            var deadlockRatio = baselineDeadlocks > 0 ? currentDeadlockRate / baselineDeadlockRate : 100.0;
-
-            // Blocking spike: at least 5 events AND 3x baseline rate (or new)
-            if (currentBlocking >= 5 && (baselineBlocking == 0 || blockingRatio >= 3))
-            {
-                anomalies.Add(new Fact
-                {
-                    Source = "anomaly",
-                    Key = "ANOMALY_BLOCKING_SPIKE",
-                    Value = currentBlocking,
-                    ServerId = context.ServerId,
-                    Metadata = new Dictionary<string, double>
-                    {
-                        ["current_count"] = currentBlocking,
-                        ["baseline_count"] = baselineBlocking,
-                        ["ratio"] = blockingRatio
-                    }
-                });
-            }
-
-            // Deadlock spike: at least 3 events AND 3x baseline rate (or new)
-            if (currentDeadlocks >= 3 && (baselineDeadlocks == 0 || deadlockRatio >= 3))
-            {
-                anomalies.Add(new Fact
-                {
-                    Source = "anomaly",
-                    Key = "ANOMALY_DEADLOCK_SPIKE",
-                    Value = currentDeadlocks,
-                    ServerId = context.ServerId,
-                    Metadata = new Dictionary<string, double>
-                    {
-                        ["current_count"] = currentDeadlocks,
-                        ["baseline_count"] = baselineDeadlocks,
-                        ["ratio"] = deadlockRatio
-                    }
-                });
-            }
-        }
-        catch (Exception ex)
-        {
-            Logger.Error($"[SqlServerAnomalyDetector] Blocking anomaly detection failed: {ex.Message}");
-        }
-    }
-
-    /// <summary>
-    /// Detects I/O latency anomalies -- significant increase in read/write latency
-    /// compared to baseline.
-    /// </summary>
-    private async Task DetectIoAnomalies(AnalysisContext context,
-        DateTime baselineStart, DateTime baselineEnd, List<Fact> anomalies)
-    {
-        try
-        {
-            using var connection = new SqlConnection(_connectionString);
-            await connection.OpenAsync();
-
-            using var cmd = connection.CreateCommand();
-            cmd.CommandText = @"
-SET TRANSACTION ISOLATION LEVEL READ UNCOMMITTED;
-
-;WITH baseline AS (
-    SELECT
-        AVG(io_stall_read_ms_delta * 1.0 / NULLIF(num_of_reads_delta, 0)) AS avg_read_lat,
-        AVG(io_stall_write_ms_delta * 1.0 / NULLIF(num_of_writes_delta, 0)) AS avg_write_lat,
-        STDEV(io_stall_read_ms_delta * 1.0 / NULLIF(num_of_reads_delta, 0)) AS stddev_read,
-        STDEV(io_stall_write_ms_delta * 1.0 / NULLIF(num_of_writes_delta, 0)) AS stddev_write,
-        COUNT(*) AS samples
-    FROM collect.file_io_stats
-    WHERE collection_time >= @baselineStart AND collection_time < @baselineEnd
-    AND   (num_of_reads_delta > 0 OR num_of_writes_delta > 0)
-),
-current_window AS (
-    SELECT
-        AVG(io_stall_read_ms_delta * 1.0 / NULLIF(num_of_reads_delta, 0)) AS avg_read_lat,
-        AVG(io_stall_write_ms_delta * 1.0 / NULLIF(num_of_writes_delta, 0)) AS avg_write_lat
-    FROM collect.file_io_stats
-    WHERE collection_time >= @windowStart AND collection_time <= @windowEnd
-    AND   (num_of_reads_delta > 0 OR num_of_writes_delta > 0)
-)
-SELECT b.avg_read_lat, b.stddev_read, c.avg_read_lat,
-       b.avg_write_lat, b.stddev_write, c.avg_write_lat,
-       b.samples
-FROM baseline b, current_window c;";
-
-            cmd.Parameters.Add(new SqlParameter("@baselineStart", baselineStart));
-            cmd.Parameters.Add(new SqlParameter("@baselineEnd", baselineEnd));
-            cmd.Parameters.Add(new SqlParameter("@windowStart", context.TimeRangeStart));
-            cmd.Parameters.Add(new SqlParameter("@windowEnd", context.TimeRangeEnd));
-
-            using var reader = await cmd.ExecuteReaderAsync();
-            if (!await reader.ReadAsync()) return;
-
-            var baselineReadLat = reader.IsDBNull(0) ? 0.0 : Convert.ToDouble(reader.GetValue(0));
-            var stddevRead = reader.IsDBNull(1) ? 0.0 : Convert.ToDouble(reader.GetValue(1));
-            var currentReadLat = reader.IsDBNull(2) ? 0.0 : Convert.ToDouble(reader.GetValue(2));
-            var baselineWriteLat = reader.IsDBNull(3) ? 0.0 : Convert.ToDouble(reader.GetValue(3));
-            var stddevWrite = reader.IsDBNull(4) ? 0.0 : Convert.ToDouble(reader.GetValue(4));
-            var currentWriteLat = reader.IsDBNull(5) ? 0.0 : Convert.ToDouble(reader.GetValue(5));
-            var samples = reader.IsDBNull(6) ? 0L : Convert.ToInt64(reader.GetValue(6));
-
-            if (samples < 3) return;
-
-            // Read latency anomaly
-            if (stddevRead > 0 && currentReadLat > 10) // At least 10ms to matter
-            {
-                var readDeviation = (currentReadLat - baselineReadLat) / stddevRead;
-                if (readDeviation >= DeviationThreshold)
-                {
-                    anomalies.Add(new Fact
-                    {
-                        Source = "anomaly",
-                        Key = "ANOMALY_READ_LATENCY",
-                        Value = currentReadLat,
-                        ServerId = context.ServerId,
-                        Metadata = new Dictionary<string, double>
-                        {
-                            ["current_latency_ms"] = currentReadLat,
-                            ["baseline_mean_ms"] = baselineReadLat,
-                            ["baseline_stddev_ms"] = stddevRead,
-                            ["deviation_sigma"] = readDeviation,
-                            ["baseline_samples"] = samples
-                        }
-                    });
-                }
-            }
-
-            // Write latency anomaly
-            if (stddevWrite > 0 && currentWriteLat > 5) // At least 5ms to matter
-            {
-                var writeDeviation = (currentWriteLat - baselineWriteLat) / stddevWrite;
-                if (writeDeviation >= DeviationThreshold)
-                {
-                    anomalies.Add(new Fact
-                    {
-                        Source = "anomaly",
-                        Key = "ANOMALY_WRITE_LATENCY",
-                        Value = currentWriteLat,
-                        ServerId = context.ServerId,
-                        Metadata = new Dictionary<string, double>
-                        {
-                            ["current_latency_ms"] = currentWriteLat,
-                            ["baseline_mean_ms"] = baselineWriteLat,
-                            ["baseline_stddev_ms"] = stddevWrite,
-                            ["deviation_sigma"] = writeDeviation,
-                            ["baseline_samples"] = samples
-                        }
-                    });
-                }
-            }
-        }
-        catch (Exception ex)
-        {
-            Logger.Error($"[SqlServerAnomalyDetector] I/O anomaly detection failed: {ex.Message}");
-        }
-    }
-}
+using System;
+using System.Collections.Generic;
+using System.Threading.Tasks;
+using Microsoft.Data.SqlClient;
+using PerformanceMonitorDashboard.Helpers;
+
+namespace PerformanceMonitorDashboard.Analysis;
+
+/// <summary>
+/// Detects anomalies by comparing the analysis window's metrics against
+/// time-bucketed baselines (hour-of-day x day-of-week, 30-day rolling window).
+///
+/// Two detection patterns:
+/// - Z-score: (observed - mean) / stddev — used for continuous metrics
+///   (CPU, batch requests, I/O latency, session counts, query duration)
+/// - Ratio: currentRate / baselineRate — used for rate/event metrics
+///   (wait stats, blocking, deadlocks)
+///
+/// Baseline computation and caching are handled by SqlServerBaselineProvider.
+///
+/// Port of Lite's AnomalyDetector — uses SQL Server collect.* tables instead of DuckDB views.
+/// No server_id filtering — Dashboard monitors one server per database.
+/// No memory metric — Dashboard doesn't collect memory stats.
+/// </summary>
+public class SqlServerAnomalyDetector
+{
+    private readonly string _connectionString;
+    private readonly SqlServerBaselineProvider _baselineProvider;
+
+    /// <summary>
+    /// Default number of standard deviations above baseline mean to flag as anomalous.
+    /// </summary>
+    private const double DefaultDeviationThreshold = 2.0;
+
+    /// <summary>
+    /// Default ratio threshold for rate-based anomaly detection (wait stats).
+    /// </summary>
+    private const double DefaultRatioThreshold = 5.0;
+
+    /// <summary>
+    /// Default ratio threshold for event-based anomaly detection (blocking/deadlocks).
+    /// </summary>
+    private const double DefaultEventRatioThreshold = 3.0;
+
+    /// <summary>
+    /// Per-metric deviation thresholds. Metrics not listed use DefaultDeviationThreshold.
+    /// </summary>
+    private readonly Dictionary<string, double> _deviationThresholds = new();
+
+    public SqlServerAnomalyDetector(string connectionString, SqlServerBaselineProvider baselineProvider)
+    {
+        _connectionString = connectionString;
+        _baselineProvider = baselineProvider;
+    }
+
+    /// <summary>
+    /// Sets a custom deviation threshold for a specific metric.
+    /// </summary>
+    public void SetDeviationThreshold(string metricName, double threshold)
+    {
+        _deviationThresholds[metricName] = threshold;
+    }
+
+    private double GetDeviationThreshold(string metricName)
+    {
+        return _deviationThresholds.TryGetValue(metricName, out var threshold)
+            ? threshold
+            : DefaultDeviationThreshold;
+    }
+
+    /// <summary>
+    /// Adds baseline context metadata to an anomaly fact's metadata dictionary.
+    /// </summary>
+    private static void AddBaselineContext(Dictionary<string, double> metadata, BaselineBucket baseline)
+    {
+        metadata["baseline_hour"] = baseline.HourOfDay;
+        metadata["baseline_dow"] = baseline.DayOfWeek;
+        metadata["baseline_tier"] = (double)baseline.Tier;
+    }
+
+    /// <summary>
+    /// Detects anomalies by comparing the analysis window against time-bucketed baselines.
+    /// Returns anomaly facts to be merged into the main fact list.
+    /// </summary>
+    public async Task<List<Fact>> DetectAnomaliesAsync(AnalysisContext context)
+    {
+        var anomalies = new List<Fact>();
+
+        // Check if baseline period has any data at all — if not, skip all anomaly detection.
+        if (!await HasBaselineDataAsync())
+            return anomalies;
+
+        // Existing detection methods (upgraded to time-bucketed baselines)
+        await DetectCpuAnomalies(context, anomalies);
+        await DetectWaitAnomalies(context, anomalies);
+        await DetectBlockingAnomalies(context, anomalies);
+        await DetectIoAnomalies(context, anomalies);
+
+        // New detection methods
+        await DetectBatchRequestAnomalies(context, anomalies);
+        await DetectSessionAnomalies(context, anomalies);
+        await DetectQueryDurationAnomalies(context, anomalies);
+
+        return anomalies;
+    }
+
+    /// <summary>
+    /// Checks if the server has enough historical data for meaningful baselines.
+    /// Uses wait_stats and cpu_utilization_stats as canary.
+    /// </summary>
+    private async Task<bool> HasBaselineDataAsync()
+    {
+        try
+        {
+            using var connection = new SqlConnection(_connectionString);
+            await connection.OpenAsync();
+
+            using var cmd = connection.CreateCommand();
+            cmd.CommandText = @"
+SET TRANSACTION ISOLATION LEVEL READ UNCOMMITTED;
+
+SELECT
+    (SELECT COUNT(*) FROM collect.wait_stats
+     WHERE collection_time >= @cutoff)
+  + (SELECT COUNT(*) FROM collect.cpu_utilization_stats
+     WHERE collection_time >= @cutoff);";
+
+            cmd.Parameters.Add(new SqlParameter("@cutoff", DateTime.UtcNow.AddDays(-30)));
+
+            var count = Convert.ToInt64(await cmd.ExecuteScalarAsync() ?? 0);
+            return count > 0;
+        }
+        catch { return false; }
+    }
+
+    /// <summary>
+    /// Detects CPU utilization anomalies using z-score against time-bucketed baseline.
+    /// </summary>
+    private async Task DetectCpuAnomalies(AnalysisContext context, List<Fact> anomalies)
+    {
+        try
+        {
+            var baseline = await _baselineProvider.GetBaselineAsync(
+                SqlServerMetricNames.Cpu, context.TimeRangeStart);
+
+            if (baseline.SampleCount == 0) return;
+            var effectiveStdDev = baseline.EffectiveStdDev;
+            if (effectiveStdDev <= 0) return;
+
+            using var connection = new SqlConnection(_connectionString);
+            await connection.OpenAsync();
+
+            using var cmd = connection.CreateCommand();
+            cmd.CommandText = @"
+SET TRANSACTION ISOLATION LEVEL READ UNCOMMITTED;
+
+SELECT
+    MAX(sqlserver_cpu_utilization) AS peak_cpu,
+    AVG(CAST(sqlserver_cpu_utilization AS FLOAT)) AS avg_cpu,
+    COUNT(*) AS sample_count,
+    (SELECT TOP 1 collection_time FROM collect.cpu_utilization_stats
+     WHERE collection_time >= @windowStart AND collection_time < @windowEnd
+     ORDER BY sqlserver_cpu_utilization DESC) AS peak_time
+FROM collect.cpu_utilization_stats
+WHERE collection_time >= @windowStart
+AND   collection_time < @windowEnd;";
+
+            cmd.Parameters.Add(new SqlParameter("@windowStart", context.TimeRangeStart));
+            cmd.Parameters.Add(new SqlParameter("@windowEnd", context.TimeRangeEnd));
+
+            using var reader = await cmd.ExecuteReaderAsync();
+            if (!await reader.ReadAsync()) return;
+
+            var peakCpu = reader.IsDBNull(0) ? 0.0 : Convert.ToDouble(reader.GetValue(0));
+            var avgCpu = reader.IsDBNull(1) ? 0.0 : Convert.ToDouble(reader.GetValue(1));
+            var windowSamples = reader.IsDBNull(2) ? 0L : Convert.ToInt64(reader.GetValue(2));
+            var peakTime = reader.IsDBNull(3) ? (DateTime?)null : reader.GetDateTime(3);
+
+            if (windowSamples == 0) return;
+
+            var deviation = (peakCpu - baseline.Mean) / effectiveStdDev;
+            if (deviation < GetDeviationThreshold(SqlServerMetricNames.Cpu) || peakCpu < 50) return;
+
+            var metadata = new Dictionary<string, double>
+            {
+                ["peak_cpu"] = peakCpu,
+                ["avg_cpu_in_window"] = avgCpu,
+                ["baseline_mean"] = baseline.Mean,
+                ["baseline_stddev"] = effectiveStdDev,
+                ["deviation_sigma"] = deviation,
+                ["baseline_samples"] = baseline.SampleCount,
+                ["window_samples"] = windowSamples,
+                ["confidence"] = 1.0,
+                ["peak_time_ticks"] = peakTime?.Ticks ?? 0
+            };
+            AddBaselineContext(metadata, baseline);
+
+            anomalies.Add(new Fact
+            {
+                Source = "anomaly",
+                Key = "ANOMALY_CPU_SPIKE",
+                Value = peakCpu,
+                ServerId = context.ServerId,
+                Metadata = metadata
+            });
+        }
+        catch (Exception ex)
+        {
+            Logger.Error($"[SqlServerAnomalyDetector] CPU anomaly detection failed: {ex.Message}");
+        }
+    }
+
+    /// <summary>
+    /// Detects wait stat anomalies — total wait time significantly above
+    /// baseline rate for this time bucket. Uses ratio-based scoring.
+    /// </summary>
+    private async Task DetectWaitAnomalies(AnalysisContext context, List<Fact> anomalies)
+    {
+        try
+        {
+            var baseline = await _baselineProvider.GetBaselineAsync(
+                SqlServerMetricNames.WaitStats, context.TimeRangeStart);
+
+            if (baseline.SampleCount == 0) return;
+
+            using var connection = new SqlConnection(_connectionString);
+            await connection.OpenAsync();
+
+            using var cmd = connection.CreateCommand();
+            cmd.CommandText = @"
+SET TRANSACTION ISOLATION LEVEL READ UNCOMMITTED;
+
+SELECT TOP 10
+    wait_type,
+    CAST(SUM(wait_time_ms_delta) AS BIGINT) AS total_ms
+FROM collect.wait_stats
+WHERE collection_time >= @windowStart AND collection_time <= @windowEnd
+AND   wait_time_ms_delta > 0
+GROUP BY wait_type
+HAVING SUM(wait_time_ms_delta) > 10000
+ORDER BY total_ms DESC;";
+
+            cmd.Parameters.Add(new SqlParameter("@windowStart", context.TimeRangeStart));
+            cmd.Parameters.Add(new SqlParameter("@windowEnd", context.TimeRangeEnd));
+
+            var currentHours = (context.TimeRangeEnd - context.TimeRangeStart).TotalHours;
+            if (currentHours <= 0) currentHours = 1;
+
+            var baselineRate = baseline.SampleCount > 0 ? baseline.Mean : 0;
+
+            using var reader = await cmd.ExecuteReaderAsync();
+            while (await reader.ReadAsync())
+            {
+                var waitType = reader.GetString(0);
+                var currentMs = Convert.ToInt64(reader.GetValue(1));
+                var currentRate = currentMs / currentHours;
+
+                double ratio;
+                string anomalyType;
+
+                if (baselineRate <= 0 || baseline.SampleCount == 0)
+                {
+                    ratio = currentMs > 60_000 ? 100.0 : 0;
+                    anomalyType = "new";
+                }
+                else
+                {
+                    ratio = currentRate / baselineRate;
+                    anomalyType = "spike";
+                }
+
+                if (ratio < DefaultRatioThreshold) continue;
+
+                var metadata = new Dictionary<string, double>
+                {
+                    ["current_ms"] = currentMs,
+                    ["baseline_mean"] = baseline.Mean,
+                    ["ratio"] = ratio,
+                    ["is_new"] = anomalyType == "new" ? 1 : 0
+                };
+                AddBaselineContext(metadata, baseline);
+
+                anomalies.Add(new Fact
+                {
+                    Source = "anomaly",
+                    Key = $"ANOMALY_WAIT_{waitType}",
+                    Value = currentMs,
+                    ServerId = context.ServerId,
+                    Metadata = metadata
+                });
+            }
+        }
+        catch (Exception ex)
+        {
+            Logger.Error($"[SqlServerAnomalyDetector] Wait anomaly detection failed: {ex.Message}");
+        }
+    }
+
+    /// <summary>
+    /// Detects blocking/deadlock anomalies — event rates significantly above
+    /// baseline for this time bucket. Uses ratio-based scoring.
+    /// </summary>
+    private async Task DetectBlockingAnomalies(AnalysisContext context, List<Fact> anomalies)
+    {
+        try
+        {
+            var blockingBaseline = await _baselineProvider.GetBaselineAsync(
+                SqlServerMetricNames.Blocking, context.TimeRangeStart);
+            var deadlockBaseline = await _baselineProvider.GetBaselineAsync(
+                SqlServerMetricNames.Deadlock, context.TimeRangeStart);
+
+            using var connection = new SqlConnection(_connectionString);
+            await connection.OpenAsync();
+
+            using var cmd = connection.CreateCommand();
+            cmd.CommandText = @"
+SET TRANSACTION ISOLATION LEVEL READ UNCOMMITTED;
+
+SELECT
+    (SELECT COUNT(*) FROM collect.blocking_BlockedProcessReport
+     WHERE collection_time >= @windowStart AND collection_time <= @windowEnd) AS current_blocking,
+    (SELECT COUNT(*) FROM collect.deadlocks
+     WHERE collection_time >= @windowStart AND collection_time <= @windowEnd) AS current_deadlocks;";
+
+            cmd.Parameters.Add(new SqlParameter("@windowStart", context.TimeRangeStart));
+            cmd.Parameters.Add(new SqlParameter("@windowEnd", context.TimeRangeEnd));
+
+            using var reader = await cmd.ExecuteReaderAsync();
+            if (!await reader.ReadAsync()) return;
+
+            var currentBlocking = Convert.ToInt64(reader.GetValue(0));
+            var currentDeadlocks = Convert.ToInt64(reader.GetValue(1));
+
+            var baselineBlockingRate = blockingBaseline.SampleCount > 0 ? blockingBaseline.Mean : 0;
+            var baselineDeadlockRate = deadlockBaseline.SampleCount > 0 ? deadlockBaseline.Mean : 0;
+
+            // Blocking spike: at least 5 events AND 3x baseline rate (or no baseline)
+            if (currentBlocking >= 5 && (baselineBlockingRate <= 0 || currentBlocking / Math.Max(baselineBlockingRate, 1) >= DefaultEventRatioThreshold))
+            {
+                var metadata = new Dictionary<string, double>
+                {
+                    ["current_count"] = currentBlocking,
+                    ["baseline_rate"] = baselineBlockingRate,
+                    ["ratio"] = baselineBlockingRate > 0 ? currentBlocking / baselineBlockingRate : 100.0
+                };
+                AddBaselineContext(metadata, blockingBaseline);
+
+                anomalies.Add(new Fact
+                {
+                    Source = "anomaly",
+                    Key = "ANOMALY_BLOCKING_SPIKE",
+                    Value = currentBlocking,
+                    ServerId = context.ServerId,
+                    Metadata = metadata
+                });
+            }
+
+            // Deadlock spike: at least 3 events AND 3x baseline rate (or no baseline)
+            if (currentDeadlocks >= 3 && (baselineDeadlockRate <= 0 || currentDeadlocks / Math.Max(baselineDeadlockRate, 1) >= DefaultEventRatioThreshold))
+            {
+                var metadata = new Dictionary<string, double>
+                {
+                    ["current_count"] = currentDeadlocks,
+                    ["baseline_rate"] = baselineDeadlockRate,
+                    ["ratio"] = baselineDeadlockRate > 0 ? currentDeadlocks / baselineDeadlockRate : 100.0
+                };
+                AddBaselineContext(metadata, deadlockBaseline);
+
+                anomalies.Add(new Fact
+                {
+                    Source = "anomaly",
+                    Key = "ANOMALY_DEADLOCK_SPIKE",
+                    Value = currentDeadlocks,
+                    ServerId = context.ServerId,
+                    Metadata = metadata
+                });
+            }
+        }
+        catch (Exception ex)
+        {
+            Logger.Error($"[SqlServerAnomalyDetector] Blocking anomaly detection failed: {ex.Message}");
+        }
+    }
+
+    /// <summary>
+    /// Detects I/O latency anomalies using z-score against time-bucketed baseline.
+    /// </summary>
+    private async Task DetectIoAnomalies(AnalysisContext context, List<Fact> anomalies)
+    {
+        try
+        {
+            var baseline = await _baselineProvider.GetBaselineAsync(
+                SqlServerMetricNames.IoLatency, context.TimeRangeStart);
+
+            if (baseline.SampleCount == 0) return;
+            var effectiveStdDev = baseline.EffectiveStdDev;
+            if (effectiveStdDev <= 0) return;
+
+            using var connection = new SqlConnection(_connectionString);
+            await connection.OpenAsync();
+
+            using var cmd = connection.CreateCommand();
+            cmd.CommandText = @"
+SET TRANSACTION ISOLATION LEVEL READ UNCOMMITTED;
+
+SELECT
+    AVG(io_stall_read_ms_delta * 1.0 / NULLIF(num_of_reads_delta, 0)) AS avg_read_lat,
+    AVG(io_stall_write_ms_delta * 1.0 / NULLIF(num_of_writes_delta, 0)) AS avg_write_lat
+FROM collect.file_io_stats
+WHERE collection_time >= @windowStart AND collection_time <= @windowEnd
+AND   (num_of_reads_delta > 0 OR num_of_writes_delta > 0);";
+
+            cmd.Parameters.Add(new SqlParameter("@windowStart", context.TimeRangeStart));
+            cmd.Parameters.Add(new SqlParameter("@windowEnd", context.TimeRangeEnd));
+
+            using var reader = await cmd.ExecuteReaderAsync();
+            if (!await reader.ReadAsync()) return;
+
+            var currentReadLat = reader.IsDBNull(0) ? 0.0 : Convert.ToDouble(reader.GetValue(0));
+            var currentWriteLat = reader.IsDBNull(1) ? 0.0 : Convert.ToDouble(reader.GetValue(1));
+
+            var ioThreshold = GetDeviationThreshold(SqlServerMetricNames.IoLatency);
+
+            // Read latency anomaly
+            if (currentReadLat > 10)
+            {
+                var readDeviation = (currentReadLat - baseline.Mean) / effectiveStdDev;
+                if (readDeviation >= ioThreshold)
+                {
+                    var metadata = new Dictionary<string, double>
+                    {
+                        ["current_latency_ms"] = currentReadLat,
+                        ["baseline_mean_ms"] = baseline.Mean,
+                        ["baseline_stddev_ms"] = effectiveStdDev,
+                        ["deviation_sigma"] = readDeviation,
+                        ["baseline_samples"] = baseline.SampleCount
+                    };
+                    AddBaselineContext(metadata, baseline);
+
+                    anomalies.Add(new Fact
+                    {
+                        Source = "anomaly",
+                        Key = "ANOMALY_READ_LATENCY",
+                        Value = currentReadLat,
+                        ServerId = context.ServerId,
+                        Metadata = metadata
+                    });
+                }
+            }
+
+            // Write latency anomaly
+            if (currentWriteLat > 5)
+            {
+                var writeDeviation = (currentWriteLat - baseline.Mean) / effectiveStdDev;
+                if (writeDeviation >= ioThreshold)
+                {
+                    var metadata = new Dictionary<string, double>
+                    {
+                        ["current_latency_ms"] = currentWriteLat,
+                        ["baseline_mean_ms"] = baseline.Mean,
+                        ["baseline_stddev_ms"] = effectiveStdDev,
+                        ["deviation_sigma"] = writeDeviation,
+                        ["baseline_samples"] = baseline.SampleCount
+                    };
+                    AddBaselineContext(metadata, baseline);
+
+                    anomalies.Add(new Fact
+                    {
+                        Source = "anomaly",
+                        Key = "ANOMALY_WRITE_LATENCY",
+                        Value = currentWriteLat,
+                        ServerId = context.ServerId,
+                        Metadata = metadata
+                    });
+                }
+            }
+        }
+        catch (Exception ex)
+        {
+            Logger.Error($"[SqlServerAnomalyDetector] I/O anomaly detection failed: {ex.Message}");
+        }
+    }
+
+    /// <summary>
+    /// Detects batch requests/sec anomalies using z-score against time-bucketed baseline.
+    /// </summary>
+    private async Task DetectBatchRequestAnomalies(AnalysisContext context, List<Fact> anomalies)
+    {
+        try
+        {
+            var baseline = await _baselineProvider.GetBaselineAsync(
+                SqlServerMetricNames.BatchRequests, context.TimeRangeStart);
+
+            if (baseline.SampleCount == 0) return;
+            var effectiveStdDev = baseline.EffectiveStdDev;
+            if (effectiveStdDev <= 0) return;
+
+            using var connection = new SqlConnection(_connectionString);
+            await connection.OpenAsync();
+
+            using var cmd = connection.CreateCommand();
+            cmd.CommandText = @"
+SET TRANSACTION ISOLATION LEVEL READ UNCOMMITTED;
+
+SELECT
+    AVG(cntr_value_delta) AS avg_batch,
+    MAX(cntr_value_delta) AS peak_batch,
+    COUNT(*) AS sample_count
+FROM collect.perfmon_stats
+WHERE collection_time >= @windowStart AND collection_time <= @windowEnd
+AND   counter_name = 'Batch Requests/sec'
+AND   cntr_value_delta >= 0;";
+
+            cmd.Parameters.Add(new SqlParameter("@windowStart", context.TimeRangeStart));
+            cmd.Parameters.Add(new SqlParameter("@windowEnd", context.TimeRangeEnd));
+
+            using var reader = await cmd.ExecuteReaderAsync();
+            if (!await reader.ReadAsync()) return;
+
+            var avgBatch = reader.IsDBNull(0) ? 0.0 : Convert.ToDouble(reader.GetValue(0));
+            var peakBatch = reader.IsDBNull(1) ? 0.0 : Convert.ToDouble(reader.GetValue(1));
+            var windowSamples = reader.IsDBNull(2) ? 0L : Convert.ToInt64(reader.GetValue(2));
+
+            if (windowSamples == 0) return;
+
+            var deviation = (peakBatch - baseline.Mean) / effectiveStdDev;
+            if (deviation < GetDeviationThreshold(SqlServerMetricNames.BatchRequests)) return;
+
+            var metadata = new Dictionary<string, double>
+            {
+                ["peak_batch_requests"] = peakBatch,
+                ["avg_batch_requests"] = avgBatch,
+                ["baseline_mean"] = baseline.Mean,
+                ["baseline_stddev"] = effectiveStdDev,
+                ["deviation_sigma"] = deviation,
+                ["baseline_samples"] = baseline.SampleCount,
+                ["window_samples"] = windowSamples
+            };
+            AddBaselineContext(metadata, baseline);
+
+            anomalies.Add(new Fact
+            {
+                Source = "anomaly",
+                Key = "ANOMALY_BATCH_REQUESTS",
+                Value = peakBatch,
+                ServerId = context.ServerId,
+                Metadata = metadata
+            });
+        }
+        catch (Exception ex)
+        {
+            Logger.Error($"[SqlServerAnomalyDetector] Batch request anomaly detection failed: {ex.Message}");
+        }
+    }
+
+    /// <summary>
+    /// Detects session/connection count anomalies using z-score against time-bucketed baseline.
+    /// </summary>
+    private async Task DetectSessionAnomalies(AnalysisContext context, List<Fact> anomalies)
+    {
+        try
+        {
+            var baseline = await _baselineProvider.GetBaselineAsync(
+                SqlServerMetricNames.SessionCount, context.TimeRangeStart);
+
+            if (baseline.SampleCount == 0) return;
+            var effectiveStdDev = baseline.EffectiveStdDev;
+            if (effectiveStdDev <= 0) return;
+
+            using var connection = new SqlConnection(_connectionString);
+            await connection.OpenAsync();
+
+            using var cmd = connection.CreateCommand();
+            cmd.CommandText = @"
+SET TRANSACTION ISOLATION LEVEL READ UNCOMMITTED;
+
+;WITH per_collection AS (
+    SELECT collection_time,
+           SUM(total_sessions) AS total_connections
+    FROM collect.session_stats
+    WHERE collection_time >= @windowStart AND collection_time <= @windowEnd
+    GROUP BY collection_time
+)
+SELECT AVG(CAST(total_connections AS FLOAT)) AS avg_connections,
+       MAX(total_connections) AS peak_connections,
+       COUNT(*) AS sample_count
+FROM per_collection;";
+
+            cmd.Parameters.Add(new SqlParameter("@windowStart", context.TimeRangeStart));
+            cmd.Parameters.Add(new SqlParameter("@windowEnd", context.TimeRangeEnd));
+
+            using var reader = await cmd.ExecuteReaderAsync();
+            if (!await reader.ReadAsync()) return;
+
+            var avgConnections = reader.IsDBNull(0) ? 0.0 : Convert.ToDouble(reader.GetValue(0));
+            var peakConnections = reader.IsDBNull(1) ? 0.0 : Convert.ToDouble(reader.GetValue(1));
+            var windowSamples = reader.IsDBNull(2) ? 0L : Convert.ToInt64(reader.GetValue(2));
+
+            if (windowSamples == 0) return;
+
+            var deviation = (peakConnections - baseline.Mean) / effectiveStdDev;
+            if (deviation < GetDeviationThreshold(SqlServerMetricNames.SessionCount)) return;
+
+            var metadata = new Dictionary<string, double>
+            {
+                ["peak_connections"] = peakConnections,
+                ["avg_connections"] = avgConnections,
+                ["baseline_mean"] = baseline.Mean,
+                ["baseline_stddev"] = effectiveStdDev,
+                ["deviation_sigma"] = deviation,
+                ["baseline_samples"] = baseline.SampleCount,
+                ["window_samples"] = windowSamples
+            };
+            AddBaselineContext(metadata, baseline);
+
+            anomalies.Add(new Fact
+            {
+                Source = "anomaly",
+                Key = "ANOMALY_SESSION_SPIKE",
+                Value = peakConnections,
+                ServerId = context.ServerId,
+                Metadata = metadata
+            });
+        }
+        catch (Exception ex)
+        {
+            Logger.Error($"[SqlServerAnomalyDetector] Session anomaly detection failed: {ex.Message}");
+        }
+    }
+
+    /// <summary>
+    /// Detects query duration aggregate anomalies using z-score against time-bucketed baseline.
+    /// Measures total elapsed time across all queries per collection interval.
+    /// </summary>
+    private async Task DetectQueryDurationAnomalies(AnalysisContext context, List<Fact> anomalies)
+    {
+        try
+        {
+            var baseline = await _baselineProvider.GetBaselineAsync(
+                SqlServerMetricNames.QueryDuration, context.TimeRangeStart);
+
+            if (baseline.SampleCount == 0) return;
+            var effectiveStdDev = baseline.EffectiveStdDev;
+            if (effectiveStdDev <= 0) return;
+
+            using var connection = new SqlConnection(_connectionString);
+            await connection.OpenAsync();
+
+            using var cmd = connection.CreateCommand();
+            cmd.CommandText = @"
+SET TRANSACTION ISOLATION LEVEL READ UNCOMMITTED;
+
+;WITH per_collection AS (
+    SELECT collection_time,
+           SUM(total_elapsed_time_delta) AS total_elapsed
+    FROM collect.query_stats
+    WHERE collection_time >= @windowStart AND collection_time <= @windowEnd
+    AND   execution_count_delta > 0
+    AND   total_elapsed_time_delta >= 0
+    GROUP BY collection_time
+)
+SELECT AVG(CAST(total_elapsed AS FLOAT)) AS avg_elapsed,
+       MAX(total_elapsed) AS peak_elapsed,
+       COUNT(*) AS sample_count
+FROM per_collection;";
+
+            cmd.Parameters.Add(new SqlParameter("@windowStart", context.TimeRangeStart));
+            cmd.Parameters.Add(new SqlParameter("@windowEnd", context.TimeRangeEnd));
+
+            using var reader = await cmd.ExecuteReaderAsync();
+            if (!await reader.ReadAsync()) return;
+
+            var avgElapsed = reader.IsDBNull(0) ? 0.0 : Convert.ToDouble(reader.GetValue(0));
+            var peakElapsed = reader.IsDBNull(1) ? 0.0 : Convert.ToDouble(reader.GetValue(1));
+            var windowSamples = reader.IsDBNull(2) ? 0L : Convert.ToInt64(reader.GetValue(2));
+
+            if (windowSamples == 0) return;
+
+            var deviation = (peakElapsed - baseline.Mean) / effectiveStdDev;
+            if (deviation < GetDeviationThreshold(SqlServerMetricNames.QueryDuration)) return;
+
+            var metadata = new Dictionary<string, double>
+            {
+                ["peak_total_elapsed_us"] = peakElapsed,
+                ["avg_total_elapsed_us"] = avgElapsed,
+                ["baseline_mean"] = baseline.Mean,
+                ["baseline_stddev"] = effectiveStdDev,
+                ["deviation_sigma"] = deviation,
+                ["baseline_samples"] = baseline.SampleCount,
+                ["window_samples"] = windowSamples
+            };
+            AddBaselineContext(metadata, baseline);
+
+            anomalies.Add(new Fact
+            {
+                Source = "anomaly",
+                Key = "ANOMALY_QUERY_DURATION",
+                Value = peakElapsed,
+                ServerId = context.ServerId,
+                Metadata = metadata
+            });
+        }
+        catch (Exception ex)
+        {
+            Logger.Error($"[SqlServerAnomalyDetector] Query duration anomaly detection failed: {ex.Message}");
+        }
+    }
+}
diff --git a/Dashboard/Analysis/SqlServerBaselineProvider.cs b/Dashboard/Analysis/SqlServerBaselineProvider.cs
new file mode 100644
index 0000000..1746028
--- /dev/null
+++ b/Dashboard/Analysis/SqlServerBaselineProvider.cs
@@ -0,0 +1,525 @@
+using System;
+using System.Collections.Concurrent;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+using Microsoft.Data.SqlClient;
+using PerformanceMonitorDashboard.Helpers;
+
+namespace PerformanceMonitorDashboard.Analysis;
+
+/// <summary>
+/// Provides time-bucketed baselines (hour-of-day x day-of-week) computed from
+/// 30-day rolling history in SQL Server collect.* tables.
+///
+/// Port of Lite's BaselineProvider — uses SQL Server instead of DuckDB.
+/// No server_id filtering — Dashboard monitors one server per database.
+///
+/// Each baseline bucket contains mean, stddev, and sample count for a metric
+/// at a specific (hour, day-of-week) combination. When a bucket has insufficient
+/// samples, the provider collapses to less-specific tiers:
+///   Full (hour+dow) -> Hour-only -> Flat (global mean/stddev)
+///
+/// Baselines are cached in memory with a 1-hour TTL to avoid redundant
+/// recomputation during rapid re-analysis.
+/// </summary>
+public class SqlServerBaselineProvider
+{
+    private readonly string _connectionString;
+
+    /// <summary>Rolling window for baseline computation.</summary>
+    private const int BaselineWindowDays = 30;
+
+    /// <summary>Collapse to hour-only when full bucket has fewer than this many samples.</summary>
+    private const int CollapseThreshold = 10;
+
+    /// <summary>Restore to full bucket when sample count reaches this level (hysteresis).</summary>
+    private const int RestoreThreshold = 15;
+
+    /// <summary>Cache TTL — baselines are recomputed after this interval.</summary>
+    public static TimeSpan CacheTtl { get; set; } = TimeSpan.FromHours(1);
+
+    private readonly ConcurrentDictionary<string, CachedBaseline> _cache = new();
+
+    public SqlServerBaselineProvider(string connectionString)
+    {
+        _connectionString = connectionString;
+    }
+
+    /// <summary>
+    /// Gets the baseline for a specific metric and time bucket.
+    /// Returns the most specific bucket available, collapsing as needed.
+    /// </summary>
+    public async Task<BaselineBucket> GetBaselineAsync(string metricName, DateTime analysisTime)
+    {
+        var hourOfDay = analysisTime.Hour;
+        var dayOfWeek = (int)analysisTime.DayOfWeek; // Sunday=0
+
+        var baselines = await GetOrComputeBaselinesAsync(metricName, analysisTime);
+        if (baselines == null || baselines.Count == 0)
+            return BaselineBucket.Empty;
+
+        // Try full bucket (hour + day-of-week)
+        var fullKey = (hourOfDay, dayOfWeek);
+        if (baselines.TryGetValue(fullKey, out var fullBucket) && fullBucket.SampleCount >= RestoreThreshold)
+            return fullBucket;
+
+        // If full bucket exists but below restore threshold, check if it's above collapse threshold
+        // (hysteresis: don't collapse if we're between 10-14 samples and were previously using full)
+        if (fullBucket != null && fullBucket.SampleCount >= CollapseThreshold)
+            return fullBucket;
+
+        // Collapse to hour-only: aggregate all days for this hour
+        var hourBuckets = baselines
+            .Where(kvp => kvp.Key.HourOfDay == hourOfDay)
+            .Select(kvp => kvp.Value)
+            .ToList();
+
+        if (hourBuckets.Count > 0)
+        {
+            var collapsed = CollapseToHourOnly(hourBuckets);
+            if (collapsed.SampleCount >= CollapseThreshold)
+                return collapsed;
+        }
+
+        // Collapse to flat: aggregate everything
+        var allBuckets = baselines.Values.ToList();
+        if (allBuckets.Count > 0)
+        {
+            var flat = CollapseToFlat(allBuckets);
+            if (flat.SampleCount >= 3) // Minimum viable baseline
+                return flat;
+        }
+
+        return BaselineBucket.Empty;
+    }
+
+    /// <summary>
+    /// Gets all baseline buckets for a metric. Used by UI for rendering
+    /// expected-range bands across all time slots.
+    /// </summary>
+    public async Task<Dictionary<(int HourOfDay, int DayOfWeek), BaselineBucket>?> GetAllBaselinesAsync(
+        string metricName, DateTime analysisTime)
+    {
+        return await GetOrComputeBaselinesAsync(metricName, analysisTime);
+    }
+
+    /// <summary>Forces full cache clear — used during testing.</summary>
+    public void ClearCache() => _cache.Clear();
+
+    private async Task<Dictionary<(int HourOfDay, int DayOfWeek), BaselineBucket>?> GetOrComputeBaselinesAsync(
+        string metricName, DateTime analysisTime)
+    {
+        var cacheKey = metricName;
+        var roundedHour = new DateTime(analysisTime.Year, analysisTime.Month, analysisTime.Day, analysisTime.Hour, 0, 0);
+
+        if (_cache.TryGetValue(cacheKey, out var cached) &&
+            cached.ComputedAt == roundedHour &&
+            (DateTime.UtcNow - cached.RealTime) < CacheTtl)
+        {
+            return cached.Buckets;
+        }
+
+        var buckets = await ComputeBaselinesAsync(metricName, analysisTime);
+
+        _cache[cacheKey] = new CachedBaseline
+        {
+            ComputedAt = roundedHour,
+            RealTime = DateTime.UtcNow,
+            Buckets = buckets
+        };
+
+        return buckets;
+    }
+
+    private async Task<Dictionary<(int HourOfDay, int DayOfWeek), BaselineBucket>?> ComputeBaselinesAsync(
+        string metricName, DateTime analysisTime)
+    {
+        var query = GetBaselineQuery(metricName);
+        if (query == null) return null;
+
+        var windowStart = analysisTime.AddDays(-BaselineWindowDays);
+
+        try
+        {
+            using var connection = new SqlConnection(_connectionString);
+            await connection.OpenAsync();
+
+            using var cmd = connection.CreateCommand();
+            cmd.CommandText = query;
+            cmd.Parameters.Add(new SqlParameter("@windowStart", windowStart));
+            cmd.Parameters.Add(new SqlParameter("@windowEnd", analysisTime));
+
+            var buckets = new Dictionary<(int, int), BaselineBucket>();
+
+            using var reader = await cmd.ExecuteReaderAsync();
+            while (await reader.ReadAsync())
+            {
+                var hour = Convert.ToInt32(reader.GetValue(0));
+                var dow = Convert.ToInt32(reader.GetValue(1));
+                var mean = reader.IsDBNull(2) ? 0.0 : Convert.ToDouble(reader.GetValue(2));
+                var stddev = reader.IsDBNull(3) ? 0.0 : Convert.ToDouble(reader.GetValue(3));
+                var count = reader.IsDBNull(4) ? 0L : Convert.ToInt64(reader.GetValue(4));
+
+                buckets[(hour, dow)] = new BaselineBucket
+                {
+                    HourOfDay = hour,
+                    DayOfWeek = dow,
+                    Mean = mean,
+                    StdDev = stddev,
+                    SampleCount = count,
+                    Tier = count >= RestoreThreshold ? BaselineTier.Full
+                         : count >= CollapseThreshold ? BaselineTier.Full
+                         : BaselineTier.HourOnly
+                };
+            }
+
+            return buckets;
+        }
+        catch (Exception ex)
+        {
+            Logger.Error($"[SqlServerBaselineProvider] Failed to compute baselines for {metricName}: {ex.Message}");
+            return null;
+        }
+    }
+
+    private static string? GetBaselineQuery(string metricName)
+    {
+        // All queries return: hour_of_day, day_of_week, mean_val, stddev_val, sample_count
+        // Day-of-week normalization: (DATEPART(weekday, x) + @@DATEFIRST - 1) % 7 gives Sunday=0
+        // Cumulative metrics use CTEs for restart poisoning exclusion — exclude samples where
+        // value drops near-zero when the prior sample was significantly higher.
+        // SQL Server has no QUALIFY — use ROW_NUMBER() in CTEs instead.
+        return metricName switch
+        {
+            // Point-in-time metric — no restart exclusion needed
+            SqlServerMetricNames.Cpu => @"
+SET TRANSACTION ISOLATION LEVEL READ UNCOMMITTED;
+
+SELECT DATEPART(HOUR, collection_time) AS hour_of_day,
+       (DATEPART(WEEKDAY, collection_time) + @@DATEFIRST - 1) % 7 AS day_of_week,
+       AVG(CAST(sqlserver_cpu_utilization AS FLOAT)) AS mean_val,
+       STDEV(CAST(sqlserver_cpu_utilization AS FLOAT)) AS stddev_val,
+       COUNT(*) AS sample_count
+FROM collect.cpu_utilization_stats
+WHERE collection_time >= @windowStart AND collection_time < @windowEnd
+GROUP BY DATEPART(HOUR, collection_time),
+         (DATEPART(WEEKDAY, collection_time) + @@DATEFIRST - 1) % 7;",
+
+            // Cumulative counter — restart exclusion via CTE with LAG.
+            // server_start_time is inline in collect.perfmon_stats.
+            // Exclude samples within 5 min of a detected restart.
+            SqlServerMetricNames.BatchRequests => @"
+SET TRANSACTION ISOLATION LEVEL READ UNCOMMITTED;
+
+;WITH filtered AS (
+    SELECT collection_time, cntr_value_delta,
+           LAG(cntr_value_delta) OVER (ORDER BY collection_time) AS prev_value
+    FROM collect.perfmon_stats
+    WHERE collection_time >= @windowStart AND collection_time < @windowEnd
+    AND   counter_name = 'Batch Requests/sec'
+    AND   cntr_value_delta >= 0
+)
+SELECT DATEPART(HOUR, collection_time) AS hour_of_day,
+       (DATEPART(WEEKDAY, collection_time) + @@DATEFIRST - 1) % 7 AS day_of_week,
+       AVG(cntr_value_delta) AS mean_val,
+       STDEV(cntr_value_delta) AS stddev_val,
+       COUNT(*) AS sample_count
+FROM filtered
+WHERE NOT (cntr_value_delta = 0 AND ISNULL(prev_value, 0) > 1000)
+GROUP BY DATEPART(HOUR, collection_time),
+         (DATEPART(WEEKDAY, collection_time) + @@DATEFIRST - 1) % 7;",
+
+            // Cumulative counter, multiple rows per collection (per wait type) —
+            // aggregate to total wait ms per collection first, then filter restart poisoning
+            SqlServerMetricNames.WaitStats => @"
+SET TRANSACTION ISOLATION LEVEL READ UNCOMMITTED;
+
+;WITH per_collection AS (
+    SELECT collection_time,
+           SUM(wait_time_ms_delta) AS total_wait_ms
+    FROM collect.wait_stats
+    WHERE collection_time >= @windowStart AND collection_time < @windowEnd
+    AND   wait_time_ms_delta >= 0
+    GROUP BY collection_time
+),
+with_lag AS (
+    SELECT collection_time, total_wait_ms,
+           LAG(total_wait_ms) OVER (ORDER BY collection_time) AS prev_value
+    FROM per_collection
+)
+SELECT DATEPART(HOUR, collection_time) AS hour_of_day,
+       (DATEPART(WEEKDAY, collection_time) + @@DATEFIRST - 1) % 7 AS day_of_week,
+       AVG(CAST(total_wait_ms AS FLOAT)) AS mean_val,
+       STDEV(CAST(total_wait_ms AS FLOAT)) AS stddev_val,
+       COUNT(*) AS sample_count
+FROM with_lag
+WHERE NOT (total_wait_ms = 0 AND ISNULL(prev_value, 0) > 10000)
+GROUP BY DATEPART(HOUR, collection_time),
+         (DATEPART(WEEKDAY, collection_time) + @@DATEFIRST - 1) % 7;",
+
+            // Point-in-time, multiple rows per collection (per program_name) —
+            // aggregate to total connections per collection first.
+            // collect.session_stats does NOT have server_start_time — not needed.
+            SqlServerMetricNames.SessionCount => @"
+SET TRANSACTION ISOLATION LEVEL READ UNCOMMITTED;
+
+;WITH per_collection AS (
+    SELECT collection_time,
+           SUM(total_sessions) AS total_connections
+    FROM collect.session_stats
+    WHERE collection_time >= @windowStart AND collection_time < @windowEnd
+    GROUP BY collection_time
+)
+SELECT DATEPART(HOUR, collection_time) AS hour_of_day,
+       (DATEPART(WEEKDAY, collection_time) + @@DATEFIRST - 1) % 7 AS day_of_week,
+       AVG(CAST(total_connections AS FLOAT)) AS mean_val,
+       STDEV(CAST(total_connections AS FLOAT)) AS stddev_val,
+       COUNT(*) AS sample_count
+FROM per_collection
+GROUP BY DATEPART(HOUR, collection_time),
+         (DATEPART(WEEKDAY, collection_time) + @@DATEFIRST - 1) % 7;",
+
+            // Cumulative (plan cache), multiple rows per collection (per query) —
+            // use delta columns, aggregate total elapsed per collection, filter restart poisoning.
+            // server_start_time is inline in collect.query_stats.
+            SqlServerMetricNames.QueryDuration => @"
+SET TRANSACTION ISOLATION LEVEL READ UNCOMMITTED;
+
+;WITH per_collection AS (
+    SELECT collection_time,
+           SUM(total_elapsed_time_delta) AS total_elapsed
+    FROM collect.query_stats
+    WHERE collection_time >= @windowStart AND collection_time < @windowEnd
+    AND   execution_count_delta > 0
+    AND   total_elapsed_time_delta >= 0
+    GROUP BY collection_time
+),
+with_lag AS (
+    SELECT collection_time, total_elapsed,
+           LAG(total_elapsed) OVER (ORDER BY collection_time) AS prev_value
+    FROM per_collection
+)
+SELECT DATEPART(HOUR, collection_time) AS hour_of_day,
+       (DATEPART(WEEKDAY, collection_time) + @@DATEFIRST - 1) % 7 AS day_of_week,
+       AVG(CAST(total_elapsed AS FLOAT)) AS mean_val,
+       STDEV(CAST(total_elapsed AS FLOAT)) AS stddev_val,
+       COUNT(*) AS sample_count
+FROM with_lag
+WHERE NOT (total_elapsed = 0 AND ISNULL(prev_value, 0) > 100000)
+GROUP BY DATEPART(HOUR, collection_time),
+         (DATEPART(WEEKDAY, collection_time) + @@DATEFIRST - 1) % 7;",
+
+            // Point-in-time metric — no restart exclusion needed
+            SqlServerMetricNames.IoLatency => @"
+SET TRANSACTION ISOLATION LEVEL READ UNCOMMITTED;
+
+SELECT DATEPART(HOUR, collection_time) AS hour_of_day,
+       (DATEPART(WEEKDAY, collection_time) + @@DATEFIRST - 1) % 7 AS day_of_week,
+       AVG(io_stall_read_ms_delta * 1.0 / NULLIF(num_of_reads_delta, 0)) AS mean_val,
+       STDEV(io_stall_read_ms_delta * 1.0 / NULLIF(num_of_reads_delta, 0)) AS stddev_val,
+       COUNT(*) AS sample_count
+FROM collect.file_io_stats
+WHERE collection_time >= @windowStart AND collection_time < @windowEnd
+AND   (num_of_reads_delta > 0 OR num_of_writes_delta > 0)
+GROUP BY DATEPART(HOUR, collection_time),
+         (DATEPART(WEEKDAY, collection_time) + @@DATEFIRST - 1) % 7;",
+
+            // Event-based — use wait_stats collection intervals as time spine (bucketed to minute),
+            // LEFT JOIN event counts so intervals with zero events are included in the baseline.
+            // Without this, the baseline only reflects storm periods (when events exist).
+            SqlServerMetricNames.Blocking => @"
+SET TRANSACTION ISOLATION LEVEL READ UNCOMMITTED;
+
+;WITH spine AS (
+    SELECT DISTINCT DATEADD(MINUTE, DATEDIFF(MINUTE, 0, collection_time), 0) AS minute_bucket
+    FROM collect.wait_stats
+    WHERE collection_time >= @windowStart AND collection_time < @windowEnd
+),
+event_counts AS (
+    SELECT DATEADD(MINUTE, DATEDIFF(MINUTE, 0, collection_time), 0) AS minute_bucket,
+           CAST(COUNT(*) AS FLOAT) AS cnt
+    FROM collect.blocking_BlockedProcessReport
+    WHERE collection_time >= @windowStart AND collection_time < @windowEnd
+    GROUP BY DATEADD(MINUTE, DATEDIFF(MINUTE, 0, collection_time), 0)
+),
+per_interval AS (
+    SELECT s.minute_bucket, ISNULL(e.cnt, 0) AS event_count
+    FROM spine s
+    LEFT JOIN event_counts e ON s.minute_bucket = e.minute_bucket
+)
+SELECT DATEPART(HOUR, minute_bucket) AS hour_of_day,
+       (DATEPART(WEEKDAY, minute_bucket) + @@DATEFIRST - 1) % 7 AS day_of_week,
+       AVG(event_count) AS mean_val,
+       STDEV(event_count) AS stddev_val,
+       COUNT(*) AS sample_count
+FROM per_interval
+GROUP BY DATEPART(HOUR, minute_bucket),
+         (DATEPART(WEEKDAY, minute_bucket) + @@DATEFIRST - 1) % 7;",
+
+            // Event-based — same spine approach as blocking
+            SqlServerMetricNames.Deadlock => @"
+SET TRANSACTION ISOLATION LEVEL READ UNCOMMITTED;
+
+;WITH spine AS (
+    SELECT DISTINCT DATEADD(MINUTE, DATEDIFF(MINUTE, 0, collection_time), 0) AS minute_bucket
+    FROM collect.wait_stats
+    WHERE collection_time >= @windowStart AND collection_time < @windowEnd
+),
+event_counts AS (
+    SELECT DATEADD(MINUTE, DATEDIFF(MINUTE, 0, collection_time), 0) AS minute_bucket,
+           CAST(COUNT(*) AS FLOAT) AS cnt
+    FROM collect.deadlocks
+    WHERE collection_time >= @windowStart AND collection_time < @windowEnd
+    GROUP BY DATEADD(MINUTE, DATEDIFF(MINUTE, 0, collection_time), 0)
+),
+per_interval AS (
+    SELECT s.minute_bucket, ISNULL(e.cnt, 0) AS event_count
+    FROM spine s
+    LEFT JOIN event_counts e ON s.minute_bucket = e.minute_bucket
+)
+SELECT DATEPART(HOUR, minute_bucket) AS hour_of_day,
+       (DATEPART(WEEKDAY, minute_bucket) + @@DATEFIRST - 1) % 7 AS day_of_week,
+       AVG(event_count) AS mean_val,
+       STDEV(event_count) AS stddev_val,
+       COUNT(*) AS sample_count
+FROM per_interval
+GROUP BY DATEPART(HOUR, minute_bucket),
+         (DATEPART(WEEKDAY, minute_bucket) + @@DATEFIRST - 1) % 7;",
+
+            _ => null
+        };
+    }
+
+    /// <summary>
+    /// Collapses multiple day-of-week buckets for the same hour into a single
+    /// hour-only bucket using pooled statistics.
+    /// </summary>
+    private static BaselineBucket CollapseToHourOnly(List<BaselineBucket> hourBuckets)
+    {
+        var totalSamples = hourBuckets.Sum(b => b.SampleCount);
+        if (totalSamples == 0)
+            return BaselineBucket.Empty;
+
+        // Weighted mean across all day-of-week buckets for this hour
+        var weightedMean = hourBuckets.Sum(b => b.Mean * b.SampleCount) / totalSamples;
+
+        // Pooled standard deviation
+        var pooledVariance = PoolVariance(hourBuckets, weightedMean);
+
+        return new BaselineBucket
+        {
+            HourOfDay = hourBuckets[0].HourOfDay,
+            DayOfWeek = -1, // Indicates hour-only
+            Mean = weightedMean,
+            StdDev = Math.Sqrt(pooledVariance),
+            SampleCount = totalSamples,
+            Tier = BaselineTier.HourOnly
+        };
+    }
+
+    /// <summary>
+    /// Collapses all buckets into a single flat baseline (equivalent to old 24h behavior).
+    /// </summary>
+    private static BaselineBucket CollapseToFlat(List<BaselineBucket> allBuckets)
+    {
+        var totalSamples = allBuckets.Sum(b => b.SampleCount);
+        if (totalSamples == 0)
+            return BaselineBucket.Empty;
+
+        var weightedMean = allBuckets.Sum(b => b.Mean * b.SampleCount) / totalSamples;
+        var pooledVariance = PoolVariance(allBuckets, weightedMean);
+
+        return new BaselineBucket
+        {
+            HourOfDay = -1,
+            DayOfWeek = -1,
+            Mean = weightedMean,
+            StdDev = Math.Sqrt(pooledVariance),
+            SampleCount = totalSamples,
+            Tier = BaselineTier.Flat
+        };
+    }
+
+    /// <summary>
+    /// Computes pooled variance from multiple buckets, accounting for both
+    /// within-bucket variance and between-bucket mean differences.
+    /// </summary>
+    private static double PoolVariance(List<BaselineBucket> buckets, double grandMean)
+    {
+        var totalSamples = buckets.Sum(b => b.SampleCount);
+        if (totalSamples <= 1) return 0;
+
+        double totalSumSq = 0;
+        foreach (var b in buckets)
+        {
+            if (b.SampleCount <= 0) continue;
+            // Within-bucket variance contribution
+            totalSumSq += (b.StdDev * b.StdDev) * (b.SampleCount - 1);
+            // Between-bucket mean difference contribution
+            totalSumSq += b.SampleCount * (b.Mean - grandMean) * (b.Mean - grandMean);
+        }
+
+        return totalSumSq / (totalSamples - 1);
+    }
+
+    private class CachedBaseline
+    {
+        public DateTime ComputedAt { get; init; }
+        public DateTime RealTime { get; init; }
+        public Dictionary<(int HourOfDay, int DayOfWeek), BaselineBucket>? Buckets { get; init; }
+    }
+}
+
+/// <summary>
+/// Represents the computed baseline statistics for a single time bucket.
+/// </summary>
+public class BaselineBucket
+{
+    public int HourOfDay { get; init; }
+    public int DayOfWeek { get; init; }
+    public double Mean { get; init; }
+    public double StdDev { get; init; }
+    public long SampleCount { get; init; }
+    public BaselineTier Tier { get; init; }
+
+    public static BaselineBucket Empty => new()
+    {
+        HourOfDay = -1, DayOfWeek = -1, Mean = 0, StdDev = 0,
+        SampleCount = 0, Tier = BaselineTier.Flat
+    };
+
+    /// <summary>
+    /// Returns the effective stddev with a proportional minimum floor to prevent
+    /// division-by-zero in z-score calculations. When both mean and stddev are 0
+    /// (zero activity), returns 0 — callers should skip scoring.
+    /// </summary>
+    public double EffectiveStdDev
+    {
+        get
+        {
+            if (Mean == 0 && StdDev <= 0) return 0; // Zero activity — skip scoring
+            return Math.Max(StdDev, Mean * 0.01);
+        }
+    }
+}
+
+public enum BaselineTier
+{
+    Full,     // hour + day-of-week (168 buckets)
+    HourOnly, // hour only (24 buckets)
+    Flat      // global mean/stddev
+}
+
+/// <summary>Metric name constants used as baseline cache keys.</summary>
+public static class SqlServerMetricNames
+{
+    public const string Cpu = "cpu";
+    public const string BatchRequests = "batch_requests";
+    public const string WaitStats = "wait_stats";
+    public const string SessionCount = "session_count";
+    public const string QueryDuration = "query_duration";
+    public const string IoLatency = "io_latency";
+    public const string Blocking = "blocking";
+    public const string Deadlock = "deadlock";
+}
diff --git a/Dashboard/Controls/CorrelatedTimelineLanesControl.xaml b/Dashboard/Controls/CorrelatedTimelineLanesControl.xaml
index 46b6815..0d58d36 100644
--- a/Dashboard/Controls/CorrelatedTimelineLanesControl.xaml
+++ b/Dashboard/Controls/CorrelatedTimelineLanesControl.xaml
@@ -18,15 +18,11 @@
             <Grid.ColumnDefinitions>
                 <ColumnDefinition Width="100"/>
                 <ColumnDefinition Width="*"/>
-                <ColumnDefinition Width="80"/>
             </Grid.ColumnDefinitions>
             <TextBlock Grid.Column="0" Text="CPU %" VerticalAlignment="Center"
                        FontSize="12" FontWeight="SemiBold"
                        Foreground="{DynamicResource ForegroundBrush}" Margin="4,0"/>
             <ScottPlot:WpfPlot Grid.Column="1" x:Name="CpuChart"/>
-            <TextBlock Grid.Column="2" x:Name="CpuValueLabel" VerticalAlignment="Center"
-                       HorizontalAlignment="Right" FontSize="11"
-                       Foreground="{DynamicResource ForegroundBrush}" Margin="4,0"/>
         </Grid>
 
         <!-- Lane 2: Wait Stats -->
@@ -34,15 +30,11 @@
             <Grid.ColumnDefinitions>
                 <ColumnDefinition Width="100"/>
                 <ColumnDefinition Width="*"/>
-                <ColumnDefinition Width="80"/>
             </Grid.ColumnDefinitions>
             <TextBlock Grid.Column="0" Text="Wait ms/sec" VerticalAlignment="Center"
                        FontSize="12" FontWeight="SemiBold"
                        Foreground="{DynamicResource ForegroundBrush}" Margin="4,0"/>
             <ScottPlot:WpfPlot Grid.Column="1" x:Name="WaitStatsChart"/>
-            <TextBlock Grid.Column="2" x:Name="WaitStatsValueLabel" VerticalAlignment="Center"
-                       HorizontalAlignment="Right" FontSize="11"
-                       Foreground="{DynamicResource ForegroundBrush}" Margin="4,0"/>
         </Grid>
 
         <!-- Lane 3: Blocking -->
@@ -50,7 +42,6 @@
             <Grid.ColumnDefinitions>
                 <ColumnDefinition Width="100"/>
                 <ColumnDefinition Width="*"/>
-                <ColumnDefinition Width="80"/>
             </Grid.ColumnDefinitions>
             <TextBlock Grid.Column="0" VerticalAlignment="Center"
                        FontSize="12" FontWeight="SemiBold"
@@ -60,25 +51,18 @@
                 <Run Text="Deadlocking"/>
             </TextBlock>
             <ScottPlot:WpfPlot Grid.Column="1" x:Name="BlockingChart"/>
-            <TextBlock Grid.Column="2" x:Name="BlockingValueLabel" VerticalAlignment="Center"
-                       HorizontalAlignment="Right" FontSize="11"
-                       Foreground="{DynamicResource ForegroundBrush}" Margin="4,0"/>
         </Grid>
 
-        <!-- Lane 4: Memory -->
+        <!-- Lane 4: Buffer Pool -->
         <Grid Grid.Row="3" Margin="0,2,0,2">
             <Grid.ColumnDefinitions>
                 <ColumnDefinition Width="100"/>
                 <ColumnDefinition Width="*"/>
-                <ColumnDefinition Width="80"/>
             </Grid.ColumnDefinitions>
-            <TextBlock Grid.Column="0" Text="Memory MB" VerticalAlignment="Center"
+            <TextBlock Grid.Column="0" Text="Buffer Pool MB" VerticalAlignment="Center"
                        FontSize="12" FontWeight="SemiBold"
                        Foreground="{DynamicResource ForegroundBrush}" Margin="4,0"/>
             <ScottPlot:WpfPlot Grid.Column="1" x:Name="MemoryChart"/>
-            <TextBlock Grid.Column="2" x:Name="MemoryValueLabel" VerticalAlignment="Center"
-                       HorizontalAlignment="Right" FontSize="11"
-                       Foreground="{DynamicResource ForegroundBrush}" Margin="4,0"/>
         </Grid>
 
         <!-- Lane 5: File I/O -->
@@ -86,15 +70,11 @@
             <Grid.ColumnDefinitions>
                 <ColumnDefinition Width="100"/>
                 <ColumnDefinition Width="*"/>
-                <ColumnDefinition Width="80"/>
             </Grid.ColumnDefinitions>
             <TextBlock Grid.Column="0" Text="I/O Latency" VerticalAlignment="Center"
                        FontSize="12" FontWeight="SemiBold"
                        Foreground="{DynamicResource ForegroundBrush}" Margin="4,0"/>
             <ScottPlot:WpfPlot Grid.Column="1" x:Name="FileIoChart"/>
-            <TextBlock Grid.Column="2" x:Name="FileIoValueLabel" VerticalAlignment="Center"
-                       HorizontalAlignment="Right" FontSize="11"
-                       Foreground="{DynamicResource ForegroundBrush}" Margin="4,0"/>
         </Grid>
     </Grid>
 </UserControl>
diff --git a/Dashboard/Controls/CorrelatedTimelineLanesControl.xaml.cs b/Dashboard/Controls/CorrelatedTimelineLanesControl.xaml.cs
index 94aa429..9af24f3 100644
--- a/Dashboard/Controls/CorrelatedTimelineLanesControl.xaml.cs
+++ b/Dashboard/Controls/CorrelatedTimelineLanesControl.xaml.cs
@@ -16,6 +16,7 @@
 using System.Threading.Tasks;
 using System.Windows;
 using System.Windows.Controls;
+using PerformanceMonitorDashboard.Analysis;
 using PerformanceMonitorDashboard.Helpers;
 using PerformanceMonitorDashboard.Services;
 
@@ -24,6 +25,7 @@ namespace PerformanceMonitorDashboard.Controls;
 public partial class CorrelatedTimelineLanesControl : UserControl
 {
     private DatabaseService? _dataService;
+    private SqlServerBaselineProvider? _baselineProvider;
     private CorrelatedCrosshairManager? _crosshairManager;
     private bool _isRefreshing;
 
@@ -34,12 +36,13 @@ public CorrelatedTimelineLanesControl()
     }
 
     /// <summary>
-    /// Initializes the control with the data service.
+    /// Initializes the control with the data service and optional baseline provider.
     /// Must be called before RefreshAsync.
     /// </summary>
-    public void Initialize(DatabaseService dataService)
+    public void Initialize(DatabaseService dataService, SqlServerBaselineProvider? baselineProvider = null)
     {
         _dataService = dataService;
+        _baselineProvider = baselineProvider;
 
         var charts = new[] { CpuChart, WaitStatsChart, BlockingChart, MemoryChart, FileIoChart };
         foreach (var chart in charts)
@@ -50,17 +53,18 @@ public void Initialize(DatabaseService dataService)
         }
 
         _crosshairManager = new CorrelatedCrosshairManager();
-        _crosshairManager.AddLane(CpuChart, "CPU", "%", CpuValueLabel);
-        _crosshairManager.AddLane(WaitStatsChart, "Wait Stats", "ms/sec", WaitStatsValueLabel);
-        _crosshairManager.AddLane(BlockingChart, "Blocking", "events", BlockingValueLabel);
-        _crosshairManager.AddLane(MemoryChart, "Memory", "MB", MemoryValueLabel);
-        _crosshairManager.AddLane(FileIoChart, "I/O Latency", "ms", FileIoValueLabel);
+        _crosshairManager.AddLane(CpuChart, "CPU", "%");
+        _crosshairManager.AddLane(WaitStatsChart, "Wait Stats", "ms/sec");
+        _crosshairManager.AddLane(BlockingChart, "Blocking", "events");
+        _crosshairManager.AddLane(MemoryChart, "Buffer Pool", "MB");
+        _crosshairManager.AddLane(FileIoChart, "I/O Latency", "ms");
     }
 
     /// <summary>
     /// Refreshes all lane data for the given time range.
     /// </summary>
-    public async Task RefreshAsync(int hoursBack, DateTime? fromDate, DateTime? toDate)
+    public async Task RefreshAsync(int hoursBack, DateTime? fromDate, DateTime? toDate,
+        (DateTime From, DateTime To)? comparisonRange = null)
     {
         if (_dataService == null || _isRefreshing) return;
         _isRefreshing = true;
@@ -76,26 +80,59 @@ public async Task RefreshAsync(int hoursBack, DateTime? fromDate, DateTime? toDa
             var memoryTask = _dataService.GetMemoryStatsAsync(hoursBack, fromDate, toDate);
             var fileIoTask = _dataService.GetFileIoLatencyTimeSeriesAsync(false, hoursBack, fromDate, toDate);
 
+            // Fetch baselines for band rendering if provider is available
+            var referenceTime = fromDate ?? DateTime.UtcNow.AddHours(-hoursBack);
+            Task<BaselineBucket?>? cpuBaselineTask = null;
+            Task<BaselineBucket?>? waitBaselineTask = null;
+            Task<BaselineBucket?>? ioBaselineTask = null;
+            Task<BaselineBucket?>? blockingBaselineTask = null;
+            Task<BaselineBucket?>? deadlockBaselineTask = null;
+
+            if (_baselineProvider != null)
+            {
+                cpuBaselineTask = GetBaselineAsync(SqlServerMetricNames.Cpu, referenceTime);
+                waitBaselineTask = GetBaselineAsync(SqlServerMetricNames.WaitStats, referenceTime);
+                ioBaselineTask = GetBaselineAsync(SqlServerMetricNames.IoLatency, referenceTime);
+                blockingBaselineTask = GetBaselineAsync(SqlServerMetricNames.Blocking, referenceTime);
+                deadlockBaselineTask = GetBaselineAsync(SqlServerMetricNames.Deadlock, referenceTime);
+            }
+
             try
             {
-                await Task.WhenAll(cpuTask, waitTask, blockingTask, deadlockTask, memoryTask, fileIoTask);
+                var tasks = new List<Task> { cpuTask, waitTask, blockingTask, deadlockTask, memoryTask, fileIoTask };
+                if (cpuBaselineTask != null) tasks.Add(cpuBaselineTask);
+                if (waitBaselineTask != null) tasks.Add(waitBaselineTask);
+                if (ioBaselineTask != null) tasks.Add(ioBaselineTask);
+                if (blockingBaselineTask != null) tasks.Add(blockingBaselineTask);
+                if (deadlockBaselineTask != null) tasks.Add(deadlockBaselineTask);
+                await Task.WhenAll(tasks);
             }
             catch (Exception ex)
             {
                 Debug.WriteLine($"CorrelatedLanes: Data fetch failed: {ex.Message}");
             }
 
+            var cpuBaseline = cpuBaselineTask is { IsCompletedSuccessfully: true } ? cpuBaselineTask.Result : null;
+            var waitBaseline = waitBaselineTask is { IsCompletedSuccessfully: true } ? waitBaselineTask.Result : null;
+            var ioBaseline = ioBaselineTask is { IsCompletedSuccessfully: true } ? ioBaselineTask.Result : null;
+            var blockingBaseline = blockingBaselineTask is { IsCompletedSuccessfully: true } ? blockingBaselineTask.Result : null;
+            var deadlockBaseline = deadlockBaselineTask is { IsCompletedSuccessfully: true } ? deadlockBaselineTask.Result : null;
+            var blockingLaneBaseline = blockingBaseline ?? deadlockBaseline;
+
+            // minAnomalyValue: absolute floor below which dots/arrows are suppressed even if outside band.
+            // Prevents "1% CPU above 0.5% baseline" false alarms on idle servers.
             if (cpuTask.IsCompletedSuccessfully)
                 UpdateLane(CpuChart, "CPU %",
-                    cpuTask.Result.Select(d => (d.SampleTime.ToOADate(), (double)d.SqlServerCpuUtilization)).ToList(),
-                    "#4FC3F7", 0, 105);
+                    cpuTask.Result.OrderBy(d => d.SampleTime)
+                        .Select(d => (d.SampleTime.ToOADate(), (double)d.SqlServerCpuUtilization)).ToList(),
+                    "#4FC3F7", 0, 105, cpuBaseline, minAnomalyValue: 10);
             else
                 ShowEmpty(CpuChart, "CPU %");
 
             if (waitTask.IsCompletedSuccessfully)
                 UpdateLane(WaitStatsChart, "Wait ms/sec",
                     waitTask.Result.Select(d => (d.CollectionTime.ToOADate(), (double)d.WaitTimeMsPerSecond)).ToList(),
-                    "#FFB74D");
+                    "#FFB74D", baseline: waitBaseline, minAnomalyValue: 100);
             else
                 ShowEmpty(WaitStatsChart, "Wait ms/sec");
 
@@ -113,7 +150,7 @@ public async Task RefreshAsync(int hoursBack, DateTime? fromDate, DateTime? toDa
                         .Select(d => (d.CollectionTime.ToOADate(), (double)d.BlockedCount))
                         .ToList()
                     : new List<(double, double)>();
-                UpdateBlockingLane(blockingData, deadlockData);
+                UpdateBlockingLane(blockingData, deadlockData, blockingLaneBaseline);
             }
             catch (Exception ex)
             {
@@ -122,11 +159,11 @@ public async Task RefreshAsync(int hoursBack, DateTime? fromDate, DateTime? toDa
             }
 
             if (memoryTask.IsCompletedSuccessfully)
-                UpdateLane(MemoryChart, "Memory MB",
+                UpdateLane(MemoryChart, "Buffer Pool MB",
                     memoryTask.Result.Select(d => (d.CollectionTime.ToOADate(), (double)d.TotalMemoryMb)).ToList(),
                     "#CE93D8");
             else
-                ShowEmpty(MemoryChart, "Memory MB");
+                ShowEmpty(MemoryChart, "Buffer Pool MB");
 
             if (fileIoTask.IsCompletedSuccessfully)
             {
@@ -135,11 +172,63 @@ public async Task RefreshAsync(int hoursBack, DateTime? fromDate, DateTime? toDa
                     .OrderBy(g => g.Key)
                     .Select(g => (g.Key.ToOADate(), (double)g.Average(x => x.ReadLatencyMs)))
                     .ToList();
-                UpdateLane(FileIoChart, "I/O ms", ioGrouped, "#81C784");
+                UpdateLane(FileIoChart, "I/O ms", ioGrouped, "#81C784", baseline: ioBaseline, minAnomalyValue: 2);
             }
             else
                 ShowEmpty(FileIoChart, "I/O ms");
 
+            // Comparison overlay — fetch reference period data and render as ghost lines
+            if (comparisonRange.HasValue)
+            {
+                var refFrom = comparisonRange.Value.From;
+                var refTo = comparisonRange.Value.To;
+                var timeShift = (fromDate ?? DateTime.UtcNow.AddHours(-hoursBack)) - refFrom;
+
+                var refCpuTask = _dataService.GetCpuUtilizationAsync(0, refFrom, refTo);
+                var refWaitTask = _dataService.GetTotalWaitStatsTrendAsync(0, refFrom, refTo);
+                var refBlockingTask = _dataService.GetBlockedSessionTrendAsync(0, refFrom, refTo);
+                var refMemoryTask = _dataService.GetMemoryStatsAsync(0, refFrom, refTo);
+                var refIoTask = _dataService.GetFileIoLatencyTimeSeriesAsync(false, 0, refFrom, refTo);
+
+                try { await Task.WhenAll(refCpuTask, refWaitTask, refBlockingTask, refMemoryTask, refIoTask); }
+                catch (Exception ex) { Debug.WriteLine($"CorrelatedLanes: Comparison fetch failed: {ex.Message}"); }
+
+                if (refCpuTask.IsCompletedSuccessfully)
+                    AddGhostLine(CpuChart, refCpuTask.Result
+                        .Select(d => (d.SampleTime.Add(timeShift).ToOADate(), (double)d.SqlServerCpuUtilization)).ToList(), "#4FC3F7");
+
+                if (refWaitTask.IsCompletedSuccessfully)
+                    AddGhostLine(WaitStatsChart, refWaitTask.Result
+                        .Select(d => (d.CollectionTime.Add(timeShift).ToOADate(), (double)d.WaitTimeMsPerSecond)).ToList(), "#FFB74D");
+
+                if (refBlockingTask.IsCompletedSuccessfully)
+                {
+                    var refBlocking = refBlockingTask.Result
+                        .GroupBy(d => d.CollectionTime)
+                        .OrderBy(g => g.Key)
+                        .Select(g => (g.Key.Add(timeShift).ToOADate(), (double)g.Sum(x => x.BlockedCount)))
+                        .ToList();
+                    if (refBlocking.Count > 0)
+                        AddGhostLine(BlockingChart, refBlocking, "#E57373");
+                }
+
+                if (refMemoryTask.IsCompletedSuccessfully)
+                    AddGhostLine(MemoryChart, refMemoryTask.Result
+                        .Select(d => (d.CollectionTime.Add(timeShift).ToOADate(), (double)d.TotalMemoryMb)).ToList(), "#CE93D8");
+
+                if (refIoTask.IsCompletedSuccessfully)
+                {
+                    var refIo = refIoTask.Result
+                        .GroupBy(d => d.CollectionTime)
+                        .OrderBy(g => g.Key)
+                        .Select(g => (g.Key.Add(timeShift).ToOADate(), (double)g.Average(x => x.ReadLatencyMs)))
+                        .ToList();
+                    AddGhostLine(FileIoChart, refIo, "#81C784");
+                }
+
+                _crosshairManager?.SetComparisonLabel(ComparisonLabel(comparisonRange.Value, fromDate, hoursBack));
+            }
+
             _crosshairManager?.ReattachVLines();
             SyncXAxes(hoursBack, fromDate, toDate);
         }
@@ -149,21 +238,32 @@ public async Task RefreshAsync(int hoursBack, DateTime? fromDate, DateTime? toDa
         }
     }
 
+    /// <summary>
+    /// Fetches a baseline bucket from the provider, wrapping in a nullable task.
+    /// </summary>
+    private async Task<BaselineBucket?> GetBaselineAsync(string metricName, DateTime referenceTime)
+    {
+        if (_baselineProvider == null) return null;
+        try
+        {
+            var bucket = await _baselineProvider.GetBaselineAsync(metricName, referenceTime);
+            return bucket.SampleCount > 0 ? bucket : null;
+        }
+        catch { return null; }
+    }
+
     private void UpdateBlockingLane(List<(double Time, double Value)> blockingData,
-        List<(double Time, double Value)> deadlockData)
+        List<(double Time, double Value)> deadlockData, BaselineBucket? baseline = null)
     {
         ClearChart(BlockingChart);
         TabHelpers.ApplyThemeToChart(BlockingChart);
 
-        // Register blocking and deadlock as separate named series for the tooltip
         var blockTimes = blockingData.Select(d => d.Time).ToArray();
         var blockValues = blockingData.Select(d => d.Value).ToArray();
         var deadTimes = deadlockData.Select(d => d.Time).ToArray();
         var deadValues = deadlockData.Select(d => d.Value).ToArray();
 
-        // First series clears any previous data
         _crosshairManager?.SetLaneData(BlockingChart, blockTimes, blockValues, isEventBased: true);
-        // Rename the auto-created series and add the second
         _crosshairManager?.AddLaneSeries(BlockingChart, "Deadlocks", "events",
             deadTimes, deadValues, isEventBased: true);
 
@@ -176,7 +276,6 @@ private void UpdateBlockingLane(List<(double Time, double Value)> blockingData,
         double barWidth = 30.0 / 86400.0;
         double maxCount = 0;
 
-        // Blocking bars — red
         if (blockingData.Count > 0)
         {
             var bars = blockingData.Select(d => new ScottPlot.Bar
@@ -191,7 +290,6 @@ private void UpdateBlockingLane(List<(double Time, double Value)> blockingData,
             maxCount = Math.Max(maxCount, blockingData.Max(d => d.Value));
         }
 
-        // Deadlock bars — yellow/amber, slightly narrower so both are visible
         if (deadlockData.Count > 0)
         {
             var bars = deadlockData.Select(d => new ScottPlot.Bar
@@ -206,6 +304,31 @@ private void UpdateBlockingLane(List<(double Time, double Value)> blockingData,
             maxCount = Math.Max(maxCount, deadlockData.Max(d => d.Value));
         }
 
+        // Baseline for blocking — event-based metrics where zero is normal.
+        // Even if EffectiveStdDev is 0 (all-zero baseline), still register the baseline
+        // so the event-based indicator check (mean < 1 → any event is ▲) works.
+        if (baseline != null && baseline.SampleCount > 0)
+        {
+            var effectiveStdDev = Math.Max(baseline.EffectiveStdDev, 0.01);
+            var upper = baseline.Mean + 2 * effectiveStdDev;
+            var lower = Math.Max(0, baseline.Mean - 2 * effectiveStdDev);
+
+            _crosshairManager?.SetLaneBaseline(BlockingChart, lower, upper, isEventBased: true);
+
+            // Only render the visual band if there's meaningful variance
+            if (baseline.EffectiveStdDev > 0)
+            {
+                var band = BlockingChart.Plot.Add.HorizontalSpan(lower, upper);
+                band.FillStyle.Color = ScottPlot.Color.FromHex("#E57373").WithAlpha(25);
+                band.LineStyle.Width = 0;
+
+                var meanLine = BlockingChart.Plot.Add.HorizontalLine(baseline.Mean);
+                meanLine.Color = ScottPlot.Color.FromHex("#E57373").WithAlpha(60);
+                meanLine.LinePattern = ScottPlot.LinePattern.Dashed;
+                meanLine.LineWidth = 1;
+            }
+        }
+
         BlockingChart.Plot.Axes.DateTimeTicksBottom();
         BlockingChart.Plot.Axes.Bottom.TickLabelStyle.IsVisible = false;
         TabHelpers.ReapplyAxisColors(BlockingChart);
@@ -215,13 +338,12 @@ private void UpdateBlockingLane(List<(double Time, double Value)> blockingData,
         BlockingChart.Plot.Legend.IsVisible = false;
         BlockingChart.Plot.Axes.Margins(bottom: 0);
         BlockingChart.Plot.Axes.SetLimitsY(0, Math.Max(maxCount * 1.3, 2));
-
-        BlockingChart.Refresh();
     }
 
     private void UpdateLane(ScottPlot.WPF.WpfPlot chart, string title,
         List<(double Time, double Value)> data, string colorHex,
-        double? yMin = null, double? yMax = null)
+        double? yMin = null, double? yMax = null, BaselineBucket? baseline = null,
+        double minAnomalyValue = 0)
     {
         ClearChart(chart);
         TabHelpers.ApplyThemeToChart(chart);
@@ -235,6 +357,43 @@ private void UpdateLane(ScottPlot.WPF.WpfPlot chart, string title,
         var times = data.Select(d => d.Time).ToArray();
         var values = data.Select(d => d.Value).ToArray();
 
+        // Render baseline band FIRST (behind the data line)
+        if (baseline != null && baseline.SampleCount > 0 && baseline.EffectiveStdDev > 0)
+        {
+            var upper = baseline.Mean + 2 * baseline.EffectiveStdDev;
+            var lower = Math.Max(0, baseline.Mean - 2 * baseline.EffectiveStdDev);
+
+            _crosshairManager?.SetLaneBaseline(chart, lower, upper, minAnomalyValue);
+
+            var band = chart.Plot.Add.HorizontalSpan(lower, upper);
+            band.FillStyle.Color = ScottPlot.Color.FromHex(colorHex).WithAlpha(25);
+            band.LineStyle.Width = 0;
+
+            var meanLine = chart.Plot.Add.HorizontalLine(baseline.Mean);
+            meanLine.Color = ScottPlot.Color.FromHex(colorHex).WithAlpha(60);
+            meanLine.LinePattern = ScottPlot.LinePattern.Dashed;
+            meanLine.LineWidth = 1;
+
+            // Highlight anomalous points (outside ± 2σ band AND above absolute minimum)
+            var anomalyIndices = new List<int>();
+            for (int i = 0; i < values.Length; i++)
+            {
+                if ((values[i] > upper && values[i] >= minAnomalyValue) || values[i] < lower)
+                    anomalyIndices.Add(i);
+            }
+
+            if (anomalyIndices.Count > 0)
+            {
+                var anomalyTimes = anomalyIndices.Select(i => times[i]).ToArray();
+                var anomalyValues = anomalyIndices.Select(i => values[i]).ToArray();
+                var anomalyScatter = chart.Plot.Add.Scatter(anomalyTimes, anomalyValues);
+                anomalyScatter.Color = ScottPlot.Color.FromHex("#FF5252");
+                anomalyScatter.MarkerSize = 6;
+                anomalyScatter.MarkerShape = ScottPlot.MarkerShape.FilledCircle;
+                anomalyScatter.LineWidth = 0;
+            }
+        }
+
         var scatter = chart.Plot.Add.Scatter(times, values);
         scatter.Color = ScottPlot.Color.FromHex(colorHex);
         scatter.MarkerSize = 0;
@@ -245,13 +404,11 @@ private void UpdateLane(ScottPlot.WPF.WpfPlot chart, string title,
         _crosshairManager?.SetLaneData(chart, times, values);
 
         chart.Plot.Axes.DateTimeTicksBottom();
-        // Hide bottom tick labels on all lanes except the last (File I/O)
         if (chart != FileIoChart)
             chart.Plot.Axes.Bottom.TickLabelStyle.IsVisible = false;
 
         TabHelpers.ReapplyAxisColors(chart);
 
-        // Compact layout: hide Y label, minimize title, no legend
         chart.Plot.Title("");
         chart.Plot.YLabel("");
         chart.Plot.Legend.IsVisible = false;
@@ -266,13 +423,8 @@ private void UpdateLane(ScottPlot.WPF.WpfPlot chart, string title,
             var padding = Math.Max((maxVal - minVal) * 0.1, 1);
             chart.Plot.Axes.SetLimitsY(Math.Max(0, minVal - padding), maxVal + padding);
         }
-
-        chart.Refresh();
     }
 
-    /// <summary>
-    /// Sets identical X-axis limits across all lanes.
-    /// </summary>
     private void SyncXAxes(int hoursBack, DateTime? fromDate, DateTime? toDate)
     {
         DateTime xStart, xEnd;
@@ -298,9 +450,34 @@ private void SyncXAxes(int hoursBack, DateTime? fromDate, DateTime? toDate)
         }
     }
 
+    private static void AddGhostLine(ScottPlot.WPF.WpfPlot chart,
+        List<(double Time, double Value)> data, string colorHex)
+    {
+        if (data.Count == 0) return;
+
+        var times = data.Select(d => d.Time).ToArray();
+        var values = data.Select(d => d.Value).ToArray();
+
+        var scatter = chart.Plot.Add.Scatter(times, values);
+        scatter.Color = ScottPlot.Colors.White.WithAlpha(140);
+        scatter.MarkerSize = 0;
+        scatter.LineWidth = 1.5f;
+        scatter.LinePattern = ScottPlot.LinePattern.Dashed;
+    }
+
+    private static string ComparisonLabel((DateTime From, DateTime To) range,
+        DateTime? fromDate, int hoursBack)
+    {
+        var currentStart = fromDate ?? DateTime.UtcNow.AddHours(-hoursBack);
+        var daysBack = (currentStart - range.From).TotalDays;
+
+        if (Math.Abs(daysBack - 1) < 0.5) return "yesterday";
+        if (Math.Abs(daysBack - 7) < 0.5) return "last week";
+        return $"{daysBack:N0}d ago";
+    }
+
     private static void ClearChart(ScottPlot.WPF.WpfPlot chart)
     {
-        chart.Reset();
         chart.Plot.Clear();
     }
 
@@ -317,7 +494,6 @@ private static void ShowEmpty(ScottPlot.WPF.WpfPlot chart, string title)
         chart.Plot.Axes.Bottom.TickGenerator = new ScottPlot.TickGenerators.EmptyTickGenerator();
         chart.Plot.Axes.Left.TickGenerator = new ScottPlot.TickGenerators.EmptyTickGenerator();
         chart.Plot.Legend.IsVisible = false;
-        chart.Refresh();
     }
 
     /// <summary>
diff --git a/Dashboard/Controls/ResourceMetricsContent.xaml b/Dashboard/Controls/ResourceMetricsContent.xaml
index 4067d08..3685041 100644
--- a/Dashboard/Controls/ResourceMetricsContent.xaml
+++ b/Dashboard/Controls/ResourceMetricsContent.xaml
@@ -28,7 +28,21 @@
     <TabControl x:Name="SubTabControl" TabStripPlacement="Top" Margin="0,5,0,0">
         <!-- Server Trends Sub-Tab — Correlated Timeline Lanes -->
         <TabItem Header="Server Trends">
-            <local:CorrelatedTimelineLanesControl x:Name="CorrelatedLanes"/>
+            <DockPanel>
+                <StackPanel DockPanel.Dock="Top" Orientation="Horizontal" Margin="8,4,8,0">
+                    <TextBlock Text="Compare:" VerticalAlignment="Center" Margin="0,0,4,0"
+                               Foreground="{DynamicResource ForegroundBrush}"/>
+                    <ComboBox x:Name="CompareToCombo" SelectedIndex="0" Width="150"
+                              SelectionChanged="CompareToCombo_SelectionChanged"
+                              ToolTip="Overlay a reference period on the timeline charts">
+                        <ComboBoxItem Content="None"/>
+                        <ComboBoxItem Content="Yesterday"/>
+                        <ComboBoxItem Content="Last week"/>
+                        <ComboBoxItem Content="Same day last week"/>
+                    </ComboBox>
+                </StackPanel>
+                <local:CorrelatedTimelineLanesControl x:Name="CorrelatedLanes"/>
+            </DockPanel>
         </TabItem>
 
         <!-- Wait Stats Detail Sub-Tab -->
diff --git a/Dashboard/Controls/ResourceMetricsContent.xaml.cs b/Dashboard/Controls/ResourceMetricsContent.xaml.cs
index 4884c6c..7faa537 100644
--- a/Dashboard/Controls/ResourceMetricsContent.xaml.cs
+++ b/Dashboard/Controls/ResourceMetricsContent.xaml.cs
@@ -214,10 +214,11 @@ private void SetupChartContextMenus()
         /// <summary>
         /// Initializes the control with required dependencies.
         /// </summary>
-        public void Initialize(DatabaseService databaseService)
+        public void Initialize(DatabaseService databaseService,
+            Analysis.SqlServerBaselineProvider? baselineProvider = null)
         {
             _databaseService = databaseService ?? throw new ArgumentNullException(nameof(databaseService));
-            CorrelatedLanes.Initialize(databaseService);
+            CorrelatedLanes.Initialize(databaseService, baselineProvider);
         }
 
         /// <summary>
@@ -1024,12 +1025,41 @@ private async Task LoadFileIoThroughputChartsAsync()
 
         #region Server Trends Tab
 
+        private async void CompareToCombo_SelectionChanged(object sender, SelectionChangedEventArgs e)
+        {
+            if (!IsLoaded) return;
+            ComparisonRange = GetComparisonRange();
+            await RefreshServerTrendsAsync();
+        }
+
+        private (DateTime From, DateTime To)? ComparisonRange { get; set; }
+
+        /// <summary>
+        /// Computes the reference time range for the comparison overlay.
+        /// Returns null if "None" is selected.
+        /// </summary>
+        private (DateTime From, DateTime To)? GetComparisonRange()
+        {
+            if (CompareToCombo == null || CompareToCombo.SelectedIndex <= 0) return null;
+
+            var currentEnd = _serverTrendsToDate ?? DateTime.UtcNow;
+            var currentStart = _serverTrendsFromDate ?? currentEnd.AddHours(-_serverTrendsHoursBack);
+
+            return CompareToCombo.SelectedIndex switch
+            {
+                1 => (currentStart.AddDays(-1), currentEnd.AddDays(-1)),   // Yesterday
+                2 => (currentStart.AddDays(-7), currentEnd.AddDays(-7)),   // Last week
+                3 => (currentStart.AddDays(-7), currentEnd.AddDays(-7)),   // Same day last week
+                _ => null
+            };
+        }
+
         private async Task RefreshServerTrendsAsync()
         {
             if (_databaseService == null) return;
             try
             {
-                await CorrelatedLanes.RefreshAsync(_serverTrendsHoursBack, _serverTrendsFromDate, _serverTrendsToDate);
+                await CorrelatedLanes.RefreshAsync(_serverTrendsHoursBack, _serverTrendsFromDate, _serverTrendsToDate, ComparisonRange);
             }
             catch (Exception ex)
             {
diff --git a/Dashboard/Helpers/CorrelatedCrosshairManager.cs b/Dashboard/Helpers/CorrelatedCrosshairManager.cs
index 7da5400..c49b0a7 100644
--- a/Dashboard/Helpers/CorrelatedCrosshairManager.cs
+++ b/Dashboard/Helpers/CorrelatedCrosshairManager.cs
@@ -1,7 +1,7 @@
 /*
  * Copyright (c) 2026 Erik Darling, Darling Data LLC
  *
- * This file is part of the SQL Server Performance Monitor Lite.
+ * This file is part of the SQL Server Performance Monitor Dashboard.
  *
  * Licensed under the MIT License. See LICENSE file in the project root for full license information.
  *
@@ -15,6 +15,7 @@
 using System.Windows;
 using System.Windows.Controls;
 using System.Windows.Controls.Primitives;
+using System.Windows.Documents;
 using System.Windows.Input;
 using System.Windows.Media;
 using PerformanceMonitorDashboard.Services;
@@ -62,14 +63,13 @@ public CorrelatedCrosshairManager()
     /// <summary>
     /// Registers a chart lane for crosshair synchronization.
     /// </summary>
-    public void AddLane(ScottPlot.WPF.WpfPlot chart, string label, string unit, TextBlock valueLabel)
+    public void AddLane(ScottPlot.WPF.WpfPlot chart, string label, string unit)
     {
         var lane = new LaneInfo
         {
             Chart = chart,
             Label = label,
-            Unit = unit,
-            ValueLabel = valueLabel
+            Unit = unit
         };
 
         chart.MouseMove += (s, e) => OnMouseMove(lane, e);
@@ -78,6 +78,21 @@ public void AddLane(ScottPlot.WPF.WpfPlot chart, string label, string unit, Text
         _lanes.Add(lane);
     }
 
+    /// <summary>
+    /// Sets the expected baseline range for a lane (upper/lower bounds).
+    /// Values outside this range get ▲/▼ indicators in the tooltip.
+    /// </summary>
+    public void SetLaneBaseline(ScottPlot.WPF.WpfPlot chart, double lower, double upper,
+        double minAnomalyValue = 0, bool isEventBased = false)
+    {
+        var lane = _lanes.Find(l => l.Chart == chart);
+        if (lane == null) return;
+        lane.BaselineLower = lower;
+        lane.BaselineUpper = upper;
+        lane.MinAnomalyValue = minAnomalyValue;
+        lane.IsEventBased = isEventBased;
+    }
+
     /// <summary>
     /// Sets a single data series for a lane (most lanes have one series).
     /// </summary>
@@ -117,6 +132,16 @@ public void AddLaneSeries(ScottPlot.WPF.WpfPlot chart, string name, string unit,
         });
     }
 
+    /// <summary>
+    /// Sets the label shown in the tooltip for comparison data (e.g., "yesterday").
+    /// </summary>
+    public void SetComparisonLabel(string label)
+    {
+        _comparisonLabel = label;
+    }
+
+    private string? _comparisonLabel;
+
     /// <summary>
     /// Clears data and VLines. Call before re-populating charts.
     /// </summary>
@@ -124,10 +149,14 @@ public void PrepareForRefresh()
     {
         _isRefreshing = true;
         _tooltip.IsOpen = false;
+        _comparisonLabel = null;
         foreach (var lane in _lanes)
         {
             lane.Series.Clear();
             lane.VLine = null;
+            lane.BaselineUpper = null;
+            lane.BaselineLower = null;
+            lane.MinAnomalyValue = 0;
         }
     }
 
@@ -165,10 +194,14 @@ private void OnMouseMove(LaneInfo sourceLane, MouseEventArgs e)
         var mouseCoords = sourceLane.Chart.Plot.GetCoordinates(pixel);
         double xValue = mouseCoords.X;
 
-        var tooltipLines = new List<string>();
+        _tooltipText.Inlines.Clear();
         var time = DateTime.FromOADate(xValue);
         var displayTime = ServerTimeHelper.ConvertForDisplay(time, ServerTimeHelper.CurrentDisplayMode);
-        tooltipLines.Add(displayTime.ToString("yyyy-MM-dd HH:mm:ss"));
+        _tooltipText.Inlines.Add(new Run(displayTime.ToString("yyyy-MM-dd HH:mm:ss")));
+        if (_comparisonLabel != null)
+            _tooltipText.Inlines.Add(new Run($"  (dashed = {_comparisonLabel})") { Foreground = DimBrush });
+
+        var defaultBrush = new SolidColorBrush(Color.FromRgb(0xE0, 0xE0, 0xE0));
 
         foreach (var lane in _lanes)
         {
@@ -179,51 +212,49 @@ private void OnMouseMove(LaneInfo sourceLane, MouseEventArgs e)
 
             if (lane.Series.Count == 1)
             {
-                // Single series — use lane label and unit
                 var series = lane.Series[0];
                 double? value = FindNearestValue(series, xValue);
 
                 if (value.HasValue)
                 {
-                    lane.ValueLabel.Text = $"{value.Value:N1} {lane.Unit}";
-                    tooltipLines.Add($"{lane.Label}: {value.Value:N1} {lane.Unit}");
+                    var indicator = GetBaselineIndicator(lane, value.Value);
+
+                    // Tooltip: value + arrow + "30d avg" context
+                    _tooltipText.Inlines.Add(new Run($"\n{lane.Label}: {value.Value:N1} {lane.Unit}") { Foreground = defaultBrush });
+                    if (indicator != null)
+                    {
+                        _tooltipText.Inlines.Add(new Run($" {indicator.Value.Symbol}") { Foreground = indicator.Value.Brush });
+                    }
                 }
                 else
                 {
-                    lane.ValueLabel.Text = "";
-                    tooltipLines.Add($"{lane.Label}: —");
+                    _tooltipText.Inlines.Add(new Run($"\n{lane.Label}: —") { Foreground = defaultBrush });
                 }
             }
             else if (lane.Series.Count > 1)
             {
-                // Multiple series — show each with its own name
-                var valueParts = new List<string>();
                 foreach (var series in lane.Series)
                 {
                     double? value = FindNearestValue(series, xValue);
                     string unit = series.Unit ?? lane.Unit;
                     if (value.HasValue)
                     {
-                        valueParts.Add($"{value.Value:N0}");
-                        tooltipLines.Add($"{series.Name}: {value.Value:N0} {unit}");
+                        _tooltipText.Inlines.Add(new Run($"\n{series.Name}: {value.Value:N0} {unit}") { Foreground = defaultBrush });
+                        var indicator = GetBaselineIndicator(lane, value.Value);
+                        if (indicator != null)
+                            _tooltipText.Inlines.Add(new Run($" {indicator.Value.Symbol}") { Foreground = indicator.Value.Brush });
                     }
                     else
-                    {
-                        tooltipLines.Add($"{series.Name}: —");
-                    }
+                        _tooltipText.Inlines.Add(new Run($"\n{series.Name}: —") { Foreground = defaultBrush });
                 }
-                lane.ValueLabel.Text = valueParts.Count > 0 ? string.Join("/", valueParts) : "";
             }
             else
             {
-                lane.ValueLabel.Text = "";
-                tooltipLines.Add($"{lane.Label}: —");
+                _tooltipText.Inlines.Add(new Run($"\n{lane.Label}: —") { Foreground = defaultBrush });
             }
 
             lane.Chart.Refresh();
         }
-
-        _tooltipText.Text = string.Join("\n", tooltipLines);
         _tooltip.PlacementTarget = sourceLane.Chart;
         _tooltip.HorizontalOffset = pos.X + 15;
         _tooltip.VerticalOffset = pos.Y + 15;
@@ -265,6 +296,38 @@ private void OnMouseMove(LaneInfo sourceLane, MouseEventArgs e)
         return val;
     }
 
+    private static readonly SolidColorBrush RedBrush = new(Color.FromRgb(0xFF, 0x52, 0x52));
+    private static readonly SolidColorBrush GreenBrush = new(Color.FromRgb(0x69, 0xF0, 0x69));
+    private static readonly SolidColorBrush DimBrush = new(Color.FromRgb(0x90, 0x96, 0xA0));
+
+    private record struct BaselineIndicator(string Symbol, SolidColorBrush Brush);
+
+    private static string? FormatBaselineContext(LaneInfo lane)
+    {
+        if (lane.BaselineUpper == null || lane.BaselineLower == null) return null;
+        var mean = (lane.BaselineUpper.Value + lane.BaselineLower.Value) / 2.0;
+        var formatted = mean >= 1000 ? $"{mean:N0}" : mean >= 10 ? $"{mean:N1}" : $"{mean:N2}";
+        return $"30d avg: ~{formatted}";
+    }
+
+    private static BaselineIndicator? GetBaselineIndicator(LaneInfo lane, double value)
+    {
+        if (lane.BaselineUpper == null || lane.BaselineLower == null) return null;
+        // For event-based metrics (blocking/deadlocks): value significantly above
+        // the baseline mean is a spike, even if within the wide ± 2σ band.
+        // Uses 3x mean as threshold — if you normally see ~5 events and now see 20, that's a spike.
+        var mean = (lane.BaselineUpper.Value + lane.BaselineLower.Value) / 2.0;
+        if (lane.IsEventBased && value >= 1.0 && (mean < 1.0 || value > mean * 3))
+            return new BaselineIndicator("▲", RedBrush);
+        // ▲ requires both: outside band AND above absolute minimum (prevents 1% CPU false alarms)
+        if (value > lane.BaselineUpper.Value && value >= lane.MinAnomalyValue)
+            return new BaselineIndicator("▲", RedBrush);
+        // ▼ always shown when below band (drops are always interesting — tuning feedback)
+        if (value < lane.BaselineLower.Value)
+            return new BaselineIndicator("▼", GreenBrush);
+        return null;
+    }
+
     private void OnMouseLeave()
     {
         _tooltip.IsOpen = false;
@@ -272,7 +335,6 @@ private void OnMouseLeave()
         {
             if (lane.VLine != null)
                 lane.VLine.IsVisible = false;
-            lane.ValueLabel.Text = "";
             lane.Chart.Refresh();
         }
     }
@@ -303,7 +365,10 @@ private class LaneInfo
         public string Label { get; set; } = "";
         public string Unit { get; set; } = "";
         public ScottPlot.Plottables.VerticalLine? VLine { get; set; }
-        public TextBlock ValueLabel { get; set; } = null!;
         public List<DataSeries> Series { get; set; } = new();
+        public double? BaselineUpper { get; set; }
+        public double? BaselineLower { get; set; }
+        public double MinAnomalyValue { get; set; }
+        public bool IsEventBased { get; set; }
     }
 }
diff --git a/Dashboard/ServerTab.xaml.cs b/Dashboard/ServerTab.xaml.cs
index b3e2872..c207bad 100644
--- a/Dashboard/ServerTab.xaml.cs
+++ b/Dashboard/ServerTab.xaml.cs
@@ -158,7 +158,8 @@ public ServerTab(ServerConnection serverConnection, int utcOffsetMinutes = 0)
                 SetDrillDownGlobalRange(from, to);
             };
             SystemEventsContent.Initialize(_databaseService);
-            ResourceMetricsContent.Initialize(_databaseService);
+            var baselineProvider = new Analysis.SqlServerBaselineProvider(_databaseService.ConnectionString);
+            ResourceMetricsContent.Initialize(_databaseService, baselineProvider);
             ResourceMetricsContent.ChartDrillDownRequested += OnChildChartDrillDown;
 
             // Set default time range on UserControls based on user preferences
diff --git a/Lite/Controls/CorrelatedTimelineLanesControl.xaml.cs b/Lite/Controls/CorrelatedTimelineLanesControl.xaml.cs
index d42a7bc..d39775a 100644
--- a/Lite/Controls/CorrelatedTimelineLanesControl.xaml.cs
+++ b/Lite/Controls/CorrelatedTimelineLanesControl.xaml.cs
@@ -275,7 +275,7 @@ private void UpdateBlockingLane(List<(double Time, double Value)> blockingData,
             var upper = baseline.Mean + 2 * baseline.EffectiveStdDev;
             var lower = Math.Max(0, baseline.Mean - 2 * baseline.EffectiveStdDev);
 
-            _crosshairManager?.SetLaneBaseline(BlockingChart, lower, upper);
+            _crosshairManager?.SetLaneBaseline(BlockingChart, lower, upper, isEventBased: true);
 
             var band = BlockingChart.Plot.Add.HorizontalSpan(lower, upper);
             band.FillStyle.Color = ScottPlot.Color.FromHex("#E57373").WithAlpha(25);
diff --git a/Lite/Helpers/CorrelatedCrosshairManager.cs b/Lite/Helpers/CorrelatedCrosshairManager.cs
index 1cb52a1..75bce9b 100644
--- a/Lite/Helpers/CorrelatedCrosshairManager.cs
+++ b/Lite/Helpers/CorrelatedCrosshairManager.cs
@@ -83,13 +83,14 @@ public void AddLane(ScottPlot.WPF.WpfPlot chart, string label, string unit)
     /// Values outside this range get ▲/▼ indicators in the tooltip.
     /// </summary>
     public void SetLaneBaseline(ScottPlot.WPF.WpfPlot chart, double lower, double upper,
-        double minAnomalyValue = 0)
+        double minAnomalyValue = 0, bool isEventBased = false)
     {
         var lane = _lanes.Find(l => l.Chart == chart);
         if (lane == null) return;
         lane.BaselineLower = lower;
         lane.BaselineUpper = upper;
         lane.MinAnomalyValue = minAnomalyValue;
+        lane.IsEventBased = isEventBased;
     }
 
     /// <summary>
@@ -223,9 +224,6 @@ private void OnMouseMove(LaneInfo sourceLane, MouseEventArgs e)
                     if (indicator != null)
                     {
                         _tooltipText.Inlines.Add(new Run($" {indicator.Value.Symbol}") { Foreground = indicator.Value.Brush });
-                        var ctx = FormatBaselineContext(lane);
-                        if (ctx != null)
-                            _tooltipText.Inlines.Add(new Run($" ({ctx})") { Foreground = DimBrush });
                     }
                 }
                 else
@@ -240,7 +238,12 @@ private void OnMouseMove(LaneInfo sourceLane, MouseEventArgs e)
                     double? value = FindNearestValue(series, xValue);
                     string unit = series.Unit ?? lane.Unit;
                     if (value.HasValue)
+                    {
                         _tooltipText.Inlines.Add(new Run($"\n{series.Name}: {value.Value:N0} {unit}") { Foreground = defaultBrush });
+                        var indicator = GetBaselineIndicator(lane, value.Value);
+                        if (indicator != null)
+                            _tooltipText.Inlines.Add(new Run($" {indicator.Value.Symbol}") { Foreground = indicator.Value.Brush });
+                    }
                     else
                         _tooltipText.Inlines.Add(new Run($"\n{series.Name}: —") { Foreground = defaultBrush });
                 }
@@ -310,6 +313,12 @@ private record struct BaselineIndicator(string Symbol, SolidColorBrush Brush);
     private static BaselineIndicator? GetBaselineIndicator(LaneInfo lane, double value)
     {
         if (lane.BaselineUpper == null || lane.BaselineLower == null) return null;
+        // For event-based metrics (blocking/deadlocks): value significantly above
+        // the baseline mean is a spike, even if within the wide ± 2σ band.
+        // Uses 3x mean as threshold — if you normally see ~5 events and now see 20, that's a spike.
+        var mean = (lane.BaselineUpper.Value + lane.BaselineLower.Value) / 2.0;
+        if (lane.IsEventBased && value >= 1.0 && (mean < 1.0 || value > mean * 3))
+            return new BaselineIndicator("▲", RedBrush);
         // ▲ requires both: outside band AND above absolute minimum (prevents 1% CPU false alarms)
         if (value > lane.BaselineUpper.Value && value >= lane.MinAnomalyValue)
             return new BaselineIndicator("▲", RedBrush);
@@ -360,5 +369,6 @@ private class LaneInfo
         public double? BaselineUpper { get; set; }
         public double? BaselineLower { get; set; }
         public double MinAnomalyValue { get; set; }
+        public bool IsEventBased { get; set; }
     }
 }

From ff00af602a81339baa1a86a363fbef58458abcea Mon Sep 17 00:00:00 2001
From: Erik Darling <2136037+erikdarlingdata@users.noreply.github.com>
Date: Tue, 7 Apr 2026 08:50:15 -0400
Subject: [PATCH 19/30] Port warning rule improvements from PerformanceStudio
 (#178)

- Rule 1 (Filter): Suppress trivial filters (< 128 reads/10ms actual, < 1.0 cost estimated)
- Rule 3 (Serial Plan): Skip trivial statements with cost < 0.01
- Rule 15 (Join OR): Exclude Merge Interval inside anti/semi joins
- Rule 20 (Local Variables): Skip trivial statements with cost < 0.01
- Rule 26 (Row Goal): Require >= 2x reduction
- ShowPlanParser: Gate XML MemoryGrantWarning at 1 GB
- Scalar UDF: Expanded remediation options (variable assignment, 2019+ inlining)

All changes applied identically to Dashboard and Lite.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
---
 Dashboard/Services/PlanAnalyzer.cs   | 80 ++++++++++++++++++++--------
 Dashboard/Services/ShowPlanParser.cs | 18 ++++---
 Lite/Services/PlanAnalyzer.cs        | 80 ++++++++++++++++++++--------
 Lite/Services/ShowPlanParser.cs      | 18 ++++---
 4 files changed, 140 insertions(+), 56 deletions(-)

diff --git a/Dashboard/Services/PlanAnalyzer.cs b/Dashboard/Services/PlanAnalyzer.cs
index 30b9343..5c9e8c9 100644
--- a/Dashboard/Services/PlanAnalyzer.cs
+++ b/Dashboard/Services/PlanAnalyzer.cs
@@ -38,7 +38,9 @@ public static void Analyze(ParsedPlan plan)
     private static void AnalyzeStatement(PlanStatement stmt)
     {
         // Rule 3: Serial plan with reason
-        if (!string.IsNullOrEmpty(stmt.NonParallelPlanReason))
+        // Skip trivial statements (e.g., variable assignments, constant scans) — not worth warning about
+        if (!string.IsNullOrEmpty(stmt.NonParallelPlanReason)
+            && stmt.StatementSubTreeCost >= 0.01)
         {
             var reason = stmt.NonParallelPlanReason switch
             {
@@ -140,7 +142,7 @@ private static void AnalyzeStatement(PlanStatement stmt)
             stmt.PlanWarnings.Add(new PlanWarning
             {
                 WarningType = "UDF Execution",
-                Message = $"Scalar UDF cost in this statement: {stmt.QueryUdfElapsedTimeMs:N0}ms elapsed, {stmt.QueryUdfCpuTimeMs:N0}ms CPU. Scalar UDFs run once per row and prevent parallelism. Rewrite as an inline table-valued function, or dump results to a #temp table and apply the UDF only to the final result set.",
+                Message = $"Scalar UDF cost in this statement: {stmt.QueryUdfElapsedTimeMs:N0}ms elapsed, {stmt.QueryUdfCpuTimeMs:N0}ms CPU. Scalar UDFs run once per row and prevent parallelism. Options: rewrite as an inline table-valued function, assign the result to a variable if only one row is needed, dump results to a #temp table and apply the UDF to the final result set, or on SQL Server 2019+ check if the UDF is eligible for automatic scalar UDF inlining.",
                 Severity = stmt.QueryUdfElapsedTimeMs >= 1000 ? PlanWarningSeverity.Critical : PlanWarningSeverity.Warning
             });
         }
@@ -148,7 +150,8 @@ private static void AnalyzeStatement(PlanStatement stmt)
         // Rule 20: Local variables without RECOMPILE
         // Parameters with no CompiledValue are likely local variables — the optimizer
         // cannot sniff their values and uses density-based ("unknown") estimates.
-        if (stmt.Parameters.Count > 0)
+        // Skip trivial statements (simple variable assignments) where estimate quality doesn't matter.
+        if (stmt.Parameters.Count > 0 && stmt.StatementSubTreeCost >= 0.01)
         {
             var unsnifffedParams = stmt.Parameters
                 .Where(p => string.IsNullOrEmpty(p.CompiledValue))
@@ -352,21 +355,42 @@ private static void AnalyzeNode(PlanNode node, PlanStatement stmt)
     {
         // Rule 1: Filter operators — rows survived the tree just to be discarded
         // Quantify the impact by summing child subtree cost (reads, CPU, time).
-        if (node.PhysicalOp == "Filter" && !string.IsNullOrEmpty(node.Predicate))
+        // Suppress when the filter's child subtree is trivial (low I/O, fast, cheap).
+        if (node.PhysicalOp == "Filter" && !string.IsNullOrEmpty(node.Predicate)
+            && node.Children.Count > 0)
         {
-            var impact = QuantifyFilterImpact(node);
-            var predicate = Truncate(node.Predicate, 200);
-            var message = "Filter operator discarding rows late in the plan.";
-            if (!string.IsNullOrEmpty(impact))
-                message += $"\n{impact}";
-            message += $"\nPredicate: {predicate}";
+            // Gate: skip trivial filters based on actual stats or estimated cost
+            bool isTrivial;
+            if (node.HasActualStats)
+            {
+                long childReads = 0;
+                foreach (var child in node.Children)
+                    childReads += SumSubtreeReads(child);
+                var childElapsed = node.Children.Max(c => c.ActualElapsedMs);
+                isTrivial = childReads < 128 && childElapsed < 10;
+            }
+            else
+            {
+                var childCost = node.Children.Sum(c => c.EstimatedTotalSubtreeCost);
+                isTrivial = childCost < 1.0;
+            }
 
-            node.Warnings.Add(new PlanWarning
+            if (!isTrivial)
             {
-                WarningType = "Filter Operator",
-                Message = message,
-                Severity = PlanWarningSeverity.Warning
-            });
+                var impact = QuantifyFilterImpact(node);
+                var predicate = Truncate(node.Predicate, 200);
+                var message = "Filter operator discarding rows late in the plan.";
+                if (!string.IsNullOrEmpty(impact))
+                    message += $"\n{impact}";
+                message += $"\nPredicate: {predicate}";
+
+                node.Warnings.Add(new PlanWarning
+                {
+                    WarningType = "Filter Operator",
+                    Message = message,
+                    Severity = PlanWarningSeverity.Warning
+                });
+            }
         }
 
         // Rule 2: Eager Index Spools — optimizer building temporary indexes on the fly
@@ -391,7 +415,7 @@ private static void AnalyzeNode(PlanNode node, PlanStatement stmt)
             node.Warnings.Add(new PlanWarning
             {
                 WarningType = "UDF Execution",
-                Message = $"Scalar UDF executing on this operator ({node.UdfElapsedTimeMs:N0}ms elapsed, {node.UdfCpuTimeMs:N0}ms CPU). Scalar UDFs run once per row and prevent parallelism. Rewrite as an inline table-valued function, or dump the query results to a #temp table first and apply the UDF only to the final result set.",
+                Message = $"Scalar UDF executing on this operator ({node.UdfElapsedTimeMs:N0}ms elapsed, {node.UdfCpuTimeMs:N0}ms CPU). Scalar UDFs run once per row and prevent parallelism. Options: rewrite as an inline table-valued function, assign the result to a variable if only one row is needed, dump results to a #temp table and apply the UDF to the final result set, or on SQL Server 2019+ check if the UDF is eligible for automatic scalar UDF inlining.",
                 Severity = node.UdfElapsedTimeMs >= 1000 ? PlanWarningSeverity.Critical : PlanWarningSeverity.Warning
             });
         }
@@ -451,7 +475,7 @@ private static void AnalyzeNode(PlanNode node, PlanStatement stmt)
             node.Warnings.Add(new PlanWarning
             {
                 WarningType = "Scalar UDF",
-                Message = $"Scalar {type} UDF: {udf.FunctionName}. Scalar UDFs run once per row and prevent parallelism. Rewrite as an inline table-valued function, or dump results to a #temp table and apply the UDF only to the final result set.",
+                Message = $"Scalar {type} UDF: {udf.FunctionName}. Scalar UDFs run once per row and prevent parallelism. Options: rewrite as an inline table-valued function, assign the result to a variable if only one row is needed, dump results to a #temp table and apply the UDF to the final result set, or on SQL Server 2019+ check if the UDF is eligible for automatic scalar UDF inlining.",
                 Severity = PlanWarningSeverity.Warning
             });
         }
@@ -830,12 +854,17 @@ _ when nonSargableReason.StartsWith("Function call", StringComparison.OrdinalIgn
             node.EstimateRowsWithoutRowGoal > node.EstimateRows)
         {
             var reduction = node.EstimateRowsWithoutRowGoal / node.EstimateRows;
-            node.Warnings.Add(new PlanWarning
+            // Require at least a 2x reduction to be worth mentioning — "1 to 1" or
+            // tiny floating-point differences that display identically are noise
+            if (reduction >= 2.0)
             {
-                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
-            });
+                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 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
+                });
+            }
         }
 
         // Rule 28: Row Count Spool — NOT IN with nullable column
@@ -1067,6 +1096,13 @@ private static bool IsOrExpansionChain(PlanNode concatenationNode)
         if (parent == null || parent.PhysicalOp != "Nested Loops")
             return false;
 
+        // If this Nested Loops is inside an Anti/Semi Join, this is a NOT IN/IN
+        // subquery pattern (Merge Interval optimizing range lookups), not an OR expansion
+        var nlParent = parent.Parent;
+        if (nlParent != null && nlParent.LogicalOp != null &&
+            nlParent.LogicalOp.Contains("Semi"))
+            return false;
+
         return true;
     }
 
diff --git a/Dashboard/Services/ShowPlanParser.cs b/Dashboard/Services/ShowPlanParser.cs
index b8c45c6..f441db9 100644
--- a/Dashboard/Services/ShowPlanParser.cs
+++ b/Dashboard/Services/ShowPlanParser.cs
@@ -1632,7 +1632,8 @@ private static List<PlanWarning> ParseWarningsFromElement(XElement warningsEl)
             });
         }
 
-        // Memory grant warning
+        // Memory grant warning (from plan XML) — gate at 1 GB to avoid noise on small grants
+        // All values are in KB, consistent with MemoryGrantInfo element
         var memWarnEl = warningsEl.Element(Ns + "MemoryGrantWarning");
         if (memWarnEl != null)
         {
@@ -1640,12 +1641,17 @@ private static List<PlanWarning> ParseWarningsFromElement(XElement warningsEl)
             var requested = ParseLong(memWarnEl.Attribute("RequestedMemory")?.Value);
             var granted = ParseLong(memWarnEl.Attribute("GrantedMemory")?.Value);
             var maxUsed = ParseLong(memWarnEl.Attribute("MaxUsedMemory")?.Value);
-            result.Add(new PlanWarning
+            if (granted >= 1048576) // 1 GB in KB
             {
-                WarningType = "Memory Grant",
-                Message = $"{kind}: Requested {requested:N0} KB, Granted {granted:N0} KB, Used {maxUsed:N0} KB",
-                Severity = PlanWarningSeverity.Warning
-            });
+                var grantedMB = granted / 1024.0;
+                var usedMB = maxUsed / 1024.0;
+                result.Add(new PlanWarning
+                {
+                    WarningType = "Memory Grant",
+                    Message = $"{kind}: Granted {grantedMB:N0} MB, Used {usedMB:N0} MB",
+                    Severity = PlanWarningSeverity.Warning
+                });
+            }
         }
 
         // Implicit conversions
diff --git a/Lite/Services/PlanAnalyzer.cs b/Lite/Services/PlanAnalyzer.cs
index 227ef4b..8308aaf 100644
--- a/Lite/Services/PlanAnalyzer.cs
+++ b/Lite/Services/PlanAnalyzer.cs
@@ -38,7 +38,9 @@ public static void Analyze(ParsedPlan plan)
     private static void AnalyzeStatement(PlanStatement stmt)
     {
         // Rule 3: Serial plan with reason
-        if (!string.IsNullOrEmpty(stmt.NonParallelPlanReason))
+        // Skip trivial statements (e.g., variable assignments, constant scans) — not worth warning about
+        if (!string.IsNullOrEmpty(stmt.NonParallelPlanReason)
+            && stmt.StatementSubTreeCost >= 0.01)
         {
             var reason = stmt.NonParallelPlanReason switch
             {
@@ -140,7 +142,7 @@ private static void AnalyzeStatement(PlanStatement stmt)
             stmt.PlanWarnings.Add(new PlanWarning
             {
                 WarningType = "UDF Execution",
-                Message = $"Scalar UDF cost in this statement: {stmt.QueryUdfElapsedTimeMs:N0}ms elapsed, {stmt.QueryUdfCpuTimeMs:N0}ms CPU. Scalar UDFs run once per row and prevent parallelism. Rewrite as an inline table-valued function, or dump results to a #temp table and apply the UDF only to the final result set.",
+                Message = $"Scalar UDF cost in this statement: {stmt.QueryUdfElapsedTimeMs:N0}ms elapsed, {stmt.QueryUdfCpuTimeMs:N0}ms CPU. Scalar UDFs run once per row and prevent parallelism. Options: rewrite as an inline table-valued function, assign the result to a variable if only one row is needed, dump results to a #temp table and apply the UDF to the final result set, or on SQL Server 2019+ check if the UDF is eligible for automatic scalar UDF inlining.",
                 Severity = stmt.QueryUdfElapsedTimeMs >= 1000 ? PlanWarningSeverity.Critical : PlanWarningSeverity.Warning
             });
         }
@@ -148,7 +150,8 @@ private static void AnalyzeStatement(PlanStatement stmt)
         // Rule 20: Local variables without RECOMPILE
         // Parameters with no CompiledValue are likely local variables — the optimizer
         // cannot sniff their values and uses density-based ("unknown") estimates.
-        if (stmt.Parameters.Count > 0)
+        // Skip trivial statements (simple variable assignments) where estimate quality doesn't matter.
+        if (stmt.Parameters.Count > 0 && stmt.StatementSubTreeCost >= 0.01)
         {
             var unsnifffedParams = stmt.Parameters
                 .Where(p => string.IsNullOrEmpty(p.CompiledValue))
@@ -352,21 +355,42 @@ private static void AnalyzeNode(PlanNode node, PlanStatement stmt)
     {
         // Rule 1: Filter operators — rows survived the tree just to be discarded
         // Quantify the impact by summing child subtree cost (reads, CPU, time).
-        if (node.PhysicalOp == "Filter" && !string.IsNullOrEmpty(node.Predicate))
+        // Suppress when the filter's child subtree is trivial (low I/O, fast, cheap).
+        if (node.PhysicalOp == "Filter" && !string.IsNullOrEmpty(node.Predicate)
+            && node.Children.Count > 0)
         {
-            var impact = QuantifyFilterImpact(node);
-            var predicate = Truncate(node.Predicate, 200);
-            var message = "Filter operator discarding rows late in the plan.";
-            if (!string.IsNullOrEmpty(impact))
-                message += $"\n{impact}";
-            message += $"\nPredicate: {predicate}";
+            // Gate: skip trivial filters based on actual stats or estimated cost
+            bool isTrivial;
+            if (node.HasActualStats)
+            {
+                long childReads = 0;
+                foreach (var child in node.Children)
+                    childReads += SumSubtreeReads(child);
+                var childElapsed = node.Children.Max(c => c.ActualElapsedMs);
+                isTrivial = childReads < 128 && childElapsed < 10;
+            }
+            else
+            {
+                var childCost = node.Children.Sum(c => c.EstimatedTotalSubtreeCost);
+                isTrivial = childCost < 1.0;
+            }
 
-            node.Warnings.Add(new PlanWarning
+            if (!isTrivial)
             {
-                WarningType = "Filter Operator",
-                Message = message,
-                Severity = PlanWarningSeverity.Warning
-            });
+                var impact = QuantifyFilterImpact(node);
+                var predicate = Truncate(node.Predicate, 200);
+                var message = "Filter operator discarding rows late in the plan.";
+                if (!string.IsNullOrEmpty(impact))
+                    message += $"\n{impact}";
+                message += $"\nPredicate: {predicate}";
+
+                node.Warnings.Add(new PlanWarning
+                {
+                    WarningType = "Filter Operator",
+                    Message = message,
+                    Severity = PlanWarningSeverity.Warning
+                });
+            }
         }
 
         // Rule 2: Eager Index Spools — optimizer building temporary indexes on the fly
@@ -391,7 +415,7 @@ private static void AnalyzeNode(PlanNode node, PlanStatement stmt)
             node.Warnings.Add(new PlanWarning
             {
                 WarningType = "UDF Execution",
-                Message = $"Scalar UDF executing on this operator ({node.UdfElapsedTimeMs:N0}ms elapsed, {node.UdfCpuTimeMs:N0}ms CPU). Scalar UDFs run once per row and prevent parallelism. Rewrite as an inline table-valued function, or dump the query results to a #temp table first and apply the UDF only to the final result set.",
+                Message = $"Scalar UDF executing on this operator ({node.UdfElapsedTimeMs:N0}ms elapsed, {node.UdfCpuTimeMs:N0}ms CPU). Scalar UDFs run once per row and prevent parallelism. Options: rewrite as an inline table-valued function, assign the result to a variable if only one row is needed, dump results to a #temp table and apply the UDF to the final result set, or on SQL Server 2019+ check if the UDF is eligible for automatic scalar UDF inlining.",
                 Severity = node.UdfElapsedTimeMs >= 1000 ? PlanWarningSeverity.Critical : PlanWarningSeverity.Warning
             });
         }
@@ -451,7 +475,7 @@ private static void AnalyzeNode(PlanNode node, PlanStatement stmt)
             node.Warnings.Add(new PlanWarning
             {
                 WarningType = "Scalar UDF",
-                Message = $"Scalar {type} UDF: {udf.FunctionName}. Scalar UDFs run once per row and prevent parallelism. Rewrite as an inline table-valued function, or dump results to a #temp table and apply the UDF only to the final result set.",
+                Message = $"Scalar {type} UDF: {udf.FunctionName}. Scalar UDFs run once per row and prevent parallelism. Options: rewrite as an inline table-valued function, assign the result to a variable if only one row is needed, dump results to a #temp table and apply the UDF to the final result set, or on SQL Server 2019+ check if the UDF is eligible for automatic scalar UDF inlining.",
                 Severity = PlanWarningSeverity.Warning
             });
         }
@@ -829,12 +853,17 @@ _ when nonSargableReason.StartsWith("Function call", StringComparison.OrdinalIgn
             node.EstimateRowsWithoutRowGoal > node.EstimateRows)
         {
             var reduction = node.EstimateRowsWithoutRowGoal / node.EstimateRows;
-            node.Warnings.Add(new PlanWarning
+            // Require at least a 2x reduction to be worth mentioning — "1 to 1" or
+            // tiny floating-point differences that display identically are noise
+            if (reduction >= 2.0)
             {
-                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
-            });
+                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 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
+                });
+            }
         }
 
         // Rule 28: Row Count Spool — NOT IN with nullable column
@@ -1066,6 +1095,13 @@ private static bool IsOrExpansionChain(PlanNode concatenationNode)
         if (parent == null || parent.PhysicalOp != "Nested Loops")
             return false;
 
+        // If this Nested Loops is inside an Anti/Semi Join, this is a NOT IN/IN
+        // subquery pattern (Merge Interval optimizing range lookups), not an OR expansion
+        var nlParent = parent.Parent;
+        if (nlParent != null && nlParent.LogicalOp != null &&
+            nlParent.LogicalOp.Contains("Semi"))
+            return false;
+
         return true;
     }
 
diff --git a/Lite/Services/ShowPlanParser.cs b/Lite/Services/ShowPlanParser.cs
index bd08ff2..1e825e9 100644
--- a/Lite/Services/ShowPlanParser.cs
+++ b/Lite/Services/ShowPlanParser.cs
@@ -1632,7 +1632,8 @@ private static List<PlanWarning> ParseWarningsFromElement(XElement warningsEl)
             });
         }
 
-        // Memory grant warning
+        // Memory grant warning (from plan XML) — gate at 1 GB to avoid noise on small grants
+        // All values are in KB, consistent with MemoryGrantInfo element
         var memWarnEl = warningsEl.Element(Ns + "MemoryGrantWarning");
         if (memWarnEl != null)
         {
@@ -1640,12 +1641,17 @@ private static List<PlanWarning> ParseWarningsFromElement(XElement warningsEl)
             var requested = ParseLong(memWarnEl.Attribute("RequestedMemory")?.Value);
             var granted = ParseLong(memWarnEl.Attribute("GrantedMemory")?.Value);
             var maxUsed = ParseLong(memWarnEl.Attribute("MaxUsedMemory")?.Value);
-            result.Add(new PlanWarning
+            if (granted >= 1048576) // 1 GB in KB
             {
-                WarningType = "Memory Grant",
-                Message = $"{kind}: Requested {requested:N0} KB, Granted {granted:N0} KB, Used {maxUsed:N0} KB",
-                Severity = PlanWarningSeverity.Warning
-            });
+                var grantedMB = granted / 1024.0;
+                var usedMB = maxUsed / 1024.0;
+                result.Add(new PlanWarning
+                {
+                    WarningType = "Memory Grant",
+                    Message = $"{kind}: Granted {grantedMB:N0} MB, Used {usedMB:N0} MB",
+                    Severity = PlanWarningSeverity.Warning
+                });
+            }
         }
 
         // Implicit conversions

From 679eb9cf14370adaa795a85fc71e31e2f6e779f1 Mon Sep 17 00:00:00 2001
From: Erik Darling <2136037+erikdarlingdata@users.noreply.github.com>
Date: Tue, 7 Apr 2026 11:46:12 -0400
Subject: [PATCH 20/30] Refine Rule 3 (Serial Plan): TRIVIAL, 0ms, severity
 demotion

- Suppress for TRIVIAL optimization level (can't go parallel anyway)
- Suppress for 0ms actual elapsed time
- Demote to Info unless user explicitly forced serial (MAXDOP 1 / hint)

Ported from PerformanceStudio #178 round 2 feedback.

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

diff --git a/Dashboard/Services/PlanAnalyzer.cs b/Dashboard/Services/PlanAnalyzer.cs
index 5c9e8c9..4c2e59b 100644
--- a/Dashboard/Services/PlanAnalyzer.cs
+++ b/Dashboard/Services/PlanAnalyzer.cs
@@ -38,9 +38,12 @@ public static void Analyze(ParsedPlan plan)
     private static void AnalyzeStatement(PlanStatement stmt)
     {
         // Rule 3: Serial plan with reason
-        // Skip trivial statements (e.g., variable assignments, constant scans) — not worth warning about
+        // Skip: trivial cost (< 0.01), TRIVIAL optimization (can't go parallel anyway),
+        // and 0ms actual elapsed time (not worth flagging).
         if (!string.IsNullOrEmpty(stmt.NonParallelPlanReason)
-            && stmt.StatementSubTreeCost >= 0.01)
+            && stmt.StatementSubTreeCost >= 0.01
+            && stmt.StatementOptmLevel != "TRIVIAL"
+            && !(stmt.QueryTimeStats != null && stmt.QueryTimeStats.ElapsedTimeMs == 0))
         {
             var reason = stmt.NonParallelPlanReason switch
             {
@@ -52,11 +55,13 @@ private static void AnalyzeStatement(PlanStatement stmt)
                 _ => stmt.NonParallelPlanReason
             };
 
+            var isExplicit = stmt.NonParallelPlanReason is "MaxDOPSetToOne" or "QueryHintNoParallelSet";
+
             stmt.PlanWarnings.Add(new PlanWarning
             {
                 WarningType = "Serial Plan",
                 Message = $"Query running serially: {reason}.",
-                Severity = PlanWarningSeverity.Warning
+                Severity = isExplicit ? PlanWarningSeverity.Warning : PlanWarningSeverity.Info
             });
         }
 
diff --git a/Lite/Services/PlanAnalyzer.cs b/Lite/Services/PlanAnalyzer.cs
index 8308aaf..7f94429 100644
--- a/Lite/Services/PlanAnalyzer.cs
+++ b/Lite/Services/PlanAnalyzer.cs
@@ -38,9 +38,12 @@ public static void Analyze(ParsedPlan plan)
     private static void AnalyzeStatement(PlanStatement stmt)
     {
         // Rule 3: Serial plan with reason
-        // Skip trivial statements (e.g., variable assignments, constant scans) — not worth warning about
+        // Skip: trivial cost (< 0.01), TRIVIAL optimization (can't go parallel anyway),
+        // and 0ms actual elapsed time (not worth flagging).
         if (!string.IsNullOrEmpty(stmt.NonParallelPlanReason)
-            && stmt.StatementSubTreeCost >= 0.01)
+            && stmt.StatementSubTreeCost >= 0.01
+            && stmt.StatementOptmLevel != "TRIVIAL"
+            && !(stmt.QueryTimeStats != null && stmt.QueryTimeStats.ElapsedTimeMs == 0))
         {
             var reason = stmt.NonParallelPlanReason switch
             {
@@ -52,11 +55,13 @@ private static void AnalyzeStatement(PlanStatement stmt)
                 _ => stmt.NonParallelPlanReason
             };
 
+            var isExplicit = stmt.NonParallelPlanReason is "MaxDOPSetToOne" or "QueryHintNoParallelSet";
+
             stmt.PlanWarnings.Add(new PlanWarning
             {
                 WarningType = "Serial Plan",
                 Message = $"Query running serially: {reason}.",
-                Severity = PlanWarningSeverity.Warning
+                Severity = isExplicit ? PlanWarningSeverity.Warning : PlanWarningSeverity.Info
             });
         }
 

From 26a13e04b519ff726657aae443f2c086bc5cd064 Mon Sep 17 00:00:00 2001
From: Erik Darling <2136037+erikdarlingdata@users.noreply.github.com>
Date: Tue, 7 Apr 2026 12:02:07 -0400
Subject: [PATCH 21/30] Add before/after comparison mode for query grids in
 Lite (#687)

Extend the global Compare dropdown to support query stats, procedure stats,
and query store tabs with delta columns showing regressions and improvements.
Compare dropdown is disabled on unsupported tabs with visual feedback.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
---
 Lite/Controls/ServerTab.xaml                 | 274 ++++++++++++++++++-
 Lite/Controls/ServerTab.xaml.cs              | 207 ++++++++++++++
 Lite/Models/ComparisonItemBase.cs            |  87 ++++++
 Lite/Models/ProcedureStatsComparisonItem.cs  |  16 ++
 Lite/Models/QueryStatsComparisonItem.cs      |  15 +
 Lite/Services/LocalDataService.QueryStats.cs | 233 ++++++++++++++++
 Lite/Services/LocalDataService.QueryStore.cs | 116 ++++++++
 7 files changed, 944 insertions(+), 4 deletions(-)
 create mode 100644 Lite/Models/ComparisonItemBase.cs
 create mode 100644 Lite/Models/ProcedureStatsComparisonItem.cs
 create mode 100644 Lite/Models/QueryStatsComparisonItem.cs

diff --git a/Lite/Controls/ServerTab.xaml b/Lite/Controls/ServerTab.xaml
index 6202f64..c04d23d 100644
--- a/Lite/Controls/ServerTab.xaml
+++ b/Lite/Controls/ServerTab.xaml
@@ -107,7 +107,7 @@
                                Foreground="{DynamicResource ForegroundBrush}"/>
                     <ComboBox x:Name="CompareToCombo" SelectedIndex="0" Width="130" Margin="0,0,8,0"
                               SelectionChanged="CompareToCombo_SelectionChanged"
-                              ToolTip="Overlay a reference period on the Overview charts">
+                              ToolTip="Compare current period against a baseline">
                         <ComboBoxItem Content="None"/>
                         <ComboBoxItem Content="Yesterday"/>
                         <ComboBoxItem Content="Last week"/>
@@ -348,11 +348,16 @@
                         <TabItem Header="Top Queries by Duration">
                             <Grid>
                                 <Grid.RowDefinitions>
+                                    <RowDefinition Height="Auto"/>
                                     <RowDefinition Height="Auto"/>
                                     <RowDefinition Height="*"/>
                                 </Grid.RowDefinitions>
                                 <controls:TimeRangeSlicerControl x:Name="QueryStatsSlicer" Grid.Row="0"/>
-                            <DataGrid Grid.Row="1" x:Name="QueryStatsGrid"
+                                <TextBlock x:Name="QueryStatsComparisonBanner" Grid.Row="1" Visibility="Collapsed"
+                                           Padding="8,4" FontWeight="Bold"
+                                           Foreground="{DynamicResource ForegroundBrush}"
+                                           Background="#2244AAFF"/>
+                            <DataGrid Grid.Row="2" x:Name="QueryStatsGrid"
                                       AutoGenerateColumns="False" IsReadOnly="True"
                                       RowStyle="{StaticResource GridRowStyle}"
                                       HeadersVisibility="Column" GridLinesVisibility="Horizontal"
@@ -477,16 +482,129 @@
                                     </DataGridTemplateColumn>
                                 </DataGrid.Columns>
                             </DataGrid>
+                            <DataGrid Grid.Row="2" x:Name="QueryStatsComparisonGrid" Visibility="Collapsed"
+                                      AutoGenerateColumns="False" IsReadOnly="True"
+                                      RowStyle="{StaticResource GridRowStyle}"
+                                      HeadersVisibility="Column" GridLinesVisibility="Horizontal"
+                                      CanUserSortColumns="True">
+                                <DataGrid.Columns>
+                                    <DataGridTextColumn Binding="{Binding StatusBadge}" Width="55">
+                                        <DataGridTextColumn.Header><TextBlock Text="" FontWeight="Bold" VerticalAlignment="Center"/></DataGridTextColumn.Header>
+                                        <DataGridTextColumn.ElementStyle>
+                                            <Style TargetType="TextBlock">
+                                                <Setter Property="FontWeight" Value="Bold"/>
+                                                <Setter Property="HorizontalAlignment" Value="Center"/>
+                                                <Style.Triggers>
+                                                    <DataTrigger Binding="{Binding IsNew}" Value="True">
+                                                        <Setter Property="Foreground" Value="#FF6B6B"/>
+                                                    </DataTrigger>
+                                                    <DataTrigger Binding="{Binding IsGone}" Value="True">
+                                                        <Setter Property="Foreground" Value="#888888"/>
+                                                    </DataTrigger>
+                                                </Style.Triggers>
+                                            </Style>
+                                        </DataGridTextColumn.ElementStyle>
+                                    </DataGridTextColumn>
+                                    <DataGridTextColumn Binding="{Binding DatabaseName}" Width="120">
+                                        <DataGridTextColumn.Header><TextBlock Text="Database" FontWeight="Bold" VerticalAlignment="Center"/></DataGridTextColumn.Header>
+                                    </DataGridTextColumn>
+                                    <DataGridTextColumn Binding="{Binding ExecutionCount, StringFormat=N0}" ElementStyle="{StaticResource NumericCell}" Width="90">
+                                        <DataGridTextColumn.Header><TextBlock Text="Executions" FontWeight="Bold" VerticalAlignment="Center"/></DataGridTextColumn.Header>
+                                    </DataGridTextColumn>
+                                    <DataGridTextColumn Binding="{Binding BaselineExecutionCount, StringFormat=N0}" ElementStyle="{StaticResource NumericCell}" Width="100">
+                                        <DataGridTextColumn.Header><TextBlock Text="Base Execs" FontWeight="Bold" VerticalAlignment="Center"/></DataGridTextColumn.Header>
+                                    </DataGridTextColumn>
+                                    <DataGridTextColumn Binding="{Binding ExecutionDeltaDisplay}" Width="80">
+                                        <DataGridTextColumn.Header><TextBlock Text="Exec &#x0394;" FontWeight="Bold" VerticalAlignment="Center"/></DataGridTextColumn.Header>
+                                        <DataGridTextColumn.ElementStyle>
+                                            <Style TargetType="TextBlock">
+                                                <Setter Property="HorizontalAlignment" Value="Right"/>
+                                                <Setter Property="Padding" Value="0,0,5,0"/>
+                                                <Setter Property="FontWeight" Value="SemiBold"/>
+                                                <Setter Property="Foreground" Value="{Binding ExecutionDeltaBrush}"/>
+                                            </Style>
+                                        </DataGridTextColumn.ElementStyle>
+                                    </DataGridTextColumn>
+                                    <DataGridTextColumn Binding="{Binding AvgDurationMs, StringFormat=N2}" ElementStyle="{StaticResource NumericCell}" Width="100">
+                                        <DataGridTextColumn.Header><TextBlock Text="Avg Dur (ms)" FontWeight="Bold" VerticalAlignment="Center"/></DataGridTextColumn.Header>
+                                    </DataGridTextColumn>
+                                    <DataGridTextColumn Binding="{Binding BaselineAvgDurationMs, StringFormat=N2}" ElementStyle="{StaticResource NumericCell}" Width="110">
+                                        <DataGridTextColumn.Header><TextBlock Text="Base Dur (ms)" FontWeight="Bold" VerticalAlignment="Center"/></DataGridTextColumn.Header>
+                                    </DataGridTextColumn>
+                                    <DataGridTextColumn Binding="{Binding DurationDeltaDisplay}" Width="80">
+                                        <DataGridTextColumn.Header><TextBlock Text="Dur &#x0394;" FontWeight="Bold" VerticalAlignment="Center"/></DataGridTextColumn.Header>
+                                        <DataGridTextColumn.ElementStyle>
+                                            <Style TargetType="TextBlock">
+                                                <Setter Property="HorizontalAlignment" Value="Right"/>
+                                                <Setter Property="Padding" Value="0,0,5,0"/>
+                                                <Setter Property="FontWeight" Value="SemiBold"/>
+                                                <Setter Property="Foreground" Value="{Binding DurationDeltaBrush}"/>
+                                            </Style>
+                                        </DataGridTextColumn.ElementStyle>
+                                    </DataGridTextColumn>
+                                    <DataGridTextColumn Binding="{Binding AvgCpuMs, StringFormat=N2}" ElementStyle="{StaticResource NumericCell}" Width="95">
+                                        <DataGridTextColumn.Header><TextBlock Text="Avg CPU (ms)" FontWeight="Bold" VerticalAlignment="Center"/></DataGridTextColumn.Header>
+                                    </DataGridTextColumn>
+                                    <DataGridTextColumn Binding="{Binding BaselineAvgCpuMs, StringFormat=N2}" ElementStyle="{StaticResource NumericCell}" Width="110">
+                                        <DataGridTextColumn.Header><TextBlock Text="Base CPU (ms)" FontWeight="Bold" VerticalAlignment="Center"/></DataGridTextColumn.Header>
+                                    </DataGridTextColumn>
+                                    <DataGridTextColumn Binding="{Binding CpuDeltaDisplay}" Width="80">
+                                        <DataGridTextColumn.Header><TextBlock Text="CPU &#x0394;" FontWeight="Bold" VerticalAlignment="Center"/></DataGridTextColumn.Header>
+                                        <DataGridTextColumn.ElementStyle>
+                                            <Style TargetType="TextBlock">
+                                                <Setter Property="HorizontalAlignment" Value="Right"/>
+                                                <Setter Property="Padding" Value="0,0,5,0"/>
+                                                <Setter Property="FontWeight" Value="SemiBold"/>
+                                                <Setter Property="Foreground" Value="{Binding CpuDeltaBrush}"/>
+                                            </Style>
+                                        </DataGridTextColumn.ElementStyle>
+                                    </DataGridTextColumn>
+                                    <DataGridTextColumn Binding="{Binding AvgReads, StringFormat=N0}" ElementStyle="{StaticResource NumericCell}" Width="85">
+                                        <DataGridTextColumn.Header><TextBlock Text="Avg Reads" FontWeight="Bold" VerticalAlignment="Center"/></DataGridTextColumn.Header>
+                                    </DataGridTextColumn>
+                                    <DataGridTextColumn Binding="{Binding BaselineAvgReads, StringFormat=N0}" ElementStyle="{StaticResource NumericCell}" Width="95">
+                                        <DataGridTextColumn.Header><TextBlock Text="Base Reads" FontWeight="Bold" VerticalAlignment="Center"/></DataGridTextColumn.Header>
+                                    </DataGridTextColumn>
+                                    <DataGridTextColumn Binding="{Binding ReadsDeltaDisplay}" Width="80">
+                                        <DataGridTextColumn.Header><TextBlock Text="Reads &#x0394;" FontWeight="Bold" VerticalAlignment="Center"/></DataGridTextColumn.Header>
+                                        <DataGridTextColumn.ElementStyle>
+                                            <Style TargetType="TextBlock">
+                                                <Setter Property="HorizontalAlignment" Value="Right"/>
+                                                <Setter Property="Padding" Value="0,0,5,0"/>
+                                                <Setter Property="FontWeight" Value="SemiBold"/>
+                                                <Setter Property="Foreground" Value="{Binding ReadsDeltaBrush}"/>
+                                            </Style>
+                                        </DataGridTextColumn.ElementStyle>
+                                    </DataGridTextColumn>
+                                    <DataGridTextColumn Binding="{Binding QueryHash}" Width="140">
+                                        <DataGridTextColumn.Header><TextBlock Text="Query Hash" FontWeight="Bold" VerticalAlignment="Center"/></DataGridTextColumn.Header>
+                                    </DataGridTextColumn>
+                                    <DataGridTemplateColumn Width="500">
+                                        <DataGridTemplateColumn.Header><TextBlock Text="Query Text" FontWeight="Bold" VerticalAlignment="Center"/></DataGridTemplateColumn.Header>
+                                        <DataGridTemplateColumn.CellTemplate>
+                                            <DataTemplate>
+                                                <TextBlock Text="{Binding QueryText}" TextWrapping="Wrap" MaxHeight="90" Margin="5,2"
+                                                           ToolTip="{Binding QueryText}"/>
+                                            </DataTemplate>
+                                        </DataGridTemplateColumn.CellTemplate>
+                                    </DataGridTemplateColumn>
+                                </DataGrid.Columns>
+                            </DataGrid>
                             </Grid>
                         </TabItem>
                         <TabItem Header="Top Procedures by Duration">
                             <Grid>
                                 <Grid.RowDefinitions>
+                                    <RowDefinition Height="Auto"/>
                                     <RowDefinition Height="Auto"/>
                                     <RowDefinition Height="*"/>
                                 </Grid.RowDefinitions>
                                 <controls:TimeRangeSlicerControl x:Name="ProcStatsSlicer" Grid.Row="0"/>
-                            <DataGrid Grid.Row="1" x:Name="ProcedureStatsGrid"
+                                <TextBlock x:Name="ProcStatsComparisonBanner" Grid.Row="1" Visibility="Collapsed"
+                                           Padding="8,4" FontWeight="Bold"
+                                           Foreground="{DynamicResource ForegroundBrush}"
+                                           Background="#2244AAFF"/>
+                            <DataGrid Grid.Row="2" x:Name="ProcedureStatsGrid"
                                       AutoGenerateColumns="False" IsReadOnly="True"
                                       RowStyle="{StaticResource GridRowStyle}"
                                       HeadersVisibility="Column" GridLinesVisibility="Horizontal"
@@ -590,16 +708,88 @@
                                     </DataGridTemplateColumn>
                                 </DataGrid.Columns>
                             </DataGrid>
+                            <DataGrid Grid.Row="2" x:Name="ProcStatsComparisonGrid" Visibility="Collapsed"
+                                      AutoGenerateColumns="False" IsReadOnly="True"
+                                      RowStyle="{StaticResource GridRowStyle}"
+                                      HeadersVisibility="Column" GridLinesVisibility="Horizontal"
+                                      CanUserSortColumns="True">
+                                <DataGrid.Columns>
+                                    <DataGridTextColumn Binding="{Binding StatusBadge}" Width="55">
+                                        <DataGridTextColumn.Header><TextBlock Text="" FontWeight="Bold"/></DataGridTextColumn.Header>
+                                        <DataGridTextColumn.ElementStyle>
+                                            <Style TargetType="TextBlock">
+                                                <Setter Property="FontWeight" Value="Bold"/>
+                                                <Setter Property="HorizontalAlignment" Value="Center"/>
+                                                <Style.Triggers>
+                                                    <DataTrigger Binding="{Binding IsNew}" Value="True"><Setter Property="Foreground" Value="#FF6B6B"/></DataTrigger>
+                                                    <DataTrigger Binding="{Binding IsGone}" Value="True"><Setter Property="Foreground" Value="#888888"/></DataTrigger>
+                                                </Style.Triggers>
+                                            </Style>
+                                        </DataGridTextColumn.ElementStyle>
+                                    </DataGridTextColumn>
+                                    <DataGridTextColumn Binding="{Binding DatabaseName}" Width="120">
+                                        <DataGridTextColumn.Header><TextBlock Text="Database" FontWeight="Bold"/></DataGridTextColumn.Header>
+                                    </DataGridTextColumn>
+                                    <DataGridTextColumn Binding="{Binding FullName}" Width="200">
+                                        <DataGridTextColumn.Header><TextBlock Text="Procedure" FontWeight="Bold"/></DataGridTextColumn.Header>
+                                    </DataGridTextColumn>
+                                    <DataGridTextColumn Binding="{Binding ExecutionCount, StringFormat=N0}" ElementStyle="{StaticResource NumericCell}" Width="90">
+                                        <DataGridTextColumn.Header><TextBlock Text="Executions" FontWeight="Bold"/></DataGridTextColumn.Header>
+                                    </DataGridTextColumn>
+                                    <DataGridTextColumn Binding="{Binding BaselineExecutionCount, StringFormat=N0}" ElementStyle="{StaticResource NumericCell}" Width="100">
+                                        <DataGridTextColumn.Header><TextBlock Text="Base Execs" FontWeight="Bold"/></DataGridTextColumn.Header>
+                                    </DataGridTextColumn>
+                                    <DataGridTextColumn Binding="{Binding ExecutionDeltaDisplay}" Width="80">
+                                        <DataGridTextColumn.Header><TextBlock Text="Exec &#x0394;" FontWeight="Bold"/></DataGridTextColumn.Header>
+                                        <DataGridTextColumn.ElementStyle><Style TargetType="TextBlock"><Setter Property="HorizontalAlignment" Value="Right"/><Setter Property="Padding" Value="0,0,5,0"/><Setter Property="FontWeight" Value="SemiBold"/><Setter Property="Foreground" Value="{Binding ExecutionDeltaBrush}"/></Style></DataGridTextColumn.ElementStyle>
+                                    </DataGridTextColumn>
+                                    <DataGridTextColumn Binding="{Binding AvgDurationMs, StringFormat=N2}" ElementStyle="{StaticResource NumericCell}" Width="100">
+                                        <DataGridTextColumn.Header><TextBlock Text="Avg Dur (ms)" FontWeight="Bold"/></DataGridTextColumn.Header>
+                                    </DataGridTextColumn>
+                                    <DataGridTextColumn Binding="{Binding BaselineAvgDurationMs, StringFormat=N2}" ElementStyle="{StaticResource NumericCell}" Width="110">
+                                        <DataGridTextColumn.Header><TextBlock Text="Base Dur (ms)" FontWeight="Bold"/></DataGridTextColumn.Header>
+                                    </DataGridTextColumn>
+                                    <DataGridTextColumn Binding="{Binding DurationDeltaDisplay}" Width="80">
+                                        <DataGridTextColumn.Header><TextBlock Text="Dur &#x0394;" FontWeight="Bold"/></DataGridTextColumn.Header>
+                                        <DataGridTextColumn.ElementStyle><Style TargetType="TextBlock"><Setter Property="HorizontalAlignment" Value="Right"/><Setter Property="Padding" Value="0,0,5,0"/><Setter Property="FontWeight" Value="SemiBold"/><Setter Property="Foreground" Value="{Binding DurationDeltaBrush}"/></Style></DataGridTextColumn.ElementStyle>
+                                    </DataGridTextColumn>
+                                    <DataGridTextColumn Binding="{Binding AvgCpuMs, StringFormat=N2}" ElementStyle="{StaticResource NumericCell}" Width="95">
+                                        <DataGridTextColumn.Header><TextBlock Text="Avg CPU (ms)" FontWeight="Bold"/></DataGridTextColumn.Header>
+                                    </DataGridTextColumn>
+                                    <DataGridTextColumn Binding="{Binding BaselineAvgCpuMs, StringFormat=N2}" ElementStyle="{StaticResource NumericCell}" Width="110">
+                                        <DataGridTextColumn.Header><TextBlock Text="Base CPU (ms)" FontWeight="Bold"/></DataGridTextColumn.Header>
+                                    </DataGridTextColumn>
+                                    <DataGridTextColumn Binding="{Binding CpuDeltaDisplay}" Width="80">
+                                        <DataGridTextColumn.Header><TextBlock Text="CPU &#x0394;" FontWeight="Bold"/></DataGridTextColumn.Header>
+                                        <DataGridTextColumn.ElementStyle><Style TargetType="TextBlock"><Setter Property="HorizontalAlignment" Value="Right"/><Setter Property="Padding" Value="0,0,5,0"/><Setter Property="FontWeight" Value="SemiBold"/><Setter Property="Foreground" Value="{Binding CpuDeltaBrush}"/></Style></DataGridTextColumn.ElementStyle>
+                                    </DataGridTextColumn>
+                                    <DataGridTextColumn Binding="{Binding AvgReads, StringFormat=N0}" ElementStyle="{StaticResource NumericCell}" Width="85">
+                                        <DataGridTextColumn.Header><TextBlock Text="Avg Reads" FontWeight="Bold"/></DataGridTextColumn.Header>
+                                    </DataGridTextColumn>
+                                    <DataGridTextColumn Binding="{Binding BaselineAvgReads, StringFormat=N0}" ElementStyle="{StaticResource NumericCell}" Width="95">
+                                        <DataGridTextColumn.Header><TextBlock Text="Base Reads" FontWeight="Bold"/></DataGridTextColumn.Header>
+                                    </DataGridTextColumn>
+                                    <DataGridTextColumn Binding="{Binding ReadsDeltaDisplay}" Width="80">
+                                        <DataGridTextColumn.Header><TextBlock Text="Reads &#x0394;" FontWeight="Bold"/></DataGridTextColumn.Header>
+                                        <DataGridTextColumn.ElementStyle><Style TargetType="TextBlock"><Setter Property="HorizontalAlignment" Value="Right"/><Setter Property="Padding" Value="0,0,5,0"/><Setter Property="FontWeight" Value="SemiBold"/><Setter Property="Foreground" Value="{Binding ReadsDeltaBrush}"/></Style></DataGridTextColumn.ElementStyle>
+                                    </DataGridTextColumn>
+                                </DataGrid.Columns>
+                            </DataGrid>
                             </Grid>
                         </TabItem>
                         <TabItem Header="Query Store by Duration">
                             <Grid>
                                 <Grid.RowDefinitions>
+                                    <RowDefinition Height="Auto"/>
                                     <RowDefinition Height="Auto"/>
                                     <RowDefinition Height="*"/>
                                 </Grid.RowDefinitions>
                                 <controls:TimeRangeSlicerControl x:Name="QueryStoreSlicer" Grid.Row="0"/>
-                            <DataGrid Grid.Row="1" x:Name="QueryStoreGrid"
+                                <TextBlock x:Name="QueryStoreComparisonBanner" Grid.Row="1" Visibility="Collapsed"
+                                           Padding="8,4" FontWeight="Bold"
+                                           Foreground="{DynamicResource ForegroundBrush}"
+                                           Background="#2244AAFF"/>
+                            <DataGrid Grid.Row="2" x:Name="QueryStoreGrid"
                                       AutoGenerateColumns="False" IsReadOnly="True"
                                       RowStyle="{StaticResource GridRowStyle}"
                                       HeadersVisibility="Column" GridLinesVisibility="Horizontal"
@@ -706,6 +896,82 @@
                                     </DataGridTemplateColumn>
                                 </DataGrid.Columns>
                             </DataGrid>
+                            <DataGrid Grid.Row="2" x:Name="QueryStoreComparisonGrid" Visibility="Collapsed"
+                                      AutoGenerateColumns="False" IsReadOnly="True"
+                                      RowStyle="{StaticResource GridRowStyle}"
+                                      HeadersVisibility="Column" GridLinesVisibility="Horizontal"
+                                      CanUserSortColumns="True">
+                                <DataGrid.Columns>
+                                    <DataGridTextColumn Binding="{Binding StatusBadge}" Width="55">
+                                        <DataGridTextColumn.Header><TextBlock Text="" FontWeight="Bold"/></DataGridTextColumn.Header>
+                                        <DataGridTextColumn.ElementStyle>
+                                            <Style TargetType="TextBlock">
+                                                <Setter Property="FontWeight" Value="Bold"/>
+                                                <Setter Property="HorizontalAlignment" Value="Center"/>
+                                                <Style.Triggers>
+                                                    <DataTrigger Binding="{Binding IsNew}" Value="True"><Setter Property="Foreground" Value="#FF6B6B"/></DataTrigger>
+                                                    <DataTrigger Binding="{Binding IsGone}" Value="True"><Setter Property="Foreground" Value="#888888"/></DataTrigger>
+                                                </Style.Triggers>
+                                            </Style>
+                                        </DataGridTextColumn.ElementStyle>
+                                    </DataGridTextColumn>
+                                    <DataGridTextColumn Binding="{Binding DatabaseName}" Width="120">
+                                        <DataGridTextColumn.Header><TextBlock Text="Database" FontWeight="Bold"/></DataGridTextColumn.Header>
+                                    </DataGridTextColumn>
+                                    <DataGridTextColumn Binding="{Binding ExecutionCount, StringFormat=N0}" ElementStyle="{StaticResource NumericCell}" Width="90">
+                                        <DataGridTextColumn.Header><TextBlock Text="Executions" FontWeight="Bold"/></DataGridTextColumn.Header>
+                                    </DataGridTextColumn>
+                                    <DataGridTextColumn Binding="{Binding BaselineExecutionCount, StringFormat=N0}" ElementStyle="{StaticResource NumericCell}" Width="100">
+                                        <DataGridTextColumn.Header><TextBlock Text="Base Execs" FontWeight="Bold"/></DataGridTextColumn.Header>
+                                    </DataGridTextColumn>
+                                    <DataGridTextColumn Binding="{Binding ExecutionDeltaDisplay}" Width="80">
+                                        <DataGridTextColumn.Header><TextBlock Text="Exec &#x0394;" FontWeight="Bold"/></DataGridTextColumn.Header>
+                                        <DataGridTextColumn.ElementStyle><Style TargetType="TextBlock"><Setter Property="HorizontalAlignment" Value="Right"/><Setter Property="Padding" Value="0,0,5,0"/><Setter Property="FontWeight" Value="SemiBold"/><Setter Property="Foreground" Value="{Binding ExecutionDeltaBrush}"/></Style></DataGridTextColumn.ElementStyle>
+                                    </DataGridTextColumn>
+                                    <DataGridTextColumn Binding="{Binding AvgDurationMs, StringFormat=N2}" ElementStyle="{StaticResource NumericCell}" Width="100">
+                                        <DataGridTextColumn.Header><TextBlock Text="Avg Dur (ms)" FontWeight="Bold"/></DataGridTextColumn.Header>
+                                    </DataGridTextColumn>
+                                    <DataGridTextColumn Binding="{Binding BaselineAvgDurationMs, StringFormat=N2}" ElementStyle="{StaticResource NumericCell}" Width="110">
+                                        <DataGridTextColumn.Header><TextBlock Text="Base Dur (ms)" FontWeight="Bold"/></DataGridTextColumn.Header>
+                                    </DataGridTextColumn>
+                                    <DataGridTextColumn Binding="{Binding DurationDeltaDisplay}" Width="80">
+                                        <DataGridTextColumn.Header><TextBlock Text="Dur &#x0394;" FontWeight="Bold"/></DataGridTextColumn.Header>
+                                        <DataGridTextColumn.ElementStyle><Style TargetType="TextBlock"><Setter Property="HorizontalAlignment" Value="Right"/><Setter Property="Padding" Value="0,0,5,0"/><Setter Property="FontWeight" Value="SemiBold"/><Setter Property="Foreground" Value="{Binding DurationDeltaBrush}"/></Style></DataGridTextColumn.ElementStyle>
+                                    </DataGridTextColumn>
+                                    <DataGridTextColumn Binding="{Binding AvgCpuMs, StringFormat=N2}" ElementStyle="{StaticResource NumericCell}" Width="95">
+                                        <DataGridTextColumn.Header><TextBlock Text="Avg CPU (ms)" FontWeight="Bold"/></DataGridTextColumn.Header>
+                                    </DataGridTextColumn>
+                                    <DataGridTextColumn Binding="{Binding BaselineAvgCpuMs, StringFormat=N2}" ElementStyle="{StaticResource NumericCell}" Width="110">
+                                        <DataGridTextColumn.Header><TextBlock Text="Base CPU (ms)" FontWeight="Bold"/></DataGridTextColumn.Header>
+                                    </DataGridTextColumn>
+                                    <DataGridTextColumn Binding="{Binding CpuDeltaDisplay}" Width="80">
+                                        <DataGridTextColumn.Header><TextBlock Text="CPU &#x0394;" FontWeight="Bold"/></DataGridTextColumn.Header>
+                                        <DataGridTextColumn.ElementStyle><Style TargetType="TextBlock"><Setter Property="HorizontalAlignment" Value="Right"/><Setter Property="Padding" Value="0,0,5,0"/><Setter Property="FontWeight" Value="SemiBold"/><Setter Property="Foreground" Value="{Binding CpuDeltaBrush}"/></Style></DataGridTextColumn.ElementStyle>
+                                    </DataGridTextColumn>
+                                    <DataGridTextColumn Binding="{Binding AvgReads, StringFormat=N0}" ElementStyle="{StaticResource NumericCell}" Width="85">
+                                        <DataGridTextColumn.Header><TextBlock Text="Avg Reads" FontWeight="Bold"/></DataGridTextColumn.Header>
+                                    </DataGridTextColumn>
+                                    <DataGridTextColumn Binding="{Binding BaselineAvgReads, StringFormat=N0}" ElementStyle="{StaticResource NumericCell}" Width="95">
+                                        <DataGridTextColumn.Header><TextBlock Text="Base Reads" FontWeight="Bold"/></DataGridTextColumn.Header>
+                                    </DataGridTextColumn>
+                                    <DataGridTextColumn Binding="{Binding ReadsDeltaDisplay}" Width="80">
+                                        <DataGridTextColumn.Header><TextBlock Text="Reads &#x0394;" FontWeight="Bold"/></DataGridTextColumn.Header>
+                                        <DataGridTextColumn.ElementStyle><Style TargetType="TextBlock"><Setter Property="HorizontalAlignment" Value="Right"/><Setter Property="Padding" Value="0,0,5,0"/><Setter Property="FontWeight" Value="SemiBold"/><Setter Property="Foreground" Value="{Binding ReadsDeltaBrush}"/></Style></DataGridTextColumn.ElementStyle>
+                                    </DataGridTextColumn>
+                                    <DataGridTextColumn Binding="{Binding QueryHash}" Width="140">
+                                        <DataGridTextColumn.Header><TextBlock Text="Query Hash" FontWeight="Bold"/></DataGridTextColumn.Header>
+                                    </DataGridTextColumn>
+                                    <DataGridTemplateColumn Width="500">
+                                        <DataGridTemplateColumn.Header><TextBlock Text="Query Text" FontWeight="Bold"/></DataGridTemplateColumn.Header>
+                                        <DataGridTemplateColumn.CellTemplate>
+                                            <DataTemplate>
+                                                <TextBlock Text="{Binding QueryText}" TextWrapping="Wrap" MaxHeight="90" Margin="5,2"
+                                                           ToolTip="{Binding QueryText}"/>
+                                            </DataTemplate>
+                                        </DataGridTemplateColumn.CellTemplate>
+                                    </DataGridTemplateColumn>
+                                </DataGrid.Columns>
+                            </DataGrid>
                             </Grid>
                         </TabItem>
                         <TabItem Header="Query Heatmap">
diff --git a/Lite/Controls/ServerTab.xaml.cs b/Lite/Controls/ServerTab.xaml.cs
index a3c8a9d..6f3a374 100644
--- a/Lite/Controls/ServerTab.xaml.cs
+++ b/Lite/Controls/ServerTab.xaml.cs
@@ -636,6 +636,20 @@ private async void CompareToCombo_SelectionChanged(object sender, SelectionChang
         }
 
         await RefreshOverviewAsync(hoursBack, fromDate, toDate);
+
+        // Also refresh comparison grids
+        try
+        {
+            var currentEnd = toDate ?? DateTime.UtcNow;
+            var currentStart = fromDate ?? currentEnd.AddHours(-hoursBack);
+            await RefreshQueryStatsComparisonAsync(currentStart, currentEnd);
+            await RefreshProcStatsComparisonAsync(currentStart, currentEnd);
+            await RefreshQueryStoreComparisonAsync(currentStart, currentEnd);
+        }
+        catch (Exception ex)
+        {
+            AppLogger.Info("ServerTab", $"[{_server.DisplayName}] Comparison refresh failed: {ex.Message}");
+        }
     }
 
     /// <summary>
@@ -960,12 +974,27 @@ await System.Threading.Tasks.Task.WhenAll(
         LiveSnapshotIndicator.Text = "";
         _queryStatsFilterMgr!.UpdateData(queryStatsTask.Result);
         SetDefaultSortIfNone(QueryStatsGrid, "TotalElapsedMs", ListSortDirection.Descending);
+        {
+            var cEnd = toDate ?? DateTime.UtcNow;
+            var cStart = fromDate ?? cEnd.AddHours(-hoursBack);
+            await RefreshQueryStatsComparisonAsync(cStart, cEnd);
+        }
         _procStatsFilterMgr!.UpdateData(procStatsTask.Result);
         SetDefaultSortIfNone(ProcedureStatsGrid, "TotalElapsedMs", ListSortDirection.Descending);
+        {
+            var cEnd2 = toDate ?? DateTime.UtcNow;
+            var cStart2 = fromDate ?? cEnd2.AddHours(-hoursBack);
+            await RefreshProcStatsComparisonAsync(cStart2, cEnd2);
+        }
         _blockedProcessFilterMgr!.UpdateData(blockedProcessTask.Result);
         _deadlockFilterMgr!.UpdateData(DeadlockProcessDetail.ParseFromRows(deadlockTask.Result));
         _queryStoreFilterMgr!.UpdateData(queryStoreTask.Result);
         SetDefaultSortIfNone(QueryStoreGrid, "TotalDurationMs", ListSortDirection.Descending);
+        {
+            var cEnd3 = toDate ?? DateTime.UtcNow;
+            var cStart3 = fromDate ?? cEnd3.AddHours(-hoursBack);
+            await RefreshQueryStoreComparisonAsync(cStart3, cEnd3);
+        }
         _serverConfigFilterMgr!.UpdateData(serverConfigTask.Result);
         _databaseConfigFilterMgr!.UpdateData(databaseConfigTask.Result);
         _dbScopedConfigFilterMgr!.UpdateData(databaseScopedConfigTask.Result);
@@ -1076,18 +1105,33 @@ private async System.Threading.Tasks.Task RefreshQueriesAsync(int hoursBack, Dat
                         _queryStatsFilterMgr!.UpdateData(queryStats);
                         SetDefaultSortIfNone(QueryStatsGrid, "TotalElapsedMs", ListSortDirection.Descending);
                         _ = LoadQueryStatsSlicerAsync();
+                        {
+                            var cEnd = toDate ?? DateTime.UtcNow;
+                            var cStart = fromDate ?? cEnd.AddHours(-hoursBack);
+                            await RefreshQueryStatsComparisonAsync(cStart, cEnd);
+                        }
                         break;
                     case 3: // Top Procedures by Duration
                         var procStats = await _dataService.GetTopProceduresByCpuAsync(_serverId, hoursBack, 50, fromDate, toDate, UtcOffsetMinutes);
                         _procStatsFilterMgr!.UpdateData(procStats);
                         SetDefaultSortIfNone(ProcedureStatsGrid, "TotalElapsedMs", ListSortDirection.Descending);
                         _ = LoadProcStatsSlicerAsync();
+                        {
+                            var cEnd = toDate ?? DateTime.UtcNow;
+                            var cStart = fromDate ?? cEnd.AddHours(-hoursBack);
+                            await RefreshProcStatsComparisonAsync(cStart, cEnd);
+                        }
                         break;
                     case 4: // Query Store by Duration
                         var qsData = await _dataService.GetQueryStoreTopQueriesAsync(_serverId, hoursBack, 50, fromDate, toDate);
                         _queryStoreFilterMgr!.UpdateData(qsData);
                         SetDefaultSortIfNone(QueryStoreGrid, "TotalDurationMs", ListSortDirection.Descending);
                         _ = LoadQueryStoreSlicerAsync();
+                        {
+                            var cEnd = toDate ?? DateTime.UtcNow;
+                            var cStart = fromDate ?? cEnd.AddHours(-hoursBack);
+                            await RefreshQueryStoreComparisonAsync(cStart, cEnd);
+                        }
                         break;
                     case 5: // Query Heatmap
                         var hmMetric = (HeatmapMetric)HeatmapMetricCombo.SelectedIndex;
@@ -1127,12 +1171,27 @@ await System.Threading.Tasks.Task.WhenAll(
             _queryStatsFilterMgr!.UpdateData(queryStatsTask.Result);
             SetDefaultSortIfNone(QueryStatsGrid, "TotalElapsedMs", ListSortDirection.Descending);
             _ = LoadQueryStatsSlicerAsync();
+            {
+                var cEnd = toDate ?? DateTime.UtcNow;
+                var cStart = fromDate ?? cEnd.AddHours(-hoursBack);
+                await RefreshQueryStatsComparisonAsync(cStart, cEnd);
+            }
             _procStatsFilterMgr!.UpdateData(procStatsTask.Result);
             SetDefaultSortIfNone(ProcedureStatsGrid, "TotalElapsedMs", ListSortDirection.Descending);
             _ = LoadProcStatsSlicerAsync();
+            {
+                var cEnd2 = toDate ?? DateTime.UtcNow;
+                var cStart2 = fromDate ?? cEnd2.AddHours(-hoursBack);
+                await RefreshProcStatsComparisonAsync(cStart2, cEnd2);
+            }
             _queryStoreFilterMgr!.UpdateData(queryStoreTask.Result);
             SetDefaultSortIfNone(QueryStoreGrid, "TotalDurationMs", ListSortDirection.Descending);
             _ = LoadQueryStoreSlicerAsync();
+            {
+                var cEnd3 = toDate ?? DateTime.UtcNow;
+                var cStart3 = fromDate ?? cEnd3.AddHours(-hoursBack);
+                await RefreshQueryStoreComparisonAsync(cStart3, cEnd3);
+            }
 
             UpdateQueryDurationTrendChart(queryDurationTrendTask.Result);
             UpdateProcDurationTrendChart(procDurationTrendTask.Result);
@@ -1146,6 +1205,120 @@ await System.Threading.Tasks.Task.WhenAll(
         }
     }
 
+    private bool IsQueryStatsComparisonActive => GetComparisonRange() != null;
+
+    private void SetQueryStatsComparisonMode(bool active, (DateTime From, DateTime To)? baselineRange = null)
+    {
+        QueryStatsGrid.Visibility = active ? System.Windows.Visibility.Collapsed : System.Windows.Visibility.Visible;
+        QueryStatsComparisonGrid.Visibility = active ? System.Windows.Visibility.Visible : System.Windows.Visibility.Collapsed;
+        QueryStatsComparisonBanner.Visibility = active ? System.Windows.Visibility.Visible : System.Windows.Visibility.Collapsed;
+
+        if (active && baselineRange.HasValue)
+        {
+            var from = ServerTimeHelper.FormatServerTime(baselineRange.Value.From);
+            var to = ServerTimeHelper.FormatServerTime(baselineRange.Value.To);
+            QueryStatsComparisonBanner.Text = $"Comparing against baseline: {from} \u2192 {to}";
+        }
+    }
+
+    private async System.Threading.Tasks.Task RefreshQueryStatsComparisonAsync(DateTime currentStart, DateTime currentEnd)
+    {
+        var baselineRange = GetComparisonRange();
+        if (baselineRange == null)
+        {
+            SetQueryStatsComparisonMode(false);
+            return;
+        }
+
+        SetQueryStatsComparisonMode(true, baselineRange);
+
+        var items = await _dataService.GetQueryStatsComparisonAsync(
+            _serverId, currentStart, currentEnd,
+            baselineRange.Value.From, baselineRange.Value.To);
+
+        // Sort: NEW first, then by duration delta descending, GONE last
+        var sorted = items
+            .OrderBy(x => x.SortGroup)
+            .ThenByDescending(x => x.SortableDurationDelta)
+            .ToList();
+
+        QueryStatsComparisonGrid.ItemsSource = sorted;
+    }
+
+    private void SetProcStatsComparisonMode(bool active, (DateTime From, DateTime To)? baselineRange = null)
+    {
+        ProcedureStatsGrid.Visibility = active ? System.Windows.Visibility.Collapsed : System.Windows.Visibility.Visible;
+        ProcStatsComparisonGrid.Visibility = active ? System.Windows.Visibility.Visible : System.Windows.Visibility.Collapsed;
+        ProcStatsComparisonBanner.Visibility = active ? System.Windows.Visibility.Visible : System.Windows.Visibility.Collapsed;
+
+        if (active && baselineRange.HasValue)
+        {
+            var from = ServerTimeHelper.FormatServerTime(baselineRange.Value.From);
+            var to = ServerTimeHelper.FormatServerTime(baselineRange.Value.To);
+            ProcStatsComparisonBanner.Text = $"Comparing against baseline: {from} \u2192 {to}";
+        }
+    }
+
+    private async System.Threading.Tasks.Task RefreshProcStatsComparisonAsync(DateTime currentStart, DateTime currentEnd)
+    {
+        var baselineRange = GetComparisonRange();
+        if (baselineRange == null)
+        {
+            SetProcStatsComparisonMode(false);
+            return;
+        }
+
+        SetProcStatsComparisonMode(true, baselineRange);
+
+        var items = await _dataService.GetProcedureStatsComparisonAsync(
+            _serverId, currentStart, currentEnd,
+            baselineRange.Value.From, baselineRange.Value.To);
+
+        var sorted = items
+            .OrderBy(x => x.SortGroup)
+            .ThenByDescending(x => x.SortableDurationDelta)
+            .ToList();
+
+        ProcStatsComparisonGrid.ItemsSource = sorted;
+    }
+
+    private void SetQueryStoreComparisonMode(bool active, (DateTime From, DateTime To)? baselineRange = null)
+    {
+        QueryStoreGrid.Visibility = active ? System.Windows.Visibility.Collapsed : System.Windows.Visibility.Visible;
+        QueryStoreComparisonGrid.Visibility = active ? System.Windows.Visibility.Visible : System.Windows.Visibility.Collapsed;
+        QueryStoreComparisonBanner.Visibility = active ? System.Windows.Visibility.Visible : System.Windows.Visibility.Collapsed;
+
+        if (active && baselineRange.HasValue)
+        {
+            var from = ServerTimeHelper.FormatServerTime(baselineRange.Value.From);
+            var to = ServerTimeHelper.FormatServerTime(baselineRange.Value.To);
+            QueryStoreComparisonBanner.Text = $"Comparing against baseline: {from} \u2192 {to}";
+        }
+    }
+
+    private async System.Threading.Tasks.Task RefreshQueryStoreComparisonAsync(DateTime currentStart, DateTime currentEnd)
+    {
+        var baselineRange = GetComparisonRange();
+        if (baselineRange == null)
+        {
+            SetQueryStoreComparisonMode(false);
+            return;
+        }
+
+        SetQueryStoreComparisonMode(true, baselineRange);
+
+        var items = await _dataService.GetQueryStoreComparisonAsync(
+            _serverId, currentStart, currentEnd,
+            baselineRange.Value.From, baselineRange.Value.To);
+
+        var sorted = items
+            .OrderBy(x => x.SortGroup)
+            .ThenByDescending(x => x.SortableDurationDelta)
+            .ToList();
+
+        QueryStoreComparisonGrid.ItemsSource = sorted;
+    }
+
     /// <summary>Tab 3 — CPU</summary>
     /// <summary>Tab 0 — Overview (Correlated Timeline Lanes)</summary>
     private async System.Threading.Tasks.Task RefreshOverviewAsync(int hoursBack, DateTime? fromDate, DateTime? toDate)
@@ -1591,6 +1764,8 @@ private async void MainTabControl_SelectionChanged(object sender, SelectionChang
         if (e.Source != MainTabControl && e.Source != QueriesSubTabControl
             && e.Source != MemorySubTabControl && e.Source != BlockingSubTabControl) return;
 
+        UpdateCompareDropdownState();
+
         var hoursBack = GetHoursBack();
         DateTime? fromDate = null, toDate = null;
         if (IsCustomRange)
@@ -1606,6 +1781,35 @@ private async void MainTabControl_SelectionChanged(object sender, SelectionChang
         await RefreshVisibleTabAsync(hoursBack, fromDate, toDate, subTabOnly: true);
     }
 
+    private bool IsComparisonSupportedOnCurrentTab()
+    {
+        return MainTabControl.SelectedIndex switch
+        {
+            0 => true, // Overview — correlated timeline lanes
+            2 => QueriesSubTabControl.SelectedIndex is 2 or 3 or 4, // Top Queries / Top Procedures / Query Store
+            _ => false
+        };
+    }
+
+    private void UpdateCompareDropdownState()
+    {
+        var supported = IsComparisonSupportedOnCurrentTab();
+
+        if (supported)
+        {
+            CompareToCombo.IsEnabled = true;
+            CompareToCombo.Opacity = 1.0;
+            CompareToCombo.ToolTip = "Compare current period against a baseline";
+        }
+        else
+        {
+            CompareToCombo.SelectedIndex = 0;
+            CompareToCombo.IsEnabled = false;
+            CompareToCombo.Opacity = 0.5;
+            CompareToCombo.ToolTip = "Comparison is not available for this tab";
+        }
+    }
+
     /// <summary>
     /// Wraps a query in a try/catch so it returns an empty list on failure instead of faulting.
     /// </summary>
@@ -4681,6 +4885,7 @@ private async void OnQueryStatsSlicerChanged(object? sender, Controls.SlicerRang
             var toServer = ServerTimeHelper.ToServerTime(e.EndUtc);
             var queryStats = await _dataService.GetTopQueriesByCpuAsync(_serverId, 0, 50, fromServer, toServer, UtcOffsetMinutes);
             _queryStatsFilterMgr!.UpdateData(queryStats);
+            await RefreshQueryStatsComparisonAsync(fromServer, toServer);
         }
         catch (Exception ex)
         {
@@ -4779,6 +4984,7 @@ private async void OnQueryStoreSlicerChanged(object? sender, Controls.SlicerRang
             var toServer = ServerTimeHelper.ToServerTime(e.EndUtc);
             var qsData = await _dataService.GetQueryStoreTopQueriesAsync(_serverId, 0, 50, fromServer, toServer);
             _queryStoreFilterMgr!.UpdateData(qsData);
+            await RefreshQueryStoreComparisonAsync(fromServer, toServer);
         }
         catch (Exception ex)
         {
@@ -4875,6 +5081,7 @@ private async void OnProcStatsSlicerChanged(object? sender, Controls.SlicerRange
             var toServer = ServerTimeHelper.ToServerTime(e.EndUtc);
             var procStats = await _dataService.GetTopProceduresByCpuAsync(_serverId, 0, 50, fromServer, toServer, UtcOffsetMinutes);
             _procStatsFilterMgr!.UpdateData(procStats);
+            await RefreshProcStatsComparisonAsync(fromServer, toServer);
         }
         catch (Exception ex)
         {
diff --git a/Lite/Models/ComparisonItemBase.cs b/Lite/Models/ComparisonItemBase.cs
new file mode 100644
index 0000000..e5271a8
--- /dev/null
+++ b/Lite/Models/ComparisonItemBase.cs
@@ -0,0 +1,87 @@
+/*
+ * 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.Windows.Media;
+
+namespace PerformanceMonitorLite.Models;
+
+public abstract class ComparisonItemBase
+{
+    public string DatabaseName { get; set; } = "";
+
+    // Current period
+    public long ExecutionCount { get; set; }
+    public double AvgDurationMs { get; set; }
+    public double AvgCpuMs { get; set; }
+    public double AvgReads { get; set; }
+
+    // Baseline period
+    public long BaselineExecutionCount { get; set; }
+    public double BaselineAvgDurationMs { get; set; }
+    public double BaselineAvgCpuMs { get; set; }
+    public double BaselineAvgReads { get; set; }
+
+    // Flags
+    public bool IsNew => ExecutionCount > 0 && BaselineExecutionCount == 0;
+    public bool IsGone => ExecutionCount == 0 && BaselineExecutionCount > 0;
+
+    // Delta percentages (null when baseline is zero or item is new/gone)
+    public double? DurationDeltaPct => ComputeDelta(AvgDurationMs, BaselineAvgDurationMs);
+    public double? CpuDeltaPct => ComputeDelta(AvgCpuMs, BaselineAvgCpuMs);
+    public double? ReadsDeltaPct => ComputeDelta(AvgReads, BaselineAvgReads);
+    public double? ExecutionDeltaPct => ComputeDelta(ExecutionCount, BaselineExecutionCount);
+
+    // Display helpers for grid binding
+    public string DurationDeltaDisplay => FormatDelta(DurationDeltaPct);
+    public string CpuDeltaDisplay => FormatDelta(CpuDeltaPct);
+    public string ReadsDeltaDisplay => FormatDelta(ReadsDeltaPct);
+    public string ExecutionDeltaDisplay => FormatDelta(ExecutionDeltaPct);
+
+    public string StatusBadge => IsNew ? "NEW" : IsGone ? "GONE" : "";
+
+    // Sort key: NEW at top (0), normal by delta (1), GONE at bottom (2)
+    public int SortGroup => IsNew ? 0 : IsGone ? 2 : 1;
+    public double SortableDurationDelta => DurationDeltaPct ?? (IsNew ? double.MaxValue : double.MinValue);
+
+    // Color brushes for delta columns (red = regression, green = improvement)
+    public Brush DurationDeltaBrush => GetDeltaBrush(DurationDeltaPct, 25);
+    public Brush CpuDeltaBrush => GetDeltaBrush(CpuDeltaPct, 25);
+    public Brush ReadsDeltaBrush => GetDeltaBrush(ReadsDeltaPct, 50, 25);
+    public Brush ExecutionDeltaBrush => GetDeltaBrush(ExecutionDeltaPct, 100, 50);
+
+    private static readonly Brush RedBrush = new SolidColorBrush(Color.FromRgb(0xFF, 0x6B, 0x6B));
+    private static readonly Brush GreenBrush = new SolidColorBrush(Color.FromRgb(0x4E, 0xC9, 0xB0));
+    private static readonly Brush NeutralBrush = Brushes.Transparent;
+
+    static ComparisonItemBase()
+    {
+        RedBrush.Freeze();
+        GreenBrush.Freeze();
+    }
+
+    private static Brush GetDeltaBrush(double? delta, double redThreshold, double greenThreshold = 25)
+    {
+        if (!delta.HasValue) return NeutralBrush;
+        if (delta.Value > redThreshold) return RedBrush;
+        if (delta.Value < -greenThreshold) return GreenBrush;
+        return NeutralBrush;
+    }
+
+    private static double? ComputeDelta(double current, double baseline)
+    {
+        if (baseline == 0) return null;
+        return (current - baseline) / baseline * 100.0;
+    }
+
+    private static string FormatDelta(double? delta)
+    {
+        if (!delta.HasValue) return "\u2014";
+        var sign = delta.Value >= 0 ? "+" : "";
+        return $"{sign}{delta.Value:N1}%";
+    }
+}
diff --git a/Lite/Models/ProcedureStatsComparisonItem.cs b/Lite/Models/ProcedureStatsComparisonItem.cs
new file mode 100644
index 0000000..8c010b6
--- /dev/null
+++ b/Lite/Models/ProcedureStatsComparisonItem.cs
@@ -0,0 +1,16 @@
+/*
+ * 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.
+ */
+
+namespace PerformanceMonitorLite.Models;
+
+public class ProcedureStatsComparisonItem : ComparisonItemBase
+{
+    public string SchemaName { get; set; } = "";
+    public string ObjectName { get; set; } = "";
+    public string FullName => string.IsNullOrEmpty(SchemaName) ? ObjectName : $"{SchemaName}.{ObjectName}";
+}
diff --git a/Lite/Models/QueryStatsComparisonItem.cs b/Lite/Models/QueryStatsComparisonItem.cs
new file mode 100644
index 0000000..531443e
--- /dev/null
+++ b/Lite/Models/QueryStatsComparisonItem.cs
@@ -0,0 +1,15 @@
+/*
+ * 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.
+ */
+
+namespace PerformanceMonitorLite.Models;
+
+public class QueryStatsComparisonItem : ComparisonItemBase
+{
+    public string QueryHash { get; set; } = "";
+    public string QueryText { get; set; } = "";
+}
diff --git a/Lite/Services/LocalDataService.QueryStats.cs b/Lite/Services/LocalDataService.QueryStats.cs
index 9b3fc93..4822c0a 100644
--- a/Lite/Services/LocalDataService.QueryStats.cs
+++ b/Lite/Services/LocalDataService.QueryStats.cs
@@ -184,6 +184,122 @@ ORDER BY SUM(delta_elapsed_time) DESC
         return items;
     }
 
+    /// <summary>
+    /// Gets query stats comparison between a current time range and a baseline range.
+    /// Returns delta percentages for duration, CPU, reads, and execution count.
+    /// </summary>
+    public async Task<List<Models.QueryStatsComparisonItem>> GetQueryStatsComparisonAsync(
+        int serverId,
+        DateTime currentStart, DateTime currentEnd,
+        DateTime baselineStart, DateTime baselineEnd)
+    {
+        using var _q = TimeQuery("GetQueryStatsComparisonAsync", "v_query_stats comparison");
+        using var connection = await OpenConnectionAsync();
+        using var command = connection.CreateCommand();
+
+        command.CommandText = @"
+WITH top_current AS (
+    SELECT query_hash, database_name
+    FROM v_query_stats
+    WHERE server_id = $1
+    AND   collection_time >= $2 AND collection_time <= $3
+    AND   delta_execution_count > 0
+    GROUP BY query_hash, database_name
+    ORDER BY SUM(delta_execution_count) DESC
+    LIMIT 100
+),
+top_baseline AS (
+    SELECT query_hash, database_name
+    FROM v_query_stats
+    WHERE server_id = $1
+    AND   collection_time >= $4 AND collection_time <= $5
+    AND   delta_execution_count > 0
+    GROUP BY query_hash, database_name
+    ORDER BY SUM(delta_execution_count) DESC
+    LIMIT 100
+),
+top_hashes AS (
+    SELECT DISTINCT query_hash, database_name
+    FROM (
+        SELECT * FROM top_current
+        UNION ALL
+        SELECT * FROM top_baseline
+    ) combined
+),
+current_period AS (
+    SELECT th.database_name, th.query_hash,
+           SUM(qs.delta_execution_count) AS exec_count,
+           SUM(qs.delta_elapsed_time)::DOUBLE / NULLIF(SUM(qs.delta_execution_count), 0) / 1000.0 AS avg_duration_ms,
+           SUM(qs.delta_worker_time)::DOUBLE / NULLIF(SUM(qs.delta_execution_count), 0) / 1000.0 AS avg_cpu_ms,
+           SUM(qs.delta_physical_reads)::DOUBLE / NULLIF(SUM(qs.delta_execution_count), 0) AS avg_reads,
+           MAX(qs.query_text) AS query_text
+    FROM top_hashes th
+    INNER JOIN v_query_stats qs
+      ON  qs.query_hash IS NOT DISTINCT FROM th.query_hash
+      AND qs.database_name IS NOT DISTINCT FROM th.database_name
+    WHERE qs.server_id = $1
+    AND   qs.collection_time >= $2 AND qs.collection_time <= $3
+    AND   qs.delta_execution_count > 0
+    GROUP BY th.database_name, th.query_hash
+),
+baseline_period AS (
+    SELECT th.database_name, th.query_hash,
+           SUM(qs.delta_execution_count) AS exec_count,
+           SUM(qs.delta_elapsed_time)::DOUBLE / NULLIF(SUM(qs.delta_execution_count), 0) / 1000.0 AS avg_duration_ms,
+           SUM(qs.delta_worker_time)::DOUBLE / NULLIF(SUM(qs.delta_execution_count), 0) / 1000.0 AS avg_cpu_ms,
+           SUM(qs.delta_physical_reads)::DOUBLE / NULLIF(SUM(qs.delta_execution_count), 0) AS avg_reads,
+           MAX(qs.query_text) AS query_text
+    FROM top_hashes th
+    INNER JOIN v_query_stats qs
+      ON  qs.query_hash IS NOT DISTINCT FROM th.query_hash
+      AND qs.database_name IS NOT DISTINCT FROM th.database_name
+    WHERE qs.server_id = $1
+    AND   qs.collection_time >= $4 AND qs.collection_time <= $5
+    AND   qs.delta_execution_count > 0
+    GROUP BY th.database_name, th.query_hash
+)
+SELECT COALESCE(c.database_name, b.database_name) AS database_name,
+       COALESCE(c.query_hash, b.query_hash) AS query_hash,
+       COALESCE(c.query_text, b.query_text) AS query_text,
+       c.exec_count, c.avg_duration_ms, c.avg_cpu_ms, c.avg_reads,
+       b.exec_count AS baseline_exec_count,
+       b.avg_duration_ms AS baseline_avg_duration_ms,
+       b.avg_cpu_ms AS baseline_avg_cpu_ms,
+       b.avg_reads AS baseline_avg_reads
+FROM current_period c
+FULL OUTER JOIN baseline_period b
+  ON  c.database_name IS NOT DISTINCT FROM b.database_name
+  AND c.query_hash IS NOT DISTINCT FROM b.query_hash;";
+
+        command.Parameters.Add(new DuckDBParameter { Value = serverId });
+        command.Parameters.Add(new DuckDBParameter { Value = currentStart });
+        command.Parameters.Add(new DuckDBParameter { Value = currentEnd });
+        command.Parameters.Add(new DuckDBParameter { Value = baselineStart });
+        command.Parameters.Add(new DuckDBParameter { Value = baselineEnd });
+
+        var items = new List<Models.QueryStatsComparisonItem>();
+        using var reader = await command.ExecuteReaderAsync();
+        while (await reader.ReadAsync())
+        {
+            items.Add(new Models.QueryStatsComparisonItem
+            {
+                DatabaseName = reader.IsDBNull(0) ? "" : reader.GetString(0),
+                QueryHash = reader.IsDBNull(1) ? "" : reader.GetString(1),
+                QueryText = reader.IsDBNull(2) ? "" : reader.GetString(2),
+                ExecutionCount = reader.IsDBNull(3) ? 0 : ToInt64(reader.GetValue(3)),
+                AvgDurationMs = reader.IsDBNull(4) ? 0 : ToDouble(reader.GetValue(4)),
+                AvgCpuMs = reader.IsDBNull(5) ? 0 : ToDouble(reader.GetValue(5)),
+                AvgReads = reader.IsDBNull(6) ? 0 : ToDouble(reader.GetValue(6)),
+                BaselineExecutionCount = reader.IsDBNull(7) ? 0 : ToInt64(reader.GetValue(7)),
+                BaselineAvgDurationMs = reader.IsDBNull(8) ? 0 : ToDouble(reader.GetValue(8)),
+                BaselineAvgCpuMs = reader.IsDBNull(9) ? 0 : ToDouble(reader.GetValue(9)),
+                BaselineAvgReads = reader.IsDBNull(10) ? 0 : ToDouble(reader.GetValue(10)),
+            });
+        }
+
+        return items;
+    }
+
     /// <summary>
     /// Gets collection-level history for a specific query hash (for drilldown).
     /// </summary>
@@ -574,6 +690,123 @@ ORDER BY SUM(delta_elapsed_time) DESC
 
         return items;
     }
+
+    /// <summary>
+    /// Gets procedure stats comparison between a current time range and a baseline range.
+    /// </summary>
+    public async Task<List<Models.ProcedureStatsComparisonItem>> GetProcedureStatsComparisonAsync(
+        int serverId,
+        DateTime currentStart, DateTime currentEnd,
+        DateTime baselineStart, DateTime baselineEnd)
+    {
+        using var _q = TimeQuery("GetProcedureStatsComparisonAsync", "v_procedure_stats comparison");
+        using var connection = await OpenConnectionAsync();
+        using var command = connection.CreateCommand();
+
+        command.CommandText = @"
+WITH top_current AS (
+    SELECT database_name, schema_name, object_name
+    FROM v_procedure_stats
+    WHERE server_id = $1
+    AND   collection_time >= $2 AND collection_time <= $3
+    AND   delta_execution_count > 0
+    GROUP BY database_name, schema_name, object_name
+    ORDER BY SUM(delta_execution_count) DESC
+    LIMIT 100
+),
+top_baseline AS (
+    SELECT database_name, schema_name, object_name
+    FROM v_procedure_stats
+    WHERE server_id = $1
+    AND   collection_time >= $4 AND collection_time <= $5
+    AND   delta_execution_count > 0
+    GROUP BY database_name, schema_name, object_name
+    ORDER BY SUM(delta_execution_count) DESC
+    LIMIT 100
+),
+top_procs AS (
+    SELECT DISTINCT database_name, schema_name, object_name
+    FROM (
+        SELECT * FROM top_current
+        UNION ALL
+        SELECT * FROM top_baseline
+    ) combined
+),
+current_period AS (
+    SELECT tp.database_name, tp.schema_name, tp.object_name,
+           SUM(ps.delta_execution_count) AS exec_count,
+           SUM(ps.delta_elapsed_time)::DOUBLE / NULLIF(SUM(ps.delta_execution_count), 0) / 1000.0 AS avg_duration_ms,
+           SUM(ps.delta_worker_time)::DOUBLE / NULLIF(SUM(ps.delta_execution_count), 0) / 1000.0 AS avg_cpu_ms,
+           SUM(ps.delta_physical_reads)::DOUBLE / NULLIF(SUM(ps.delta_execution_count), 0) AS avg_reads
+    FROM top_procs tp
+    INNER JOIN v_procedure_stats ps
+      ON  ps.database_name IS NOT DISTINCT FROM tp.database_name
+      AND ps.schema_name IS NOT DISTINCT FROM tp.schema_name
+      AND ps.object_name IS NOT DISTINCT FROM tp.object_name
+    WHERE ps.server_id = $1
+    AND   ps.collection_time >= $2 AND ps.collection_time <= $3
+    AND   ps.delta_execution_count > 0
+    GROUP BY tp.database_name, tp.schema_name, tp.object_name
+),
+baseline_period AS (
+    SELECT tp.database_name, tp.schema_name, tp.object_name,
+           SUM(ps.delta_execution_count) AS exec_count,
+           SUM(ps.delta_elapsed_time)::DOUBLE / NULLIF(SUM(ps.delta_execution_count), 0) / 1000.0 AS avg_duration_ms,
+           SUM(ps.delta_worker_time)::DOUBLE / NULLIF(SUM(ps.delta_execution_count), 0) / 1000.0 AS avg_cpu_ms,
+           SUM(ps.delta_physical_reads)::DOUBLE / NULLIF(SUM(ps.delta_execution_count), 0) AS avg_reads
+    FROM top_procs tp
+    INNER JOIN v_procedure_stats ps
+      ON  ps.database_name IS NOT DISTINCT FROM tp.database_name
+      AND ps.schema_name IS NOT DISTINCT FROM tp.schema_name
+      AND ps.object_name IS NOT DISTINCT FROM tp.object_name
+    WHERE ps.server_id = $1
+    AND   ps.collection_time >= $4 AND ps.collection_time <= $5
+    AND   ps.delta_execution_count > 0
+    GROUP BY tp.database_name, tp.schema_name, tp.object_name
+)
+SELECT COALESCE(c.database_name, b.database_name) AS database_name,
+       COALESCE(c.schema_name, b.schema_name) AS schema_name,
+       COALESCE(c.object_name, b.object_name) AS object_name,
+       c.exec_count, c.avg_duration_ms, c.avg_cpu_ms, c.avg_reads,
+       b.exec_count AS baseline_exec_count,
+       b.avg_duration_ms AS baseline_avg_duration_ms,
+       b.avg_cpu_ms AS baseline_avg_cpu_ms,
+       b.avg_reads AS baseline_avg_reads
+FROM current_period c
+FULL OUTER JOIN baseline_period b
+  ON  c.database_name IS NOT DISTINCT FROM b.database_name
+  AND c.schema_name IS NOT DISTINCT FROM b.schema_name
+  AND c.object_name IS NOT DISTINCT FROM b.object_name;";
+
+        command.Parameters.Add(new DuckDBParameter { Value = serverId });
+        command.Parameters.Add(new DuckDBParameter { Value = currentStart });
+        command.Parameters.Add(new DuckDBParameter { Value = currentEnd });
+        command.Parameters.Add(new DuckDBParameter { Value = baselineStart });
+        command.Parameters.Add(new DuckDBParameter { Value = baselineEnd });
+
+        var items = new List<Models.ProcedureStatsComparisonItem>();
+        using var reader = await command.ExecuteReaderAsync();
+        while (await reader.ReadAsync())
+        {
+            items.Add(new Models.ProcedureStatsComparisonItem
+            {
+                DatabaseName = reader.IsDBNull(0) ? "" : reader.GetString(0),
+                SchemaName = reader.IsDBNull(1) ? "" : reader.GetString(1),
+                ObjectName = reader.IsDBNull(2) ? "" : reader.GetString(2),
+                ExecutionCount = reader.IsDBNull(3) ? 0 : ToInt64(reader.GetValue(3)),
+                AvgDurationMs = reader.IsDBNull(4) ? 0 : ToDouble(reader.GetValue(4)),
+                AvgCpuMs = reader.IsDBNull(5) ? 0 : ToDouble(reader.GetValue(5)),
+                AvgReads = reader.IsDBNull(6) ? 0 : ToDouble(reader.GetValue(6)),
+                BaselineExecutionCount = reader.IsDBNull(7) ? 0 : ToInt64(reader.GetValue(7)),
+                BaselineAvgDurationMs = reader.IsDBNull(8) ? 0 : ToDouble(reader.GetValue(8)),
+                BaselineAvgCpuMs = reader.IsDBNull(9) ? 0 : ToDouble(reader.GetValue(9)),
+                BaselineAvgReads = reader.IsDBNull(10) ? 0 : ToDouble(reader.GetValue(10)),
+            });
+        }
+
+        return items;
+    }
+
     /// <summary>
     /// Gets query duration trend — total elapsed time per collection snapshot.
     /// </summary>
diff --git a/Lite/Services/LocalDataService.QueryStore.cs b/Lite/Services/LocalDataService.QueryStore.cs
index 6b5a8de..b19df4b 100644
--- a/Lite/Services/LocalDataService.QueryStore.cs
+++ b/Lite/Services/LocalDataService.QueryStore.cs
@@ -161,6 +161,122 @@ ORDER BY SUM(execution_count) * AVG(CAST(avg_duration_us AS DOUBLE)) DESC
         return items;
     }
 
+    /// <summary>
+    /// Gets query store comparison between a current time range and a baseline range.
+    /// Uses weighted averages (execution_count * avg_metric) for accurate aggregation.
+    /// </summary>
+    public async Task<List<Models.QueryStatsComparisonItem>> GetQueryStoreComparisonAsync(
+        int serverId,
+        DateTime currentStart, DateTime currentEnd,
+        DateTime baselineStart, DateTime baselineEnd)
+    {
+        using var _q = TimeQuery("GetQueryStoreComparisonAsync", "v_query_store_stats comparison");
+        using var connection = await OpenConnectionAsync();
+        using var command = connection.CreateCommand();
+
+        command.CommandText = @"
+WITH top_current AS (
+    SELECT database_name, query_hash
+    FROM v_query_store_stats
+    WHERE server_id = $1
+    AND   collection_time >= $2 AND collection_time <= $3
+    AND   execution_count > 0
+    GROUP BY database_name, query_hash
+    ORDER BY SUM(execution_count) DESC
+    LIMIT 100
+),
+top_baseline AS (
+    SELECT database_name, query_hash
+    FROM v_query_store_stats
+    WHERE server_id = $1
+    AND   collection_time >= $4 AND collection_time <= $5
+    AND   execution_count > 0
+    GROUP BY database_name, query_hash
+    ORDER BY SUM(execution_count) DESC
+    LIMIT 100
+),
+top_hashes AS (
+    SELECT DISTINCT database_name, query_hash
+    FROM (
+        SELECT * FROM top_current
+        UNION ALL
+        SELECT * FROM top_baseline
+    ) combined
+),
+current_period AS (
+    SELECT th.database_name, th.query_hash,
+           SUM(qs.execution_count) AS exec_count,
+           SUM(qs.execution_count * qs.avg_duration_us::DOUBLE) / NULLIF(SUM(qs.execution_count), 0) / 1000.0 AS avg_duration_ms,
+           SUM(qs.execution_count * qs.avg_cpu_time_us::DOUBLE) / NULLIF(SUM(qs.execution_count), 0) / 1000.0 AS avg_cpu_ms,
+           SUM(qs.execution_count * qs.avg_logical_io_reads::DOUBLE) / NULLIF(SUM(qs.execution_count), 0) AS avg_reads,
+           MAX(qs.query_text) AS query_text
+    FROM top_hashes th
+    INNER JOIN v_query_store_stats qs
+      ON  qs.query_hash IS NOT DISTINCT FROM th.query_hash
+      AND qs.database_name IS NOT DISTINCT FROM th.database_name
+    WHERE qs.server_id = $1
+    AND   qs.collection_time >= $2 AND qs.collection_time <= $3
+    AND   qs.execution_count > 0
+    GROUP BY th.database_name, th.query_hash
+),
+baseline_period AS (
+    SELECT th.database_name, th.query_hash,
+           SUM(qs.execution_count) AS exec_count,
+           SUM(qs.execution_count * qs.avg_duration_us::DOUBLE) / NULLIF(SUM(qs.execution_count), 0) / 1000.0 AS avg_duration_ms,
+           SUM(qs.execution_count * qs.avg_cpu_time_us::DOUBLE) / NULLIF(SUM(qs.execution_count), 0) / 1000.0 AS avg_cpu_ms,
+           SUM(qs.execution_count * qs.avg_logical_io_reads::DOUBLE) / NULLIF(SUM(qs.execution_count), 0) AS avg_reads,
+           MAX(qs.query_text) AS query_text
+    FROM top_hashes th
+    INNER JOIN v_query_store_stats qs
+      ON  qs.query_hash IS NOT DISTINCT FROM th.query_hash
+      AND qs.database_name IS NOT DISTINCT FROM th.database_name
+    WHERE qs.server_id = $1
+    AND   qs.collection_time >= $4 AND qs.collection_time <= $5
+    AND   qs.execution_count > 0
+    GROUP BY th.database_name, th.query_hash
+)
+SELECT COALESCE(c.database_name, b.database_name) AS database_name,
+       COALESCE(c.query_hash, b.query_hash) AS query_hash,
+       COALESCE(c.query_text, b.query_text) AS query_text,
+       c.exec_count, c.avg_duration_ms, c.avg_cpu_ms, c.avg_reads,
+       b.exec_count AS baseline_exec_count,
+       b.avg_duration_ms AS baseline_avg_duration_ms,
+       b.avg_cpu_ms AS baseline_avg_cpu_ms,
+       b.avg_reads AS baseline_avg_reads
+FROM current_period c
+FULL OUTER JOIN baseline_period b
+  ON  c.database_name IS NOT DISTINCT FROM b.database_name
+  AND c.query_hash IS NOT DISTINCT FROM b.query_hash;";
+
+        command.Parameters.Add(new DuckDBParameter { Value = serverId });
+        command.Parameters.Add(new DuckDBParameter { Value = currentStart });
+        command.Parameters.Add(new DuckDBParameter { Value = currentEnd });
+        command.Parameters.Add(new DuckDBParameter { Value = baselineStart });
+        command.Parameters.Add(new DuckDBParameter { Value = baselineEnd });
+
+        var items = new List<Models.QueryStatsComparisonItem>();
+        using var reader = await command.ExecuteReaderAsync();
+        while (await reader.ReadAsync())
+        {
+            items.Add(new Models.QueryStatsComparisonItem
+            {
+                DatabaseName = reader.IsDBNull(0) ? "" : reader.GetString(0),
+                QueryHash = reader.IsDBNull(1) ? "" : reader.GetString(1),
+                QueryText = reader.IsDBNull(2) ? "" : reader.GetString(2),
+                ExecutionCount = reader.IsDBNull(3) ? 0 : ToInt64(reader.GetValue(3)),
+                AvgDurationMs = reader.IsDBNull(4) ? 0 : ToDouble(reader.GetValue(4)),
+                AvgCpuMs = reader.IsDBNull(5) ? 0 : ToDouble(reader.GetValue(5)),
+                AvgReads = reader.IsDBNull(6) ? 0 : ToDouble(reader.GetValue(6)),
+                BaselineExecutionCount = reader.IsDBNull(7) ? 0 : ToInt64(reader.GetValue(7)),
+                BaselineAvgDurationMs = reader.IsDBNull(8) ? 0 : ToDouble(reader.GetValue(8)),
+                BaselineAvgCpuMs = reader.IsDBNull(9) ? 0 : ToDouble(reader.GetValue(9)),
+                BaselineAvgReads = reader.IsDBNull(10) ? 0 : ToDouble(reader.GetValue(10)),
+            });
+        }
+
+        return items;
+    }
+
     /// <summary>
     /// Gets collection-level history for a specific Query Store query (for drilldown).
     /// </summary>

From c1578ccc84971d2ab40f41c4f1d44a40ec35a1aa Mon Sep 17 00:00:00 2001
From: Erik Darling <2136037+erikdarlingdata@users.noreply.github.com>
Date: Tue, 7 Apr 2026 12:02:22 -0400
Subject: [PATCH 22/30] Fix collector health status for on-load collectors

On-load collectors (server_config, database_config, etc.) run once per tab
open rather than on the scheduled loop, so staleness thresholds don't apply.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
---
 .../LocalDataService.CollectionHealth.cs       | 18 ++++++++++++++++++
 1 file changed, 18 insertions(+)

diff --git a/Lite/Services/LocalDataService.CollectionHealth.cs b/Lite/Services/LocalDataService.CollectionHealth.cs
index 19c47eb..e28338f 100644
--- a/Lite/Services/LocalDataService.CollectionHealth.cs
+++ b/Lite/Services/LocalDataService.CollectionHealth.cs
@@ -189,6 +189,19 @@ public class CollectionLogRow
 
 public class CollectorHealthRow
 {
+    /// <summary>
+    /// On-load collectors run once per tab open, not on the scheduled loop.
+    /// Staleness thresholds don't apply to them.
+    /// </summary>
+    private static readonly HashSet<string> OnLoadCollectors = new(StringComparer.OrdinalIgnoreCase)
+    {
+        "server_config",
+        "database_config",
+        "database_scoped_config",
+        "trace_flags",
+        "server_properties"
+    };
+
     public string CollectorName { get; set; } = "";
     public long TotalRuns { get; set; }
     public long SuccessCount { get; set; }
@@ -211,6 +224,11 @@ public string HealthStatus
         {
             if (TotalRuns == 0) return "NEVER_RUN";
             if (PermissionDeniedCount > 0 && ErrorCount == 0 && SuccessCount == 0) return "NO_PERMISSIONS";
+            if (OnLoadCollectors.Contains(CollectorName))
+            {
+                if (FailureRatePercent > 20) return "WARNING";
+                return "HEALTHY";
+            }
             if (HoursSinceLastSuccess > 24) return "FAILING";
             if (HoursSinceLastSuccess > 4) return "STALE";
             if (FailureRatePercent > 20) return "WARNING";

From 75854947cae52351d99346b6cd35d6340614d121 Mon Sep 17 00:00:00 2001
From: Erik Darling <2136037+erikdarlingdata@users.noreply.github.com>
Date: Tue, 7 Apr 2026 12:21:12 -0400
Subject: [PATCH 23/30] Fix Rule 3 severity: CouldNotGenerateValidParallelPlan
 is actionable
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

This reason means something in the query blocks parallelism (scalar UDFs,
table variable inserts, etc.) — that's worth a Warning, not Info.

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

diff --git a/Dashboard/Services/PlanAnalyzer.cs b/Dashboard/Services/PlanAnalyzer.cs
index 4c2e59b..2b55e67 100644
--- a/Dashboard/Services/PlanAnalyzer.cs
+++ b/Dashboard/Services/PlanAnalyzer.cs
@@ -55,13 +55,14 @@ private static void AnalyzeStatement(PlanStatement stmt)
                 _ => stmt.NonParallelPlanReason
             };
 
-            var isExplicit = stmt.NonParallelPlanReason is "MaxDOPSetToOne" or "QueryHintNoParallelSet";
+            var isActionable = stmt.NonParallelPlanReason is "MaxDOPSetToOne"
+                or "QueryHintNoParallelSet" or "CouldNotGenerateValidParallelPlan";
 
             stmt.PlanWarnings.Add(new PlanWarning
             {
                 WarningType = "Serial Plan",
                 Message = $"Query running serially: {reason}.",
-                Severity = isExplicit ? PlanWarningSeverity.Warning : PlanWarningSeverity.Info
+                Severity = isActionable ? PlanWarningSeverity.Warning : PlanWarningSeverity.Info
             });
         }
 
diff --git a/Lite/Services/PlanAnalyzer.cs b/Lite/Services/PlanAnalyzer.cs
index 7f94429..87cee2b 100644
--- a/Lite/Services/PlanAnalyzer.cs
+++ b/Lite/Services/PlanAnalyzer.cs
@@ -55,13 +55,14 @@ private static void AnalyzeStatement(PlanStatement stmt)
                 _ => stmt.NonParallelPlanReason
             };
 
-            var isExplicit = stmt.NonParallelPlanReason is "MaxDOPSetToOne" or "QueryHintNoParallelSet";
+            var isActionable = stmt.NonParallelPlanReason is "MaxDOPSetToOne"
+                or "QueryHintNoParallelSet" or "CouldNotGenerateValidParallelPlan";
 
             stmt.PlanWarnings.Add(new PlanWarning
             {
                 WarningType = "Serial Plan",
                 Message = $"Query running serially: {reason}.",
-                Severity = isExplicit ? PlanWarningSeverity.Warning : PlanWarningSeverity.Info
+                Severity = isActionable ? PlanWarningSeverity.Warning : PlanWarningSeverity.Info
             });
         }
 

From b8a760b7842cb1f7f836fc9f4491bb1b5c962504 Mon Sep 17 00:00:00 2001
From: Erik Darling <2136037+erikdarlingdata@users.noreply.github.com>
Date: Tue, 7 Apr 2026 12:32:37 -0400
Subject: [PATCH 24/30] Port query grid comparison to Dashboard with global
 Compare dropdown

Replace the local Compare dropdown in ResourceMetricsContent with a global
one in the ServerTab toolbar. Add comparison grids for Query Stats, Procedure
Stats, and Query Store tabs with color-coded delta columns. Compare dropdown
is disabled on unsupported tabs with visual feedback.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
---
 .../Controls/QueryPerformanceContent.xaml     | 133 ++++++-
 .../Controls/QueryPerformanceContent.xaml.cs  | 146 +++++++-
 .../Controls/ResourceMetricsContent.xaml      |  12 -
 .../Controls/ResourceMetricsContent.xaml.cs   |  26 +-
 Dashboard/Models/ComparisonItemBase.cs        |  80 +++++
 .../Models/ProcedureStatsComparisonItem.cs    |   9 +
 Dashboard/Models/QueryStatsComparisonItem.cs  |  11 +
 Dashboard/ServerTab.xaml                      |  10 +
 Dashboard/ServerTab.xaml.cs                   |  73 ++++
 .../DatabaseService.QueryPerformance.cs       | 335 ++++++++++++++++++
 10 files changed, 797 insertions(+), 38 deletions(-)
 create mode 100644 Dashboard/Models/ComparisonItemBase.cs
 create mode 100644 Dashboard/Models/ProcedureStatsComparisonItem.cs
 create mode 100644 Dashboard/Models/QueryStatsComparisonItem.cs

diff --git a/Dashboard/Controls/QueryPerformanceContent.xaml b/Dashboard/Controls/QueryPerformanceContent.xaml
index 79aaca9..0c1694e 100644
--- a/Dashboard/Controls/QueryPerformanceContent.xaml
+++ b/Dashboard/Controls/QueryPerformanceContent.xaml
@@ -571,11 +571,16 @@
         <TabItem Header="Query Stats">
             <Grid>
                 <Grid.RowDefinitions>
+                    <RowDefinition Height="Auto"/>
                     <RowDefinition Height="Auto"/>
                     <RowDefinition Height="*"/>
                 </Grid.RowDefinitions>
                 <local:TimeRangeSlicerControl x:Name="QueryStatsSlicer" Grid.Row="0"/>
-            <DataGrid Grid.Row="1" x:Name="QueryStatsDataGrid" AutoGenerateColumns="False" IsReadOnly="True"
+                <TextBlock x:Name="QueryStatsComparisonBanner" Grid.Row="1" Visibility="Collapsed"
+                           Padding="8,4" FontWeight="Bold"
+                           Foreground="{DynamicResource ForegroundBrush}"
+                           Background="#2244AAFF"/>
+            <DataGrid Grid.Row="2" x:Name="QueryStatsDataGrid" AutoGenerateColumns="False" IsReadOnly="True"
                       GridLinesVisibility="Horizontal" CanUserResizeColumns="True"
                       ScrollViewer.CanContentScroll="True" ScrollViewer.HorizontalScrollBarVisibility="Auto" ScrollViewer.VerticalScrollBarVisibility="Auto"
                       RowStyle="{DynamicResource DefaultRowStyle}"
@@ -862,6 +867,44 @@
                     </DataGridTemplateColumn>
                 </DataGrid.Columns>
             </DataGrid>
+            <DataGrid Grid.Row="2" x:Name="QueryStatsComparisonGrid" Visibility="Collapsed"
+                      AutoGenerateColumns="False" IsReadOnly="True"
+                      GridLinesVisibility="Horizontal" CanUserResizeColumns="True"
+                      RowStyle="{DynamicResource DefaultRowStyle}">
+                <DataGrid.Columns>
+                    <DataGridTextColumn Binding="{Binding StatusBadge}" Width="55">
+                        <DataGridTextColumn.Header><TextBlock Text="" FontWeight="Bold"/></DataGridTextColumn.Header>
+                        <DataGridTextColumn.ElementStyle>
+                            <Style TargetType="TextBlock"><Setter Property="FontWeight" Value="Bold"/><Setter Property="HorizontalAlignment" Value="Center"/>
+                                <Style.Triggers>
+                                    <DataTrigger Binding="{Binding IsNew}" Value="True"><Setter Property="Foreground" Value="#FF6B6B"/></DataTrigger>
+                                    <DataTrigger Binding="{Binding IsGone}" Value="True"><Setter Property="Foreground" Value="#888888"/></DataTrigger>
+                                </Style.Triggers>
+                            </Style>
+                        </DataGridTextColumn.ElementStyle>
+                    </DataGridTextColumn>
+                    <DataGridTextColumn Binding="{Binding DatabaseName}" Width="120"><DataGridTextColumn.Header><TextBlock Text="Database" FontWeight="Bold"/></DataGridTextColumn.Header></DataGridTextColumn>
+                    <DataGridTextColumn Binding="{Binding ExecutionCount, StringFormat=N0}" ElementStyle="{StaticResource NumericCell}" Width="90"><DataGridTextColumn.Header><TextBlock Text="Executions" FontWeight="Bold"/></DataGridTextColumn.Header></DataGridTextColumn>
+                    <DataGridTextColumn Binding="{Binding BaselineExecutionCount, StringFormat=N0}" ElementStyle="{StaticResource NumericCell}" Width="100"><DataGridTextColumn.Header><TextBlock Text="Base Execs" FontWeight="Bold"/></DataGridTextColumn.Header></DataGridTextColumn>
+                    <DataGridTextColumn Binding="{Binding ExecutionDeltaDisplay}" Width="80"><DataGridTextColumn.Header><TextBlock Text="Exec &#x0394;" FontWeight="Bold"/></DataGridTextColumn.Header>
+                        <DataGridTextColumn.ElementStyle><Style TargetType="TextBlock"><Setter Property="HorizontalAlignment" Value="Right"/><Setter Property="Padding" Value="0,0,5,0"/><Setter Property="FontWeight" Value="SemiBold"/><Setter Property="Foreground" Value="{Binding ExecutionDeltaBrush}"/></Style></DataGridTextColumn.ElementStyle></DataGridTextColumn>
+                    <DataGridTextColumn Binding="{Binding AvgDurationMs, StringFormat=N2}" ElementStyle="{StaticResource NumericCell}" Width="100"><DataGridTextColumn.Header><TextBlock Text="Avg Dur (ms)" FontWeight="Bold"/></DataGridTextColumn.Header></DataGridTextColumn>
+                    <DataGridTextColumn Binding="{Binding BaselineAvgDurationMs, StringFormat=N2}" ElementStyle="{StaticResource NumericCell}" Width="110"><DataGridTextColumn.Header><TextBlock Text="Base Dur (ms)" FontWeight="Bold"/></DataGridTextColumn.Header></DataGridTextColumn>
+                    <DataGridTextColumn Binding="{Binding DurationDeltaDisplay}" Width="80"><DataGridTextColumn.Header><TextBlock Text="Dur &#x0394;" FontWeight="Bold"/></DataGridTextColumn.Header>
+                        <DataGridTextColumn.ElementStyle><Style TargetType="TextBlock"><Setter Property="HorizontalAlignment" Value="Right"/><Setter Property="Padding" Value="0,0,5,0"/><Setter Property="FontWeight" Value="SemiBold"/><Setter Property="Foreground" Value="{Binding DurationDeltaBrush}"/></Style></DataGridTextColumn.ElementStyle></DataGridTextColumn>
+                    <DataGridTextColumn Binding="{Binding AvgCpuMs, StringFormat=N2}" ElementStyle="{StaticResource NumericCell}" Width="95"><DataGridTextColumn.Header><TextBlock Text="Avg CPU (ms)" FontWeight="Bold"/></DataGridTextColumn.Header></DataGridTextColumn>
+                    <DataGridTextColumn Binding="{Binding BaselineAvgCpuMs, StringFormat=N2}" ElementStyle="{StaticResource NumericCell}" Width="110"><DataGridTextColumn.Header><TextBlock Text="Base CPU (ms)" FontWeight="Bold"/></DataGridTextColumn.Header></DataGridTextColumn>
+                    <DataGridTextColumn Binding="{Binding CpuDeltaDisplay}" Width="80"><DataGridTextColumn.Header><TextBlock Text="CPU &#x0394;" FontWeight="Bold"/></DataGridTextColumn.Header>
+                        <DataGridTextColumn.ElementStyle><Style TargetType="TextBlock"><Setter Property="HorizontalAlignment" Value="Right"/><Setter Property="Padding" Value="0,0,5,0"/><Setter Property="FontWeight" Value="SemiBold"/><Setter Property="Foreground" Value="{Binding CpuDeltaBrush}"/></Style></DataGridTextColumn.ElementStyle></DataGridTextColumn>
+                    <DataGridTextColumn Binding="{Binding AvgReads, StringFormat=N0}" ElementStyle="{StaticResource NumericCell}" Width="85"><DataGridTextColumn.Header><TextBlock Text="Avg Reads" FontWeight="Bold"/></DataGridTextColumn.Header></DataGridTextColumn>
+                    <DataGridTextColumn Binding="{Binding BaselineAvgReads, StringFormat=N0}" ElementStyle="{StaticResource NumericCell}" Width="95"><DataGridTextColumn.Header><TextBlock Text="Base Reads" FontWeight="Bold"/></DataGridTextColumn.Header></DataGridTextColumn>
+                    <DataGridTextColumn Binding="{Binding ReadsDeltaDisplay}" Width="80"><DataGridTextColumn.Header><TextBlock Text="Reads &#x0394;" FontWeight="Bold"/></DataGridTextColumn.Header>
+                        <DataGridTextColumn.ElementStyle><Style TargetType="TextBlock"><Setter Property="HorizontalAlignment" Value="Right"/><Setter Property="Padding" Value="0,0,5,0"/><Setter Property="FontWeight" Value="SemiBold"/><Setter Property="Foreground" Value="{Binding ReadsDeltaBrush}"/></Style></DataGridTextColumn.ElementStyle></DataGridTextColumn>
+                    <DataGridTextColumn Binding="{Binding QueryHash}" Width="140"><DataGridTextColumn.Header><TextBlock Text="Query Hash" FontWeight="Bold"/></DataGridTextColumn.Header></DataGridTextColumn>
+                    <DataGridTemplateColumn Width="500"><DataGridTemplateColumn.Header><TextBlock Text="Query Text" FontWeight="Bold"/></DataGridTemplateColumn.Header>
+                        <DataGridTemplateColumn.CellTemplate><DataTemplate><TextBlock Text="{Binding QueryText}" TextWrapping="Wrap" MaxHeight="90" Margin="5,2" ToolTip="{Binding QueryText}"/></DataTemplate></DataGridTemplateColumn.CellTemplate></DataGridTemplateColumn>
+                </DataGrid.Columns>
+            </DataGrid>
             <TextBlock x:Name="QueryStatsNoDataMessage" Style="{StaticResource EmptyStateMessage}"
                        Text="No query statistics in selected time range"/>
             <local:LoadingOverlay x:Name="QueryStatsLoading"/>
@@ -872,11 +915,16 @@
         <TabItem Header="Procedure Stats">
             <Grid>
                 <Grid.RowDefinitions>
+                    <RowDefinition Height="Auto"/>
                     <RowDefinition Height="Auto"/>
                     <RowDefinition Height="*"/>
                 </Grid.RowDefinitions>
                 <local:TimeRangeSlicerControl x:Name="ProcStatsSlicer" Grid.Row="0"/>
-            <DataGrid Grid.Row="1" x:Name="ProcStatsDataGrid" AutoGenerateColumns="False" IsReadOnly="True"
+                <TextBlock x:Name="ProcStatsComparisonBanner" Grid.Row="1" Visibility="Collapsed"
+                           Padding="8,4" FontWeight="Bold"
+                           Foreground="{DynamicResource ForegroundBrush}"
+                           Background="#2244AAFF"/>
+            <DataGrid Grid.Row="2" x:Name="ProcStatsDataGrid" AutoGenerateColumns="False" IsReadOnly="True"
                       GridLinesVisibility="Horizontal" CanUserResizeColumns="True"
                       ScrollViewer.CanContentScroll="True" ScrollViewer.HorizontalScrollBarVisibility="Auto" ScrollViewer.VerticalScrollBarVisibility="Auto"
                       RowStyle="{DynamicResource DefaultRowStyle}"
@@ -1134,6 +1182,42 @@
                     </DataGridTextColumn>
                 </DataGrid.Columns>
             </DataGrid>
+            <DataGrid Grid.Row="2" x:Name="ProcStatsComparisonGrid" Visibility="Collapsed"
+                      AutoGenerateColumns="False" IsReadOnly="True"
+                      GridLinesVisibility="Horizontal" CanUserResizeColumns="True"
+                      RowStyle="{DynamicResource DefaultRowStyle}">
+                <DataGrid.Columns>
+                    <DataGridTextColumn Binding="{Binding StatusBadge}" Width="55">
+                        <DataGridTextColumn.Header><TextBlock Text="" FontWeight="Bold"/></DataGridTextColumn.Header>
+                        <DataGridTextColumn.ElementStyle>
+                            <Style TargetType="TextBlock"><Setter Property="FontWeight" Value="Bold"/><Setter Property="HorizontalAlignment" Value="Center"/>
+                                <Style.Triggers>
+                                    <DataTrigger Binding="{Binding IsNew}" Value="True"><Setter Property="Foreground" Value="#FF6B6B"/></DataTrigger>
+                                    <DataTrigger Binding="{Binding IsGone}" Value="True"><Setter Property="Foreground" Value="#888888"/></DataTrigger>
+                                </Style.Triggers>
+                            </Style>
+                        </DataGridTextColumn.ElementStyle>
+                    </DataGridTextColumn>
+                    <DataGridTextColumn Binding="{Binding DatabaseName}" Width="120"><DataGridTextColumn.Header><TextBlock Text="Database" FontWeight="Bold"/></DataGridTextColumn.Header></DataGridTextColumn>
+                    <DataGridTextColumn Binding="{Binding FullName}" Width="200"><DataGridTextColumn.Header><TextBlock Text="Procedure" FontWeight="Bold"/></DataGridTextColumn.Header></DataGridTextColumn>
+                    <DataGridTextColumn Binding="{Binding ExecutionCount, StringFormat=N0}" ElementStyle="{StaticResource NumericCell}" Width="90"><DataGridTextColumn.Header><TextBlock Text="Executions" FontWeight="Bold"/></DataGridTextColumn.Header></DataGridTextColumn>
+                    <DataGridTextColumn Binding="{Binding BaselineExecutionCount, StringFormat=N0}" ElementStyle="{StaticResource NumericCell}" Width="100"><DataGridTextColumn.Header><TextBlock Text="Base Execs" FontWeight="Bold"/></DataGridTextColumn.Header></DataGridTextColumn>
+                    <DataGridTextColumn Binding="{Binding ExecutionDeltaDisplay}" Width="80"><DataGridTextColumn.Header><TextBlock Text="Exec &#x0394;" FontWeight="Bold"/></DataGridTextColumn.Header>
+                        <DataGridTextColumn.ElementStyle><Style TargetType="TextBlock"><Setter Property="HorizontalAlignment" Value="Right"/><Setter Property="Padding" Value="0,0,5,0"/><Setter Property="FontWeight" Value="SemiBold"/><Setter Property="Foreground" Value="{Binding ExecutionDeltaBrush}"/></Style></DataGridTextColumn.ElementStyle></DataGridTextColumn>
+                    <DataGridTextColumn Binding="{Binding AvgDurationMs, StringFormat=N2}" ElementStyle="{StaticResource NumericCell}" Width="100"><DataGridTextColumn.Header><TextBlock Text="Avg Dur (ms)" FontWeight="Bold"/></DataGridTextColumn.Header></DataGridTextColumn>
+                    <DataGridTextColumn Binding="{Binding BaselineAvgDurationMs, StringFormat=N2}" ElementStyle="{StaticResource NumericCell}" Width="110"><DataGridTextColumn.Header><TextBlock Text="Base Dur (ms)" FontWeight="Bold"/></DataGridTextColumn.Header></DataGridTextColumn>
+                    <DataGridTextColumn Binding="{Binding DurationDeltaDisplay}" Width="80"><DataGridTextColumn.Header><TextBlock Text="Dur &#x0394;" FontWeight="Bold"/></DataGridTextColumn.Header>
+                        <DataGridTextColumn.ElementStyle><Style TargetType="TextBlock"><Setter Property="HorizontalAlignment" Value="Right"/><Setter Property="Padding" Value="0,0,5,0"/><Setter Property="FontWeight" Value="SemiBold"/><Setter Property="Foreground" Value="{Binding DurationDeltaBrush}"/></Style></DataGridTextColumn.ElementStyle></DataGridTextColumn>
+                    <DataGridTextColumn Binding="{Binding AvgCpuMs, StringFormat=N2}" ElementStyle="{StaticResource NumericCell}" Width="95"><DataGridTextColumn.Header><TextBlock Text="Avg CPU (ms)" FontWeight="Bold"/></DataGridTextColumn.Header></DataGridTextColumn>
+                    <DataGridTextColumn Binding="{Binding BaselineAvgCpuMs, StringFormat=N2}" ElementStyle="{StaticResource NumericCell}" Width="110"><DataGridTextColumn.Header><TextBlock Text="Base CPU (ms)" FontWeight="Bold"/></DataGridTextColumn.Header></DataGridTextColumn>
+                    <DataGridTextColumn Binding="{Binding CpuDeltaDisplay}" Width="80"><DataGridTextColumn.Header><TextBlock Text="CPU &#x0394;" FontWeight="Bold"/></DataGridTextColumn.Header>
+                        <DataGridTextColumn.ElementStyle><Style TargetType="TextBlock"><Setter Property="HorizontalAlignment" Value="Right"/><Setter Property="Padding" Value="0,0,5,0"/><Setter Property="FontWeight" Value="SemiBold"/><Setter Property="Foreground" Value="{Binding CpuDeltaBrush}"/></Style></DataGridTextColumn.ElementStyle></DataGridTextColumn>
+                    <DataGridTextColumn Binding="{Binding AvgReads, StringFormat=N0}" ElementStyle="{StaticResource NumericCell}" Width="85"><DataGridTextColumn.Header><TextBlock Text="Avg Reads" FontWeight="Bold"/></DataGridTextColumn.Header></DataGridTextColumn>
+                    <DataGridTextColumn Binding="{Binding BaselineAvgReads, StringFormat=N0}" ElementStyle="{StaticResource NumericCell}" Width="95"><DataGridTextColumn.Header><TextBlock Text="Base Reads" FontWeight="Bold"/></DataGridTextColumn.Header></DataGridTextColumn>
+                    <DataGridTextColumn Binding="{Binding ReadsDeltaDisplay}" Width="80"><DataGridTextColumn.Header><TextBlock Text="Reads &#x0394;" FontWeight="Bold"/></DataGridTextColumn.Header>
+                        <DataGridTextColumn.ElementStyle><Style TargetType="TextBlock"><Setter Property="HorizontalAlignment" Value="Right"/><Setter Property="Padding" Value="0,0,5,0"/><Setter Property="FontWeight" Value="SemiBold"/><Setter Property="Foreground" Value="{Binding ReadsDeltaBrush}"/></Style></DataGridTextColumn.ElementStyle></DataGridTextColumn>
+                </DataGrid.Columns>
+            </DataGrid>
             <TextBlock x:Name="ProcStatsNoDataMessage" Style="{StaticResource NoDataMessage}"/>
             </Grid>
         </TabItem>
@@ -1142,11 +1226,16 @@
         <TabItem Header="Query Store">
             <Grid>
                 <Grid.RowDefinitions>
+                    <RowDefinition Height="Auto"/>
                     <RowDefinition Height="Auto"/>
                     <RowDefinition Height="*"/>
                 </Grid.RowDefinitions>
                 <local:TimeRangeSlicerControl x:Name="QueryStoreSlicer" Grid.Row="0"/>
-            <DataGrid Grid.Row="1" x:Name="QueryStoreDataGrid" AutoGenerateColumns="False" IsReadOnly="True"
+                <TextBlock x:Name="QueryStoreComparisonBanner" Grid.Row="1" Visibility="Collapsed"
+                           Padding="8,4" FontWeight="Bold"
+                           Foreground="{DynamicResource ForegroundBrush}"
+                           Background="#2244AAFF"/>
+            <DataGrid Grid.Row="2" x:Name="QueryStoreDataGrid" AutoGenerateColumns="False" IsReadOnly="True"
                       GridLinesVisibility="Horizontal" CanUserResizeColumns="True"
                       ScrollViewer.CanContentScroll="True" ScrollViewer.HorizontalScrollBarVisibility="Auto" ScrollViewer.VerticalScrollBarVisibility="Auto"
                       RowStyle="{DynamicResource DefaultRowStyle}"
@@ -1545,6 +1634,44 @@
                     </DataGridTemplateColumn>
                 </DataGrid.Columns>
             </DataGrid>
+            <DataGrid Grid.Row="2" x:Name="QueryStoreComparisonGrid" Visibility="Collapsed"
+                      AutoGenerateColumns="False" IsReadOnly="True"
+                      GridLinesVisibility="Horizontal" CanUserResizeColumns="True"
+                      RowStyle="{DynamicResource DefaultRowStyle}">
+                <DataGrid.Columns>
+                    <DataGridTextColumn Binding="{Binding StatusBadge}" Width="55">
+                        <DataGridTextColumn.Header><TextBlock Text="" FontWeight="Bold"/></DataGridTextColumn.Header>
+                        <DataGridTextColumn.ElementStyle>
+                            <Style TargetType="TextBlock"><Setter Property="FontWeight" Value="Bold"/><Setter Property="HorizontalAlignment" Value="Center"/>
+                                <Style.Triggers>
+                                    <DataTrigger Binding="{Binding IsNew}" Value="True"><Setter Property="Foreground" Value="#FF6B6B"/></DataTrigger>
+                                    <DataTrigger Binding="{Binding IsGone}" Value="True"><Setter Property="Foreground" Value="#888888"/></DataTrigger>
+                                </Style.Triggers>
+                            </Style>
+                        </DataGridTextColumn.ElementStyle>
+                    </DataGridTextColumn>
+                    <DataGridTextColumn Binding="{Binding DatabaseName}" Width="120"><DataGridTextColumn.Header><TextBlock Text="Database" FontWeight="Bold"/></DataGridTextColumn.Header></DataGridTextColumn>
+                    <DataGridTextColumn Binding="{Binding ExecutionCount, StringFormat=N0}" ElementStyle="{StaticResource NumericCell}" Width="90"><DataGridTextColumn.Header><TextBlock Text="Executions" FontWeight="Bold"/></DataGridTextColumn.Header></DataGridTextColumn>
+                    <DataGridTextColumn Binding="{Binding BaselineExecutionCount, StringFormat=N0}" ElementStyle="{StaticResource NumericCell}" Width="100"><DataGridTextColumn.Header><TextBlock Text="Base Execs" FontWeight="Bold"/></DataGridTextColumn.Header></DataGridTextColumn>
+                    <DataGridTextColumn Binding="{Binding ExecutionDeltaDisplay}" Width="80"><DataGridTextColumn.Header><TextBlock Text="Exec &#x0394;" FontWeight="Bold"/></DataGridTextColumn.Header>
+                        <DataGridTextColumn.ElementStyle><Style TargetType="TextBlock"><Setter Property="HorizontalAlignment" Value="Right"/><Setter Property="Padding" Value="0,0,5,0"/><Setter Property="FontWeight" Value="SemiBold"/><Setter Property="Foreground" Value="{Binding ExecutionDeltaBrush}"/></Style></DataGridTextColumn.ElementStyle></DataGridTextColumn>
+                    <DataGridTextColumn Binding="{Binding AvgDurationMs, StringFormat=N2}" ElementStyle="{StaticResource NumericCell}" Width="100"><DataGridTextColumn.Header><TextBlock Text="Avg Dur (ms)" FontWeight="Bold"/></DataGridTextColumn.Header></DataGridTextColumn>
+                    <DataGridTextColumn Binding="{Binding BaselineAvgDurationMs, StringFormat=N2}" ElementStyle="{StaticResource NumericCell}" Width="110"><DataGridTextColumn.Header><TextBlock Text="Base Dur (ms)" FontWeight="Bold"/></DataGridTextColumn.Header></DataGridTextColumn>
+                    <DataGridTextColumn Binding="{Binding DurationDeltaDisplay}" Width="80"><DataGridTextColumn.Header><TextBlock Text="Dur &#x0394;" FontWeight="Bold"/></DataGridTextColumn.Header>
+                        <DataGridTextColumn.ElementStyle><Style TargetType="TextBlock"><Setter Property="HorizontalAlignment" Value="Right"/><Setter Property="Padding" Value="0,0,5,0"/><Setter Property="FontWeight" Value="SemiBold"/><Setter Property="Foreground" Value="{Binding DurationDeltaBrush}"/></Style></DataGridTextColumn.ElementStyle></DataGridTextColumn>
+                    <DataGridTextColumn Binding="{Binding AvgCpuMs, StringFormat=N2}" ElementStyle="{StaticResource NumericCell}" Width="95"><DataGridTextColumn.Header><TextBlock Text="Avg CPU (ms)" FontWeight="Bold"/></DataGridTextColumn.Header></DataGridTextColumn>
+                    <DataGridTextColumn Binding="{Binding BaselineAvgCpuMs, StringFormat=N2}" ElementStyle="{StaticResource NumericCell}" Width="110"><DataGridTextColumn.Header><TextBlock Text="Base CPU (ms)" FontWeight="Bold"/></DataGridTextColumn.Header></DataGridTextColumn>
+                    <DataGridTextColumn Binding="{Binding CpuDeltaDisplay}" Width="80"><DataGridTextColumn.Header><TextBlock Text="CPU &#x0394;" FontWeight="Bold"/></DataGridTextColumn.Header>
+                        <DataGridTextColumn.ElementStyle><Style TargetType="TextBlock"><Setter Property="HorizontalAlignment" Value="Right"/><Setter Property="Padding" Value="0,0,5,0"/><Setter Property="FontWeight" Value="SemiBold"/><Setter Property="Foreground" Value="{Binding CpuDeltaBrush}"/></Style></DataGridTextColumn.ElementStyle></DataGridTextColumn>
+                    <DataGridTextColumn Binding="{Binding AvgReads, StringFormat=N0}" ElementStyle="{StaticResource NumericCell}" Width="85"><DataGridTextColumn.Header><TextBlock Text="Avg Reads" FontWeight="Bold"/></DataGridTextColumn.Header></DataGridTextColumn>
+                    <DataGridTextColumn Binding="{Binding BaselineAvgReads, StringFormat=N0}" ElementStyle="{StaticResource NumericCell}" Width="95"><DataGridTextColumn.Header><TextBlock Text="Base Reads" FontWeight="Bold"/></DataGridTextColumn.Header></DataGridTextColumn>
+                    <DataGridTextColumn Binding="{Binding ReadsDeltaDisplay}" Width="80"><DataGridTextColumn.Header><TextBlock Text="Reads &#x0394;" FontWeight="Bold"/></DataGridTextColumn.Header>
+                        <DataGridTextColumn.ElementStyle><Style TargetType="TextBlock"><Setter Property="HorizontalAlignment" Value="Right"/><Setter Property="Padding" Value="0,0,5,0"/><Setter Property="FontWeight" Value="SemiBold"/><Setter Property="Foreground" Value="{Binding ReadsDeltaBrush}"/></Style></DataGridTextColumn.ElementStyle></DataGridTextColumn>
+                    <DataGridTextColumn Binding="{Binding QueryHash}" Width="140"><DataGridTextColumn.Header><TextBlock Text="Query Hash" FontWeight="Bold"/></DataGridTextColumn.Header></DataGridTextColumn>
+                    <DataGridTemplateColumn Width="500"><DataGridTemplateColumn.Header><TextBlock Text="Query Text" FontWeight="Bold"/></DataGridTemplateColumn.Header>
+                        <DataGridTemplateColumn.CellTemplate><DataTemplate><TextBlock Text="{Binding QueryText}" TextWrapping="Wrap" MaxHeight="90" Margin="5,2" ToolTip="{Binding QueryText}"/></DataTemplate></DataGridTemplateColumn.CellTemplate></DataGridTemplateColumn>
+                </DataGrid.Columns>
+            </DataGrid>
             <TextBlock x:Name="QueryStoreNoDataMessage" Style="{StaticResource NoDataMessage}"/>
             </Grid>
         </TabItem>
diff --git a/Dashboard/Controls/QueryPerformanceContent.xaml.cs b/Dashboard/Controls/QueryPerformanceContent.xaml.cs
index 0d15c70..f2147f8 100644
--- a/Dashboard/Controls/QueryPerformanceContent.xaml.cs
+++ b/Dashboard/Controls/QueryPerformanceContent.xaml.cs
@@ -60,6 +60,9 @@ private static (DateTime start, DateTime end) GetSlicerTimeRange(
         /// <summary>Raised when a drill-down needs the parent to set custom time pickers. Args: (fromUtc, toUtc)</summary>
         public event Action<DateTime, DateTime>? DrillDownTimeRangeRequested;
 
+        /// <summary>Fired when the Queries sub-tab changes, so the global Compare dropdown can update.</summary>
+        public event Action? SubTabChanged;
+
         private CancellationTokenSource? _actualPlanCts;
 
         /// <summary>Cancels the in-flight actual plan execution, if any.</summary>
@@ -157,7 +160,14 @@ public QueryPerformanceContent()
             SetupChartSaveMenus();
             Loaded += OnLoaded;
             Unloaded += OnUnloaded;
-            SubTabControl.SelectionChanged += (s, e) => { if (e.Source == SubTabControl) _isDrillDownActive = false; };
+            SubTabControl.SelectionChanged += (s, e) =>
+            {
+                if (e.Source == SubTabControl)
+                {
+                    _isDrillDownActive = false;
+                    SubTabChanged?.Invoke();
+                }
+            };
             Helpers.ThemeManager.ThemeChanged += OnThemeChanged;
 
             _queryDurationHover = new Helpers.ChartHoverHelper(QueryPerfTrendsQueryChart, "ms/sec");
@@ -723,6 +733,140 @@ public void RefreshGridBindings()
         /// </summary>
         public void SelectSubTab(int index) => SubTabControl.SelectedIndex = index;
 
+        private (DateTime From, DateTime To)? _comparisonRange;
+
+        public void SetComparisonRange((DateTime From, DateTime To)? range)
+        {
+            _comparisonRange = range;
+        }
+
+        public async Task RefreshComparisonAsync()
+        {
+            if (_databaseService == null) return;
+
+            try
+            {
+                var currentEnd = _queryStatsToDate ?? DateTime.UtcNow;
+                var currentStart = _queryStatsFromDate ?? currentEnd.AddHours(-_queryStatsHoursBack);
+
+                await RefreshQueryStatsComparisonAsync(currentStart, currentEnd);
+                await RefreshProcStatsComparisonAsync(currentStart, currentEnd);
+                await RefreshQueryStoreComparisonAsync(currentStart, currentEnd);
+            }
+            catch (Exception ex)
+            {
+                _statusCallback?.Invoke($"Comparison failed: {ex.Message}");
+            }
+        }
+
+        private void SetQueryStatsComparisonMode(bool active, (DateTime From, DateTime To)? baselineRange = null)
+        {
+            QueryStatsDataGrid.Visibility = active ? System.Windows.Visibility.Collapsed : System.Windows.Visibility.Visible;
+            QueryStatsComparisonGrid.Visibility = active ? System.Windows.Visibility.Visible : System.Windows.Visibility.Collapsed;
+            QueryStatsComparisonBanner.Visibility = active ? System.Windows.Visibility.Visible : System.Windows.Visibility.Collapsed;
+
+            if (active && baselineRange.HasValue)
+            {
+                var from = baselineRange.Value.From.ToString("yyyy-MM-dd HH:mm");
+                var to = baselineRange.Value.To.ToString("yyyy-MM-dd HH:mm");
+                QueryStatsComparisonBanner.Text = $"Comparing against baseline: {from} \u2192 {to}";
+            }
+        }
+
+        private async Task RefreshQueryStatsComparisonAsync(DateTime currentStart, DateTime currentEnd)
+        {
+            if (_comparisonRange == null)
+            {
+                SetQueryStatsComparisonMode(false);
+                return;
+            }
+
+            SetQueryStatsComparisonMode(true, _comparisonRange);
+
+            var items = await _databaseService!.GetQueryStatsComparisonAsync(
+                currentStart, currentEnd,
+                _comparisonRange.Value.From, _comparisonRange.Value.To);
+
+            var sorted = items
+                .OrderBy(x => x.SortGroup)
+                .ThenByDescending(x => x.SortableDurationDelta)
+                .ToList();
+
+            QueryStatsComparisonGrid.ItemsSource = sorted;
+        }
+
+        private void SetProcStatsComparisonMode(bool active, (DateTime From, DateTime To)? baselineRange = null)
+        {
+            ProcStatsDataGrid.Visibility = active ? System.Windows.Visibility.Collapsed : System.Windows.Visibility.Visible;
+            ProcStatsComparisonGrid.Visibility = active ? System.Windows.Visibility.Visible : System.Windows.Visibility.Collapsed;
+            ProcStatsComparisonBanner.Visibility = active ? System.Windows.Visibility.Visible : System.Windows.Visibility.Collapsed;
+
+            if (active && baselineRange.HasValue)
+            {
+                var from = baselineRange.Value.From.ToString("yyyy-MM-dd HH:mm");
+                var to = baselineRange.Value.To.ToString("yyyy-MM-dd HH:mm");
+                ProcStatsComparisonBanner.Text = $"Comparing against baseline: {from} \u2192 {to}";
+            }
+        }
+
+        private async Task RefreshProcStatsComparisonAsync(DateTime currentStart, DateTime currentEnd)
+        {
+            if (_comparisonRange == null)
+            {
+                SetProcStatsComparisonMode(false);
+                return;
+            }
+
+            SetProcStatsComparisonMode(true, _comparisonRange);
+
+            var items = await _databaseService!.GetProcedureStatsComparisonAsync(
+                currentStart, currentEnd,
+                _comparisonRange.Value.From, _comparisonRange.Value.To);
+
+            var sorted = items
+                .OrderBy(x => x.SortGroup)
+                .ThenByDescending(x => x.SortableDurationDelta)
+                .ToList();
+
+            ProcStatsComparisonGrid.ItemsSource = sorted;
+        }
+
+        private void SetQueryStoreComparisonMode(bool active, (DateTime From, DateTime To)? baselineRange = null)
+        {
+            QueryStoreDataGrid.Visibility = active ? System.Windows.Visibility.Collapsed : System.Windows.Visibility.Visible;
+            QueryStoreComparisonGrid.Visibility = active ? System.Windows.Visibility.Visible : System.Windows.Visibility.Collapsed;
+            QueryStoreComparisonBanner.Visibility = active ? System.Windows.Visibility.Visible : System.Windows.Visibility.Collapsed;
+
+            if (active && baselineRange.HasValue)
+            {
+                var from = baselineRange.Value.From.ToString("yyyy-MM-dd HH:mm");
+                var to = baselineRange.Value.To.ToString("yyyy-MM-dd HH:mm");
+                QueryStoreComparisonBanner.Text = $"Comparing against baseline: {from} \u2192 {to}";
+            }
+        }
+
+        private async Task RefreshQueryStoreComparisonAsync(DateTime currentStart, DateTime currentEnd)
+        {
+            if (_comparisonRange == null)
+            {
+                SetQueryStoreComparisonMode(false);
+                return;
+            }
+
+            SetQueryStoreComparisonMode(true, _comparisonRange);
+
+            var items = await _databaseService!.GetQueryStoreComparisonAsync(
+                currentStart, currentEnd,
+                _comparisonRange.Value.From, _comparisonRange.Value.To);
+
+            var sorted = items
+                .OrderBy(x => x.SortGroup)
+                .ThenByDescending(x => x.SortableDurationDelta)
+                .ToList();
+
+            QueryStoreComparisonGrid.ItemsSource = sorted;
+        }
+
         public void SetTimeRange(int hoursBack, DateTime? fromDate = null, DateTime? toDate = null)
         {
             _isDrillDownActive = false;
diff --git a/Dashboard/Controls/ResourceMetricsContent.xaml b/Dashboard/Controls/ResourceMetricsContent.xaml
index 3685041..9bcdac6 100644
--- a/Dashboard/Controls/ResourceMetricsContent.xaml
+++ b/Dashboard/Controls/ResourceMetricsContent.xaml
@@ -29,18 +29,6 @@
         <!-- Server Trends Sub-Tab — Correlated Timeline Lanes -->
         <TabItem Header="Server Trends">
             <DockPanel>
-                <StackPanel DockPanel.Dock="Top" Orientation="Horizontal" Margin="8,4,8,0">
-                    <TextBlock Text="Compare:" VerticalAlignment="Center" Margin="0,0,4,0"
-                               Foreground="{DynamicResource ForegroundBrush}"/>
-                    <ComboBox x:Name="CompareToCombo" SelectedIndex="0" Width="150"
-                              SelectionChanged="CompareToCombo_SelectionChanged"
-                              ToolTip="Overlay a reference period on the timeline charts">
-                        <ComboBoxItem Content="None"/>
-                        <ComboBoxItem Content="Yesterday"/>
-                        <ComboBoxItem Content="Last week"/>
-                        <ComboBoxItem Content="Same day last week"/>
-                    </ComboBox>
-                </StackPanel>
                 <local:CorrelatedTimelineLanesControl x:Name="CorrelatedLanes"/>
             </DockPanel>
         </TabItem>
diff --git a/Dashboard/Controls/ResourceMetricsContent.xaml.cs b/Dashboard/Controls/ResourceMetricsContent.xaml.cs
index 7faa537..e66c6e9 100644
--- a/Dashboard/Controls/ResourceMetricsContent.xaml.cs
+++ b/Dashboard/Controls/ResourceMetricsContent.xaml.cs
@@ -1025,33 +1025,15 @@ private async Task LoadFileIoThroughputChartsAsync()
 
         #region Server Trends Tab
 
-        private async void CompareToCombo_SelectionChanged(object sender, SelectionChangedEventArgs e)
-        {
-            if (!IsLoaded) return;
-            ComparisonRange = GetComparisonRange();
-            await RefreshServerTrendsAsync();
-        }
-
         private (DateTime From, DateTime To)? ComparisonRange { get; set; }
 
         /// <summary>
-        /// Computes the reference time range for the comparison overlay.
-        /// Returns null if "None" is selected.
+        /// Sets the comparison range from the global Compare dropdown and refreshes Server Trends.
         /// </summary>
-        private (DateTime From, DateTime To)? GetComparisonRange()
+        public async Task SetComparisonRangeAsync((DateTime From, DateTime To)? range)
         {
-            if (CompareToCombo == null || CompareToCombo.SelectedIndex <= 0) return null;
-
-            var currentEnd = _serverTrendsToDate ?? DateTime.UtcNow;
-            var currentStart = _serverTrendsFromDate ?? currentEnd.AddHours(-_serverTrendsHoursBack);
-
-            return CompareToCombo.SelectedIndex switch
-            {
-                1 => (currentStart.AddDays(-1), currentEnd.AddDays(-1)),   // Yesterday
-                2 => (currentStart.AddDays(-7), currentEnd.AddDays(-7)),   // Last week
-                3 => (currentStart.AddDays(-7), currentEnd.AddDays(-7)),   // Same day last week
-                _ => null
-            };
+            ComparisonRange = range;
+            await RefreshServerTrendsAsync();
         }
 
         private async Task RefreshServerTrendsAsync()
diff --git a/Dashboard/Models/ComparisonItemBase.cs b/Dashboard/Models/ComparisonItemBase.cs
new file mode 100644
index 0000000..f91d145
--- /dev/null
+++ b/Dashboard/Models/ComparisonItemBase.cs
@@ -0,0 +1,80 @@
+using System.Windows.Media;
+
+namespace PerformanceMonitorDashboard.Models
+{
+    public abstract class ComparisonItemBase
+    {
+        public string DatabaseName { get; set; } = "";
+
+        // Current period
+        public long ExecutionCount { get; set; }
+        public double AvgDurationMs { get; set; }
+        public double AvgCpuMs { get; set; }
+        public double AvgReads { get; set; }
+
+        // Baseline period
+        public long BaselineExecutionCount { get; set; }
+        public double BaselineAvgDurationMs { get; set; }
+        public double BaselineAvgCpuMs { get; set; }
+        public double BaselineAvgReads { get; set; }
+
+        // Flags
+        public bool IsNew => ExecutionCount > 0 && BaselineExecutionCount == 0;
+        public bool IsGone => ExecutionCount == 0 && BaselineExecutionCount > 0;
+
+        // Delta percentages (null when baseline is zero or item is new/gone)
+        public double? DurationDeltaPct => ComputeDelta(AvgDurationMs, BaselineAvgDurationMs);
+        public double? CpuDeltaPct => ComputeDelta(AvgCpuMs, BaselineAvgCpuMs);
+        public double? ReadsDeltaPct => ComputeDelta(AvgReads, BaselineAvgReads);
+        public double? ExecutionDeltaPct => ComputeDelta(ExecutionCount, BaselineExecutionCount);
+
+        // Display helpers for grid binding
+        public string DurationDeltaDisplay => FormatDelta(DurationDeltaPct);
+        public string CpuDeltaDisplay => FormatDelta(CpuDeltaPct);
+        public string ReadsDeltaDisplay => FormatDelta(ReadsDeltaPct);
+        public string ExecutionDeltaDisplay => FormatDelta(ExecutionDeltaPct);
+
+        public string StatusBadge => IsNew ? "NEW" : IsGone ? "GONE" : "";
+
+        // Sort key: NEW at top (0), normal by delta (1), GONE at bottom (2)
+        public int SortGroup => IsNew ? 0 : IsGone ? 2 : 1;
+        public double SortableDurationDelta => DurationDeltaPct ?? (IsNew ? double.MaxValue : double.MinValue);
+
+        // Color brushes for delta columns (red = regression, green = improvement)
+        public Brush DurationDeltaBrush => GetDeltaBrush(DurationDeltaPct, 25);
+        public Brush CpuDeltaBrush => GetDeltaBrush(CpuDeltaPct, 25);
+        public Brush ReadsDeltaBrush => GetDeltaBrush(ReadsDeltaPct, 50, 25);
+        public Brush ExecutionDeltaBrush => GetDeltaBrush(ExecutionDeltaPct, 100, 50);
+
+        private static readonly Brush RedBrush = new SolidColorBrush(Color.FromRgb(0xFF, 0x6B, 0x6B));
+        private static readonly Brush GreenBrush = new SolidColorBrush(Color.FromRgb(0x4E, 0xC9, 0xB0));
+        private static readonly Brush NeutralBrush = Brushes.Transparent;
+
+        static ComparisonItemBase()
+        {
+            RedBrush.Freeze();
+            GreenBrush.Freeze();
+        }
+
+        private static Brush GetDeltaBrush(double? delta, double redThreshold, double greenThreshold = 25)
+        {
+            if (!delta.HasValue) return NeutralBrush;
+            if (delta.Value > redThreshold) return RedBrush;
+            if (delta.Value < -greenThreshold) return GreenBrush;
+            return NeutralBrush;
+        }
+
+        private static double? ComputeDelta(double current, double baseline)
+        {
+            if (baseline == 0) return null;
+            return (current - baseline) / baseline * 100.0;
+        }
+
+        private static string FormatDelta(double? delta)
+        {
+            if (!delta.HasValue) return "\u2014";
+            var sign = delta.Value >= 0 ? "+" : "";
+            return $"{sign}{delta.Value:N1}%";
+        }
+    }
+}
diff --git a/Dashboard/Models/ProcedureStatsComparisonItem.cs b/Dashboard/Models/ProcedureStatsComparisonItem.cs
new file mode 100644
index 0000000..463cdfb
--- /dev/null
+++ b/Dashboard/Models/ProcedureStatsComparisonItem.cs
@@ -0,0 +1,9 @@
+namespace PerformanceMonitorDashboard.Models
+{
+    public class ProcedureStatsComparisonItem : ComparisonItemBase
+    {
+        public string SchemaName { get; set; } = "";
+        public string ObjectName { get; set; } = "";
+        public string FullName => string.IsNullOrEmpty(SchemaName) ? ObjectName : $"{SchemaName}.{ObjectName}";
+    }
+}
diff --git a/Dashboard/Models/QueryStatsComparisonItem.cs b/Dashboard/Models/QueryStatsComparisonItem.cs
new file mode 100644
index 0000000..77287cb
--- /dev/null
+++ b/Dashboard/Models/QueryStatsComparisonItem.cs
@@ -0,0 +1,11 @@
+namespace PerformanceMonitorDashboard.Models
+{
+    public class QueryStatsComparisonItem : ComparisonItemBase
+    {
+        public string QueryHash { get; set; } = "";
+        public string? ObjectName { get; set; }
+        public string? SchemaName { get; set; }
+        public string? ObjectType { get; set; }
+        public string QueryText { get; set; } = "";
+    }
+}
diff --git a/Dashboard/ServerTab.xaml b/Dashboard/ServerTab.xaml
index e1d831b..4590426 100644
--- a/Dashboard/ServerTab.xaml
+++ b/Dashboard/ServerTab.xaml
@@ -105,6 +105,16 @@
                         <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}"/>
+                        <TextBlock Text="Compare:" VerticalAlignment="Center" Margin="0,0,4,0" Foreground="{DynamicResource ForegroundBrush}"/>
+                        <ComboBox x:Name="CompareToCombo" SelectedIndex="0" Width="130" Margin="0,0,8,0"
+                                  SelectionChanged="CompareToCombo_SelectionChanged"
+                                  ToolTip="Compare current period against a baseline">
+                            <ComboBoxItem Content="None"/>
+                            <ComboBoxItem Content="Yesterday"/>
+                            <ComboBoxItem Content="Last week"/>
+                            <ComboBoxItem Content="Same day last week"/>
+                        </ComboBox>
+                        <TextBlock Text="|" VerticalAlignment="Center" Margin="0,0,4,0" Foreground="{DynamicResource ForegroundBrush}"/>
                         <TextBlock Text="Times:" VerticalAlignment="Center" Margin="0,0,4,0" Foreground="{DynamicResource ForegroundBrush}"/>
                         <ComboBox x:Name="TimeDisplayModeBox" Width="120" SelectionChanged="TimeDisplayMode_SelectionChanged" ToolTip="How timestamps are displayed across all tabs">
                             <ComboBoxItem Content="Server Time" Tag="ServerTime"/>
diff --git a/Dashboard/ServerTab.xaml.cs b/Dashboard/ServerTab.xaml.cs
index c207bad..a6eb9cf 100644
--- a/Dashboard/ServerTab.xaml.cs
+++ b/Dashboard/ServerTab.xaml.cs
@@ -157,6 +157,7 @@ public ServerTab(ServerConnection serverConnection, int utcOffsetMinutes = 0)
             {
                 SetDrillDownGlobalRange(from, to);
             };
+            PerformanceTab.SubTabChanged += () => UpdateCompareDropdownState();
             SystemEventsContent.Initialize(_databaseService);
             var baselineProvider = new Analysis.SqlServerBaselineProvider(_databaseService.ConnectionString);
             ResourceMetricsContent.Initialize(_databaseService, baselineProvider);
@@ -1639,6 +1640,8 @@ private async void DataTabControl_SelectionChanged(object sender, SelectionChang
             // Only handle events from the main DataTabControl, not from nested sub-tab controls
             if (e.Source != DataTabControl) return;
 
+            UpdateCompareDropdownState();
+
             // Don't refresh during initial load or if already refreshing
             if (_isRefreshing || !IsLoaded) return;
 
@@ -1678,6 +1681,76 @@ private void EditSchedules_Click(object sender, RoutedEventArgs e)
             scheduleWindow.ShowDialog();
         }
 
+        #region Global Compare Dropdown
+
+        private async void CompareToCombo_SelectionChanged(object sender, SelectionChangedEventArgs e)
+        {
+            if (!IsLoaded || _isRefreshing) return;
+
+            var comparisonRange = GetComparisonRange();
+
+            try
+            {
+                // Feed comparison to Resource Metrics (Server Trends overlay)
+                await ResourceMetricsContent.SetComparisonRangeAsync(comparisonRange);
+
+                // Feed comparison to Query Performance grids
+                PerformanceTab.SetComparisonRange(comparisonRange);
+                await PerformanceTab.RefreshComparisonAsync();
+            }
+            catch (Exception ex)
+            {
+                Logger.Error($"Comparison refresh failed: {ex.Message}", ex);
+            }
+        }
+
+        private (DateTime From, DateTime To)? GetComparisonRange()
+        {
+            if (CompareToCombo == null || CompareToCombo.SelectedIndex <= 0) return null;
+
+            var currentEnd = _globalToDate ?? DateTime.UtcNow;
+            var currentStart = _globalFromDate ?? currentEnd.AddHours(-_globalHoursBack);
+
+            return CompareToCombo.SelectedIndex switch
+            {
+                1 => (currentStart.AddDays(-1), currentEnd.AddDays(-1)),   // Yesterday
+                2 => (currentStart.AddDays(-7), currentEnd.AddDays(-7)),   // Last week
+                3 => (currentStart.AddDays(-7), currentEnd.AddDays(-7)),   // Same day last week
+                _ => null
+            };
+        }
+
+        private bool IsComparisonSupportedOnCurrentTab()
+        {
+            return DataTabControl.SelectedIndex switch
+            {
+                1 => PerformanceTab.SubTabControl.SelectedIndex is 3 or 4 or 5, // Query Stats / Proc Stats / Query Store
+                3 => true, // Resource Metrics — Server Trends overlay
+                _ => false
+            };
+        }
+
+        private void UpdateCompareDropdownState()
+        {
+            var supported = IsComparisonSupportedOnCurrentTab();
+
+            if (supported)
+            {
+                CompareToCombo.IsEnabled = true;
+                CompareToCombo.Opacity = 1.0;
+                CompareToCombo.ToolTip = "Compare current period against a baseline";
+            }
+            else
+            {
+                CompareToCombo.SelectedIndex = 0;
+                CompareToCombo.IsEnabled = false;
+                CompareToCombo.Opacity = 0.5;
+                CompareToCombo.ToolTip = "Comparison is not available for this tab";
+            }
+        }
+
+        #endregion
+
         private void TimeDisplayMode_SelectionChanged(object sender, SelectionChangedEventArgs e)
         {
             if (TimeDisplayModeBox.SelectedItem is not ComboBoxItem item) return;
diff --git a/Dashboard/Services/DatabaseService.QueryPerformance.cs b/Dashboard/Services/DatabaseService.QueryPerformance.cs
index 2e162eb..9e59094 100644
--- a/Dashboard/Services/DatabaseService.QueryPerformance.cs
+++ b/Dashboard/Services/DatabaseService.QueryPerformance.cs
@@ -3810,5 +3810,340 @@ ORDER BY
                 CellDetails = cellDetails
             };
         }
+
+        /// <summary>
+        /// Gets query stats comparison between a current time range and a baseline range.
+        /// Uses delta columns for accurate period-level aggregation.
+        /// </summary>
+        public async Task<List<Models.QueryStatsComparisonItem>> GetQueryStatsComparisonAsync(
+            DateTime currentStart, DateTime currentEnd,
+            DateTime baselineStart, DateTime baselineEnd)
+        {
+            var items = new List<Models.QueryStatsComparisonItem>();
+
+            await using var tc = await OpenThrottledConnectionAsync();
+            var connection = tc.Connection;
+
+            string query = @"
+SET TRANSACTION ISOLATION LEVEL READ UNCOMMITTED;
+
+;WITH top_hashes AS (
+    SELECT DISTINCT query_hash, database_name, object_name, schema_name, object_type
+    FROM (
+        SELECT TOP 100 query_hash, database_name, object_name, schema_name, object_type
+        FROM collect.query_stats
+        WHERE collection_time >= @currentStart AND collection_time <= @currentEnd
+        AND   execution_count_delta > 0
+        GROUP BY query_hash, database_name, object_name, schema_name, object_type
+        ORDER BY SUM(execution_count_delta) DESC
+        UNION
+        SELECT TOP 100 query_hash, database_name, object_name, schema_name, object_type
+        FROM collect.query_stats
+        WHERE collection_time >= @baselineStart AND collection_time <= @baselineEnd
+        AND   execution_count_delta > 0
+        GROUP BY query_hash, database_name, object_name, schema_name, object_type
+        ORDER BY SUM(execution_count_delta) DESC
+    ) AS combined
+),
+current_period AS (
+    SELECT th.database_name,
+           CONVERT(nvarchar(20), th.query_hash, 1) AS query_hash,
+           th.object_name, th.schema_name, th.object_type,
+           SUM(qs.execution_count_delta) AS exec_count,
+           SUM(qs.total_elapsed_time_delta) / NULLIF(SUM(qs.execution_count_delta), 0) / 1000.0 AS avg_duration_ms,
+           SUM(qs.total_worker_time_delta) / NULLIF(SUM(qs.execution_count_delta), 0) / 1000.0 AS avg_cpu_ms,
+           SUM(qs.total_physical_reads_delta) / NULLIF(SUM(qs.execution_count_delta), 0) AS avg_reads,
+           LEFT(CAST(DECOMPRESS(MAX(qs.query_text)) AS nvarchar(max)), 500) AS query_text
+    FROM top_hashes th
+    INNER JOIN collect.query_stats qs
+      ON  qs.query_hash = th.query_hash
+      AND qs.database_name = th.database_name
+      AND ISNULL(qs.object_name, N'') = ISNULL(th.object_name, N'')
+    WHERE qs.collection_time >= @currentStart AND qs.collection_time <= @currentEnd
+    AND   qs.execution_count_delta > 0
+    GROUP BY th.database_name, th.query_hash, th.object_name, th.schema_name, th.object_type
+),
+baseline_period AS (
+    SELECT th.database_name,
+           CONVERT(nvarchar(20), th.query_hash, 1) AS query_hash,
+           th.object_name, th.schema_name, th.object_type,
+           SUM(qs.execution_count_delta) AS exec_count,
+           SUM(qs.total_elapsed_time_delta) / NULLIF(SUM(qs.execution_count_delta), 0) / 1000.0 AS avg_duration_ms,
+           SUM(qs.total_worker_time_delta) / NULLIF(SUM(qs.execution_count_delta), 0) / 1000.0 AS avg_cpu_ms,
+           SUM(qs.total_physical_reads_delta) / NULLIF(SUM(qs.execution_count_delta), 0) AS avg_reads,
+           LEFT(CAST(DECOMPRESS(MAX(qs.query_text)) AS nvarchar(max)), 500) AS query_text
+    FROM top_hashes th
+    INNER JOIN collect.query_stats qs
+      ON  qs.query_hash = th.query_hash
+      AND qs.database_name = th.database_name
+      AND ISNULL(qs.object_name, N'') = ISNULL(th.object_name, N'')
+    WHERE qs.collection_time >= @baselineStart AND qs.collection_time <= @baselineEnd
+    AND   qs.execution_count_delta > 0
+    GROUP BY th.database_name, th.query_hash, th.object_name, th.schema_name, th.object_type
+)
+SELECT COALESCE(c.database_name, b.database_name) AS database_name,
+       COALESCE(c.query_hash, b.query_hash) AS query_hash,
+       COALESCE(c.object_name, b.object_name) AS object_name,
+       COALESCE(c.schema_name, b.schema_name) AS schema_name,
+       COALESCE(c.object_type, b.object_type) AS object_type,
+       COALESCE(c.query_text, b.query_text) AS query_text,
+       c.exec_count, c.avg_duration_ms, c.avg_cpu_ms, c.avg_reads,
+       b.exec_count AS baseline_exec_count,
+       b.avg_duration_ms AS baseline_avg_duration_ms,
+       b.avg_cpu_ms AS baseline_avg_cpu_ms,
+       b.avg_reads AS baseline_avg_reads
+FROM current_period c
+FULL OUTER JOIN baseline_period b
+  ON  ISNULL(c.database_name, N'') = ISNULL(b.database_name, N'')
+  AND ISNULL(c.query_hash, N'') = ISNULL(b.query_hash, N'')
+  AND ISNULL(c.object_name, N'') = ISNULL(b.object_name, N'')
+  AND ISNULL(c.schema_name, N'') = ISNULL(b.schema_name, N'')
+  AND ISNULL(c.object_type, N'') = ISNULL(b.object_type, N'');";
+
+            using var command = new SqlCommand(query, connection);
+            command.CommandTimeout = 120;
+            command.Parameters.Add(new SqlParameter("@currentStart", SqlDbType.DateTime2) { Value = currentStart });
+            command.Parameters.Add(new SqlParameter("@currentEnd", SqlDbType.DateTime2) { Value = currentEnd });
+            command.Parameters.Add(new SqlParameter("@baselineStart", SqlDbType.DateTime2) { Value = baselineStart });
+            command.Parameters.Add(new SqlParameter("@baselineEnd", SqlDbType.DateTime2) { Value = baselineEnd });
+
+            using var reader = await command.ExecuteReaderAsync();
+            while (await reader.ReadAsync())
+            {
+                items.Add(new Models.QueryStatsComparisonItem
+                {
+                    DatabaseName = reader.IsDBNull(0) ? "" : reader.GetString(0),
+                    QueryHash = reader.IsDBNull(1) ? "" : reader.GetString(1),
+                    ObjectName = reader.IsDBNull(2) ? null : reader.GetString(2),
+                    SchemaName = reader.IsDBNull(3) ? null : reader.GetString(3),
+                    ObjectType = reader.IsDBNull(4) ? null : reader.GetString(4),
+                    QueryText = reader.IsDBNull(5) ? "" : reader.GetString(5),
+                    ExecutionCount = reader.IsDBNull(6) ? 0 : reader.GetInt64(6),
+                    AvgDurationMs = reader.IsDBNull(7) ? 0 : Convert.ToDouble(reader.GetValue(7), CultureInfo.InvariantCulture),
+                    AvgCpuMs = reader.IsDBNull(8) ? 0 : Convert.ToDouble(reader.GetValue(8), CultureInfo.InvariantCulture),
+                    AvgReads = reader.IsDBNull(9) ? 0 : Convert.ToDouble(reader.GetValue(9), CultureInfo.InvariantCulture),
+                    BaselineExecutionCount = reader.IsDBNull(10) ? 0 : reader.GetInt64(10),
+                    BaselineAvgDurationMs = reader.IsDBNull(11) ? 0 : Convert.ToDouble(reader.GetValue(11), CultureInfo.InvariantCulture),
+                    BaselineAvgCpuMs = reader.IsDBNull(12) ? 0 : Convert.ToDouble(reader.GetValue(12), CultureInfo.InvariantCulture),
+                    BaselineAvgReads = reader.IsDBNull(13) ? 0 : Convert.ToDouble(reader.GetValue(13), CultureInfo.InvariantCulture),
+                });
+            }
+
+            return items;
+        }
+
+        /// <summary>
+        /// Gets procedure stats comparison between a current time range and a baseline range.
+        /// </summary>
+        public async Task<List<Models.ProcedureStatsComparisonItem>> GetProcedureStatsComparisonAsync(
+            DateTime currentStart, DateTime currentEnd,
+            DateTime baselineStart, DateTime baselineEnd)
+        {
+            var items = new List<Models.ProcedureStatsComparisonItem>();
+
+            await using var tc = await OpenThrottledConnectionAsync();
+            var connection = tc.Connection;
+
+            string query = @"
+SET TRANSACTION ISOLATION LEVEL READ UNCOMMITTED;
+
+;WITH top_procs AS (
+    SELECT DISTINCT database_name, schema_name, object_name
+    FROM (
+        SELECT TOP 100 database_name, schema_name, object_name
+        FROM collect.procedure_stats
+        WHERE collection_time >= @currentStart AND collection_time <= @currentEnd
+        AND   execution_count_delta > 0
+        GROUP BY database_name, schema_name, object_name
+        ORDER BY SUM(execution_count_delta) DESC
+        UNION
+        SELECT TOP 100 database_name, schema_name, object_name
+        FROM collect.procedure_stats
+        WHERE collection_time >= @baselineStart AND collection_time <= @baselineEnd
+        AND   execution_count_delta > 0
+        GROUP BY database_name, schema_name, object_name
+        ORDER BY SUM(execution_count_delta) DESC
+    ) AS combined
+),
+current_period AS (
+    SELECT tp.database_name, tp.schema_name, tp.object_name,
+           SUM(ps.execution_count_delta) AS exec_count,
+           SUM(ps.total_elapsed_time_delta) / NULLIF(SUM(ps.execution_count_delta), 0) / 1000.0 AS avg_duration_ms,
+           SUM(ps.total_worker_time_delta) / NULLIF(SUM(ps.execution_count_delta), 0) / 1000.0 AS avg_cpu_ms,
+           SUM(ps.total_physical_reads_delta) / NULLIF(SUM(ps.execution_count_delta), 0) AS avg_reads
+    FROM top_procs tp
+    INNER JOIN collect.procedure_stats ps
+      ON  ps.database_name = tp.database_name
+      AND ISNULL(ps.schema_name, N'') = ISNULL(tp.schema_name, N'')
+      AND ps.object_name = tp.object_name
+    WHERE ps.collection_time >= @currentStart AND ps.collection_time <= @currentEnd
+    AND   ps.execution_count_delta > 0
+    GROUP BY tp.database_name, tp.schema_name, tp.object_name
+),
+baseline_period AS (
+    SELECT tp.database_name, tp.schema_name, tp.object_name,
+           SUM(ps.execution_count_delta) AS exec_count,
+           SUM(ps.total_elapsed_time_delta) / NULLIF(SUM(ps.execution_count_delta), 0) / 1000.0 AS avg_duration_ms,
+           SUM(ps.total_worker_time_delta) / NULLIF(SUM(ps.execution_count_delta), 0) / 1000.0 AS avg_cpu_ms,
+           SUM(ps.total_physical_reads_delta) / NULLIF(SUM(ps.execution_count_delta), 0) AS avg_reads
+    FROM top_procs tp
+    INNER JOIN collect.procedure_stats ps
+      ON  ps.database_name = tp.database_name
+      AND ISNULL(ps.schema_name, N'') = ISNULL(tp.schema_name, N'')
+      AND ps.object_name = tp.object_name
+    WHERE ps.collection_time >= @baselineStart AND ps.collection_time <= @baselineEnd
+    AND   ps.execution_count_delta > 0
+    GROUP BY tp.database_name, tp.schema_name, tp.object_name
+)
+SELECT COALESCE(c.database_name, b.database_name) AS database_name,
+       COALESCE(c.schema_name, b.schema_name) AS schema_name,
+       COALESCE(c.object_name, b.object_name) AS object_name,
+       c.exec_count, c.avg_duration_ms, c.avg_cpu_ms, c.avg_reads,
+       b.exec_count AS baseline_exec_count,
+       b.avg_duration_ms AS baseline_avg_duration_ms,
+       b.avg_cpu_ms AS baseline_avg_cpu_ms,
+       b.avg_reads AS baseline_avg_reads
+FROM current_period c
+FULL OUTER JOIN baseline_period b
+  ON  ISNULL(c.database_name, N'') = ISNULL(b.database_name, N'')
+  AND ISNULL(c.schema_name, N'') = ISNULL(b.schema_name, N'')
+  AND ISNULL(c.object_name, N'') = ISNULL(b.object_name, N'');";
+
+            using var command = new SqlCommand(query, connection);
+            command.CommandTimeout = 120;
+            command.Parameters.Add(new SqlParameter("@currentStart", SqlDbType.DateTime2) { Value = currentStart });
+            command.Parameters.Add(new SqlParameter("@currentEnd", SqlDbType.DateTime2) { Value = currentEnd });
+            command.Parameters.Add(new SqlParameter("@baselineStart", SqlDbType.DateTime2) { Value = baselineStart });
+            command.Parameters.Add(new SqlParameter("@baselineEnd", SqlDbType.DateTime2) { Value = baselineEnd });
+
+            using var reader = await command.ExecuteReaderAsync();
+            while (await reader.ReadAsync())
+            {
+                items.Add(new Models.ProcedureStatsComparisonItem
+                {
+                    DatabaseName = reader.IsDBNull(0) ? "" : reader.GetString(0),
+                    SchemaName = reader.IsDBNull(1) ? "" : reader.GetString(1),
+                    ObjectName = reader.IsDBNull(2) ? "" : reader.GetString(2),
+                    ExecutionCount = reader.IsDBNull(3) ? 0 : reader.GetInt64(3),
+                    AvgDurationMs = reader.IsDBNull(4) ? 0 : Convert.ToDouble(reader.GetValue(4), CultureInfo.InvariantCulture),
+                    AvgCpuMs = reader.IsDBNull(5) ? 0 : Convert.ToDouble(reader.GetValue(5), CultureInfo.InvariantCulture),
+                    AvgReads = reader.IsDBNull(6) ? 0 : Convert.ToDouble(reader.GetValue(6), CultureInfo.InvariantCulture),
+                    BaselineExecutionCount = reader.IsDBNull(7) ? 0 : reader.GetInt64(7),
+                    BaselineAvgDurationMs = reader.IsDBNull(8) ? 0 : Convert.ToDouble(reader.GetValue(8), CultureInfo.InvariantCulture),
+                    BaselineAvgCpuMs = reader.IsDBNull(9) ? 0 : Convert.ToDouble(reader.GetValue(9), CultureInfo.InvariantCulture),
+                    BaselineAvgReads = reader.IsDBNull(10) ? 0 : Convert.ToDouble(reader.GetValue(10), CultureInfo.InvariantCulture),
+                });
+            }
+
+            return items;
+        }
+
+        /// <summary>
+        /// Gets query store comparison between a current time range and a baseline range.
+        /// Reuses QueryStatsComparisonItem model (same identity: database + query_hash).
+        /// </summary>
+        public async Task<List<Models.QueryStatsComparisonItem>> GetQueryStoreComparisonAsync(
+            DateTime currentStart, DateTime currentEnd,
+            DateTime baselineStart, DateTime baselineEnd)
+        {
+            var items = new List<Models.QueryStatsComparisonItem>();
+
+            await using var tc = await OpenThrottledConnectionAsync();
+            var connection = tc.Connection;
+
+            string query = @"
+SET TRANSACTION ISOLATION LEVEL READ UNCOMMITTED;
+
+;WITH top_hashes AS (
+    SELECT DISTINCT database_name, query_hash
+    FROM (
+        SELECT TOP 100 database_name, query_hash
+        FROM collect.query_store_stats
+        WHERE collection_time >= @currentStart AND collection_time <= @currentEnd
+        AND   execution_count > 0
+        GROUP BY database_name, query_hash
+        ORDER BY SUM(execution_count) DESC
+        UNION
+        SELECT TOP 100 database_name, query_hash
+        FROM collect.query_store_stats
+        WHERE collection_time >= @baselineStart AND collection_time <= @baselineEnd
+        AND   execution_count > 0
+        GROUP BY database_name, query_hash
+        ORDER BY SUM(execution_count) DESC
+    ) AS combined
+),
+current_period AS (
+    SELECT th.database_name,
+           CONVERT(nvarchar(20), th.query_hash, 1) AS query_hash,
+           SUM(qs.execution_count) AS exec_count,
+           SUM(CAST(qs.execution_count AS bigint) * qs.avg_duration_us) / NULLIF(SUM(qs.execution_count), 0) / 1000.0 AS avg_duration_ms,
+           SUM(CAST(qs.execution_count AS bigint) * qs.avg_cpu_time_us) / NULLIF(SUM(qs.execution_count), 0) / 1000.0 AS avg_cpu_ms,
+           SUM(CAST(qs.execution_count AS bigint) * qs.avg_logical_io_reads) / NULLIF(SUM(qs.execution_count), 0) AS avg_reads,
+           MAX(qs.query_text) AS query_text
+    FROM top_hashes th
+    INNER JOIN collect.query_store_stats qs
+      ON  qs.query_hash = th.query_hash
+      AND qs.database_name = th.database_name
+    WHERE qs.collection_time >= @currentStart AND qs.collection_time <= @currentEnd
+    AND   qs.execution_count > 0
+    GROUP BY th.database_name, th.query_hash
+),
+baseline_period AS (
+    SELECT th.database_name,
+           CONVERT(nvarchar(20), th.query_hash, 1) AS query_hash,
+           SUM(qs.execution_count) AS exec_count,
+           SUM(CAST(qs.execution_count AS bigint) * qs.avg_duration_us) / NULLIF(SUM(qs.execution_count), 0) / 1000.0 AS avg_duration_ms,
+           SUM(CAST(qs.execution_count AS bigint) * qs.avg_cpu_time_us) / NULLIF(SUM(qs.execution_count), 0) / 1000.0 AS avg_cpu_ms,
+           SUM(CAST(qs.execution_count AS bigint) * qs.avg_logical_io_reads) / NULLIF(SUM(qs.execution_count), 0) AS avg_reads,
+           MAX(qs.query_text) AS query_text
+    FROM top_hashes th
+    INNER JOIN collect.query_store_stats qs
+      ON  qs.query_hash = th.query_hash
+      AND qs.database_name = th.database_name
+    WHERE qs.collection_time >= @baselineStart AND qs.collection_time <= @baselineEnd
+    AND   qs.execution_count > 0
+    GROUP BY th.database_name, th.query_hash
+)
+SELECT COALESCE(c.database_name, b.database_name) AS database_name,
+       COALESCE(c.query_hash, b.query_hash) AS query_hash,
+       COALESCE(c.query_text, b.query_text) AS query_text,
+       c.exec_count, c.avg_duration_ms, c.avg_cpu_ms, c.avg_reads,
+       b.exec_count AS baseline_exec_count,
+       b.avg_duration_ms AS baseline_avg_duration_ms,
+       b.avg_cpu_ms AS baseline_avg_cpu_ms,
+       b.avg_reads AS baseline_avg_reads
+FROM current_period c
+FULL OUTER JOIN baseline_period b
+  ON  ISNULL(c.database_name, N'') = ISNULL(b.database_name, N'')
+  AND ISNULL(c.query_hash, N'') = ISNULL(b.query_hash, N'');";
+
+            using var command = new SqlCommand(query, connection);
+            command.CommandTimeout = 120;
+            command.Parameters.Add(new SqlParameter("@currentStart", SqlDbType.DateTime2) { Value = currentStart });
+            command.Parameters.Add(new SqlParameter("@currentEnd", SqlDbType.DateTime2) { Value = currentEnd });
+            command.Parameters.Add(new SqlParameter("@baselineStart", SqlDbType.DateTime2) { Value = baselineStart });
+            command.Parameters.Add(new SqlParameter("@baselineEnd", SqlDbType.DateTime2) { Value = baselineEnd });
+
+            using var reader = await command.ExecuteReaderAsync();
+            while (await reader.ReadAsync())
+            {
+                items.Add(new Models.QueryStatsComparisonItem
+                {
+                    DatabaseName = reader.IsDBNull(0) ? "" : reader.GetString(0),
+                    QueryHash = reader.IsDBNull(1) ? "" : reader.GetString(1),
+                    QueryText = reader.IsDBNull(2) ? "" : reader.GetString(2),
+                    ExecutionCount = reader.IsDBNull(3) ? 0 : reader.GetInt64(3),
+                    AvgDurationMs = reader.IsDBNull(4) ? 0 : Convert.ToDouble(reader.GetValue(4), CultureInfo.InvariantCulture),
+                    AvgCpuMs = reader.IsDBNull(5) ? 0 : Convert.ToDouble(reader.GetValue(5), CultureInfo.InvariantCulture),
+                    AvgReads = reader.IsDBNull(6) ? 0 : Convert.ToDouble(reader.GetValue(6), CultureInfo.InvariantCulture),
+                    BaselineExecutionCount = reader.IsDBNull(7) ? 0 : reader.GetInt64(7),
+                    BaselineAvgDurationMs = reader.IsDBNull(8) ? 0 : Convert.ToDouble(reader.GetValue(8), CultureInfo.InvariantCulture),
+                    BaselineAvgCpuMs = reader.IsDBNull(9) ? 0 : Convert.ToDouble(reader.GetValue(9), CultureInfo.InvariantCulture),
+                    BaselineAvgReads = reader.IsDBNull(10) ? 0 : Convert.ToDouble(reader.GetValue(10), CultureInfo.InvariantCulture),
+                });
+            }
+
+            return items;
+        }
     }
 }

From 2c8af66fc0130f0f7805ecdeebe66dd4ca331d76 Mon Sep 17 00:00:00 2001
From: Erik Darling <2136037+erikdarlingdata@users.noreply.github.com>
Date: Tue, 7 Apr 2026 12:35:08 -0400
Subject: [PATCH 25/30] Expand Rule 3 to cover all 25 NonParallelPlanReason
 values

Warning: UDFs, cursors, table variables, remote queries, trace flags,
hints, DML OUTPUT, writeback variables
Info: cost below threshold, edition limits, memory-optimized, upgrade

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

diff --git a/Dashboard/Services/PlanAnalyzer.cs b/Dashboard/Services/PlanAnalyzer.cs
index 2b55e67..6965bbb 100644
--- a/Dashboard/Services/PlanAnalyzer.cs
+++ b/Dashboard/Services/PlanAnalyzer.cs
@@ -47,16 +47,63 @@ private static void AnalyzeStatement(PlanStatement stmt)
         {
             var reason = stmt.NonParallelPlanReason switch
             {
+                // User/config forced serial
                 "MaxDOPSetToOne" => "MAXDOP is set to 1",
+                "QueryHintNoParallelSet" => "OPTION (MAXDOP 1) hint forces serial execution",
+                "ParallelismDisabledByTraceFlag" => "Parallelism disabled by trace flag",
+
+                // Passive — optimizer chose serial, nothing wrong
                 "EstimatedDOPIsOne" => "Estimated DOP is 1 (the plan's estimated cost was below the cost threshold for parallelism)",
+
+                // Edition/environment limitations
                 "NoParallelPlansInDesktopOrExpressEdition" => "Express/Desktop edition does not support parallelism",
+                "NoParallelCreateIndexInNonEnterpriseEdition" => "Parallel index creation requires Enterprise edition",
+                "NoParallelPlansDuringUpgrade" => "Parallel plans disabled during upgrade",
+                "NoParallelForPDWCompilation" => "Parallel plans not supported for PDW compilation",
+                "NoParallelForCloudDBReplication" => "Parallel plans not supported during cloud DB replication",
+
+                // Query constructs that block parallelism (actionable)
                 "CouldNotGenerateValidParallelPlan" => "Optimizer could not generate a valid parallel plan. Common causes: scalar UDFs, inserts into table variables, certain system functions, or OPTION (MAXDOP 1) hints",
-                "QueryHintNoParallelSet" => "OPTION (MAXDOP 1) hint forces serial execution",
+                "TSQLUserDefinedFunctionsNotParallelizable" => "T-SQL scalar UDF prevents parallelism. Rewrite as an inline table-valued function, or on SQL Server 2019+ check if the UDF is eligible for automatic inlining",
+                "CLRUserDefinedFunctionRequiresDataAccess" => "CLR UDF with data access prevents parallelism",
+                "NonParallelizableIntrinsicFunction" => "Non-parallelizable intrinsic function in the query",
+                "TableVariableTransactionsDoNotSupportParallelNestedTransaction" => "Table variable transaction prevents parallelism. Consider using a #temp table instead",
+                "UpdatingWritebackVariable" => "Updating a writeback variable prevents parallelism",
+                "DMLQueryReturnsOutputToClient" => "DML with OUTPUT clause returning results to client prevents parallelism",
+                "MixedSerialAndParallelOnlineIndexBuildNotSupported" => "Mixed serial/parallel online index build not supported",
+                "NoRangesResumableCreate" => "Resumable index create cannot use parallelism for this operation",
+
+                // Cursor limitations
+                "NoParallelCursorFetchByBookmark" => "Cursor fetch by bookmark cannot use parallelism",
+                "NoParallelDynamicCursor" => "Dynamic cursors cannot use parallelism",
+                "NoParallelFastForwardCursor" => "Fast-forward cursors cannot use parallelism",
+
+                // Memory-optimized / natively compiled
+                "NoParallelForMemoryOptimizedTables" => "Memory-optimized tables do not support parallel plans",
+                "NoParallelForDmlOnMemoryOptimizedTable" => "DML on memory-optimized tables cannot use parallelism",
+                "NoParallelForNativelyCompiledModule" => "Natively compiled modules do not support parallelism",
+
+                // Remote queries
+                "NoParallelWithRemoteQuery" => "Remote queries cannot use parallelism",
+                "NoRemoteParallelismForMatrix" => "Remote parallelism not available for this query shape",
+
                 _ => stmt.NonParallelPlanReason
             };
 
-            var isActionable = stmt.NonParallelPlanReason is "MaxDOPSetToOne"
-                or "QueryHintNoParallelSet" or "CouldNotGenerateValidParallelPlan";
+            var isActionable = stmt.NonParallelPlanReason is
+                "MaxDOPSetToOne" or "QueryHintNoParallelSet" or "ParallelismDisabledByTraceFlag"
+                or "CouldNotGenerateValidParallelPlan"
+                or "TSQLUserDefinedFunctionsNotParallelizable"
+                or "CLRUserDefinedFunctionRequiresDataAccess"
+                or "NonParallelizableIntrinsicFunction"
+                or "TableVariableTransactionsDoNotSupportParallelNestedTransaction"
+                or "UpdatingWritebackVariable"
+                or "DMLQueryReturnsOutputToClient"
+                or "NoParallelCursorFetchByBookmark"
+                or "NoParallelDynamicCursor"
+                or "NoParallelFastForwardCursor"
+                or "NoParallelWithRemoteQuery"
+                or "NoRemoteParallelismForMatrix";
 
             stmt.PlanWarnings.Add(new PlanWarning
             {
diff --git a/Lite/Services/PlanAnalyzer.cs b/Lite/Services/PlanAnalyzer.cs
index 87cee2b..0ead490 100644
--- a/Lite/Services/PlanAnalyzer.cs
+++ b/Lite/Services/PlanAnalyzer.cs
@@ -47,16 +47,63 @@ private static void AnalyzeStatement(PlanStatement stmt)
         {
             var reason = stmt.NonParallelPlanReason switch
             {
+                // User/config forced serial
                 "MaxDOPSetToOne" => "MAXDOP is set to 1",
+                "QueryHintNoParallelSet" => "OPTION (MAXDOP 1) hint forces serial execution",
+                "ParallelismDisabledByTraceFlag" => "Parallelism disabled by trace flag",
+
+                // Passive — optimizer chose serial, nothing wrong
                 "EstimatedDOPIsOne" => "Estimated DOP is 1 (the plan's estimated cost was below the cost threshold for parallelism)",
+
+                // Edition/environment limitations
                 "NoParallelPlansInDesktopOrExpressEdition" => "Express/Desktop edition does not support parallelism",
+                "NoParallelCreateIndexInNonEnterpriseEdition" => "Parallel index creation requires Enterprise edition",
+                "NoParallelPlansDuringUpgrade" => "Parallel plans disabled during upgrade",
+                "NoParallelForPDWCompilation" => "Parallel plans not supported for PDW compilation",
+                "NoParallelForCloudDBReplication" => "Parallel plans not supported during cloud DB replication",
+
+                // Query constructs that block parallelism (actionable)
                 "CouldNotGenerateValidParallelPlan" => "Optimizer could not generate a valid parallel plan. Common causes: scalar UDFs, inserts into table variables, certain system functions, or OPTION (MAXDOP 1) hints",
-                "QueryHintNoParallelSet" => "OPTION (MAXDOP 1) hint forces serial execution",
+                "TSQLUserDefinedFunctionsNotParallelizable" => "T-SQL scalar UDF prevents parallelism. Rewrite as an inline table-valued function, or on SQL Server 2019+ check if the UDF is eligible for automatic inlining",
+                "CLRUserDefinedFunctionRequiresDataAccess" => "CLR UDF with data access prevents parallelism",
+                "NonParallelizableIntrinsicFunction" => "Non-parallelizable intrinsic function in the query",
+                "TableVariableTransactionsDoNotSupportParallelNestedTransaction" => "Table variable transaction prevents parallelism. Consider using a #temp table instead",
+                "UpdatingWritebackVariable" => "Updating a writeback variable prevents parallelism",
+                "DMLQueryReturnsOutputToClient" => "DML with OUTPUT clause returning results to client prevents parallelism",
+                "MixedSerialAndParallelOnlineIndexBuildNotSupported" => "Mixed serial/parallel online index build not supported",
+                "NoRangesResumableCreate" => "Resumable index create cannot use parallelism for this operation",
+
+                // Cursor limitations
+                "NoParallelCursorFetchByBookmark" => "Cursor fetch by bookmark cannot use parallelism",
+                "NoParallelDynamicCursor" => "Dynamic cursors cannot use parallelism",
+                "NoParallelFastForwardCursor" => "Fast-forward cursors cannot use parallelism",
+
+                // Memory-optimized / natively compiled
+                "NoParallelForMemoryOptimizedTables" => "Memory-optimized tables do not support parallel plans",
+                "NoParallelForDmlOnMemoryOptimizedTable" => "DML on memory-optimized tables cannot use parallelism",
+                "NoParallelForNativelyCompiledModule" => "Natively compiled modules do not support parallelism",
+
+                // Remote queries
+                "NoParallelWithRemoteQuery" => "Remote queries cannot use parallelism",
+                "NoRemoteParallelismForMatrix" => "Remote parallelism not available for this query shape",
+
                 _ => stmt.NonParallelPlanReason
             };
 
-            var isActionable = stmt.NonParallelPlanReason is "MaxDOPSetToOne"
-                or "QueryHintNoParallelSet" or "CouldNotGenerateValidParallelPlan";
+            var isActionable = stmt.NonParallelPlanReason is
+                "MaxDOPSetToOne" or "QueryHintNoParallelSet" or "ParallelismDisabledByTraceFlag"
+                or "CouldNotGenerateValidParallelPlan"
+                or "TSQLUserDefinedFunctionsNotParallelizable"
+                or "CLRUserDefinedFunctionRequiresDataAccess"
+                or "NonParallelizableIntrinsicFunction"
+                or "TableVariableTransactionsDoNotSupportParallelNestedTransaction"
+                or "UpdatingWritebackVariable"
+                or "DMLQueryReturnsOutputToClient"
+                or "NoParallelCursorFetchByBookmark"
+                or "NoParallelDynamicCursor"
+                or "NoParallelFastForwardCursor"
+                or "NoParallelWithRemoteQuery"
+                or "NoRemoteParallelismForMatrix";
 
             stmt.PlanWarnings.Add(new PlanWarning
             {

From f22215097d5e9cdb05955b3ef45ea8eee47a5309 Mon Sep 17 00:00:00 2001
From: Erik Darling <2136037+erikdarlingdata@users.noreply.github.com>
Date: Tue, 7 Apr 2026 13:48:49 -0400
Subject: [PATCH 26/30] Switch to release-signing and add SignPath sponsor
 attribution
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

SignPath FOSS certificate approved — switch from test-signing to
release-signing policy and add required sponsor section to README.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
---
 .github/workflows/build.yml |  6 +++---
 README.md                   | 11 +++++++++++
 2 files changed, 14 insertions(+), 3 deletions(-)

diff --git a/.github/workflows/build.yml b/.github/workflows/build.yml
index c3168b9..a235f90 100644
--- a/.github/workflows/build.yml
+++ b/.github/workflows/build.yml
@@ -114,7 +114,7 @@ jobs:
           api-token: '${{ secrets.SIGNPATH_API_TOKEN }}'
           organization-id: '7969f8b6-d946-4a74-9bac-a55856d8b8e0'
           project-slug: 'PerformanceMonitor'
-          signing-policy-slug: 'test-signing'
+          signing-policy-slug: 'release-signing'
           artifact-configuration-slug: 'Dashboard'
           github-artifact-id: '${{ steps.upload-dashboard.outputs.artifact-id }}'
           wait-for-completion: true
@@ -127,7 +127,7 @@ jobs:
           api-token: '${{ secrets.SIGNPATH_API_TOKEN }}'
           organization-id: '7969f8b6-d946-4a74-9bac-a55856d8b8e0'
           project-slug: 'PerformanceMonitor'
-          signing-policy-slug: 'test-signing'
+          signing-policy-slug: 'release-signing'
           artifact-configuration-slug: 'Lite'
           github-artifact-id: '${{ steps.upload-lite.outputs.artifact-id }}'
           wait-for-completion: true
@@ -140,7 +140,7 @@ jobs:
           api-token: '${{ secrets.SIGNPATH_API_TOKEN }}'
           organization-id: '7969f8b6-d946-4a74-9bac-a55856d8b8e0'
           project-slug: 'PerformanceMonitor'
-          signing-policy-slug: 'test-signing'
+          signing-policy-slug: 'release-signing'
           artifact-configuration-slug: 'Installers'
           github-artifact-id: '${{ steps.upload-installer.outputs.artifact-id }}'
           wait-for-completion: true
diff --git a/README.md b/README.md
index 2d3d4d3..dd6cb13 100644
--- a/README.md
+++ b/README.md
@@ -693,6 +693,17 @@ See [THIRD_PARTY_NOTICES.md](THIRD_PARTY_NOTICES.md) for complete license texts.
 
 ---
 
+## Sponsors
+
+<table>
+  <tr>
+    <td><a href="https://signpath.io"><img src="https://about.signpath.io/wp-content/uploads/2024/01/signpath_logo_blue.svg" alt="SignPath" width="40"></a></td>
+    <td>Free code signing on Windows provided by <a href="https://signpath.io">SignPath.io</a>, certificate by <a href="https://signpath.org">SignPath Foundation</a></td>
+  </tr>
+</table>
+
+---
+
 ## License
 
 Copyright (c) 2026 Darling Data, LLC. Licensed under the MIT License. See [LICENSE](LICENSE) for details.

From e8e13e5e5a398cdbcd2e0e07ae5131b7b984bbeb Mon Sep 17 00:00:00 2001
From: Erik Darling <2136037+erikdarlingdata@users.noreply.github.com>
Date: Wed, 8 Apr 2026 09:32:39 -0400
Subject: [PATCH 27/30] Fix CSV and clipboard exports writing StackPanel type
 name as column headers (#805)

Five inline export paths used col.Header?.ToString() which returns
"System.Windows.Controls.StackPanel" for complex headers. Replace with
DataGridClipboardBehavior.GetHeaderText() which extracts the TextBlock text.

Affected: ServerTab, FinOpsTab (clipboard + CSV), AlertsHistoryTab (clipboard + CSV).

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
---
 Lite/Controls/AlertsHistoryTab.xaml.cs | 5 +++--
 Lite/Controls/FinOpsTab.xaml.cs        | 5 +++--
 Lite/Controls/ServerTab.xaml.cs        | 2 +-
 3 files changed, 7 insertions(+), 5 deletions(-)

diff --git a/Lite/Controls/AlertsHistoryTab.xaml.cs b/Lite/Controls/AlertsHistoryTab.xaml.cs
index e6f37f3..d884459 100644
--- a/Lite/Controls/AlertsHistoryTab.xaml.cs
+++ b/Lite/Controls/AlertsHistoryTab.xaml.cs
@@ -19,6 +19,7 @@
 using Microsoft.Win32;
 using PerformanceMonitorLite.Controls;
 using PerformanceMonitorLite.Models;
+using PerformanceMonitorLite.Helpers;
 using PerformanceMonitorLite.Services;
 
 namespace PerformanceMonitorLite.Controls;
@@ -419,7 +420,7 @@ private void CopyAllRows_Click(object sender, RoutedEventArgs e)
 
         foreach (var col in grid.Columns)
         {
-            sb.Append(col.Header?.ToString() ?? "");
+            sb.Append(DataGridClipboardBehavior.GetHeaderText(col));
             sb.Append('\t');
         }
         sb.AppendLine();
@@ -456,7 +457,7 @@ private void ExportToCsv_Click(object sender, RoutedEventArgs e)
 
         var headers = new List<string>();
         foreach (var col in grid.Columns)
-            headers.Add(CsvEscape(col.Header?.ToString() ?? ""));
+            headers.Add(CsvEscape(DataGridClipboardBehavior.GetHeaderText(col)));
         sb.AppendLine(string.Join(",", headers));
 
         foreach (var item in grid.Items)
diff --git a/Lite/Controls/FinOpsTab.xaml.cs b/Lite/Controls/FinOpsTab.xaml.cs
index 67505af..ca5eda6 100644
--- a/Lite/Controls/FinOpsTab.xaml.cs
+++ b/Lite/Controls/FinOpsTab.xaml.cs
@@ -18,6 +18,7 @@
 using System.Windows.Media;
 using Microsoft.Win32;
 using PerformanceMonitorLite.Models;
+using PerformanceMonitorLite.Helpers;
 using PerformanceMonitorLite.Services;
 
 namespace PerformanceMonitorLite.Controls;
@@ -884,7 +885,7 @@ private void CopyAllRows_Click(object sender, RoutedEventArgs e)
 
         foreach (var col in grid.Columns)
         {
-            sb.Append(col.Header?.ToString() ?? "");
+            sb.Append(DataGridClipboardBehavior.GetHeaderText(col));
             sb.Append('\t');
         }
         sb.AppendLine();
@@ -930,7 +931,7 @@ private void ExportToCsv_Click(object sender, RoutedEventArgs e)
 
         var headers = new List<string>();
         foreach (var col in grid.Columns)
-            headers.Add(CsvEscape(col.Header?.ToString() ?? ""));
+            headers.Add(CsvEscape(DataGridClipboardBehavior.GetHeaderText(col)));
         sb.AppendLine(string.Join(",", headers));
 
         foreach (var item in grid.Items)
diff --git a/Lite/Controls/ServerTab.xaml.cs b/Lite/Controls/ServerTab.xaml.cs
index 6f3a374..4370176 100644
--- a/Lite/Controls/ServerTab.xaml.cs
+++ b/Lite/Controls/ServerTab.xaml.cs
@@ -4213,7 +4213,7 @@ private void ExportToCsv_Click(object sender, RoutedEventArgs e)
         var headers = new List<string>();
         foreach (var col in grid.Columns)
         {
-            headers.Add(CsvEscape(col.Header?.ToString() ?? "", sep));
+            headers.Add(CsvEscape(DataGridClipboardBehavior.GetHeaderText(col), sep));
         }
         sb.AppendLine(string.Join(sep, headers));
 

From a0bd8197bcbe0ebb4d67b8a516ba2e785bac0cef Mon Sep 17 00:00:00 2001
From: Erik Darling <2136037+erikdarlingdata@users.noreply.github.com>
Date: Wed, 8 Apr 2026 09:49:43 -0400
Subject: [PATCH 28/30] Fix broken SignPath sponsor logo

The external SVG URL on about.signpath.io now 404s. Host the logo
locally in docs/ so it won't break again.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
---
 README.md              | 2 +-
 docs/signpath_logo.svg | 1 +
 2 files changed, 2 insertions(+), 1 deletion(-)
 create mode 100644 docs/signpath_logo.svg

diff --git a/README.md b/README.md
index dd6cb13..9390c01 100644
--- a/README.md
+++ b/README.md
@@ -697,7 +697,7 @@ See [THIRD_PARTY_NOTICES.md](THIRD_PARTY_NOTICES.md) for complete license texts.
 
 <table>
   <tr>
-    <td><a href="https://signpath.io"><img src="https://about.signpath.io/wp-content/uploads/2024/01/signpath_logo_blue.svg" alt="SignPath" width="40"></a></td>
+    <td><a href="https://signpath.io"><img src="docs/signpath_logo.svg" alt="SignPath" width="40"></a></td>
     <td>Free code signing on Windows provided by <a href="https://signpath.io">SignPath.io</a>, certificate by <a href="https://signpath.org">SignPath Foundation</a></td>
   </tr>
 </table>
diff --git a/docs/signpath_logo.svg b/docs/signpath_logo.svg
new file mode 100644
index 0000000..673b327
--- /dev/null
+++ b/docs/signpath_logo.svg
@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" xml:space="preserve" style="enable-background:new 0 0 795.2 142.4" viewBox="0 0 795.2 142.4"><path fill="#fff" d="M143.7 23.8v-19c0-2.6-2.1-4.8-4.8-4.8H4.8C2.2 0 0 2.1 0 4.8v132.8c0 2.6 2.2 4.8 4.8 4.8h28.7c2.7 0 4.8-2.1 4.8-4.8V90.2c0-2.6 2.2-4.8 4.8-4.8h86.2c2.6 0 4.8-2.1 4.8-4.7v-19c0-2.6-2.2-4.7-4.8-4.7H43.1c-2.6 0-4.8-2.1-4.8-4.7v-19c0-2.6 2.2-4.7 4.8-4.7h95.8c2.7-.1 4.8-2.2 4.8-4.8m162.9 113.8v-19c0-2.6-2.2-4.7-4.8-4.7H196.4c-2.7 0-4.8-2.1-4.8-4.8v-19c0-2.6 2.1-4.8 4.8-4.8h95.8c2.6 0 4.8-2.1 4.8-4.7v-19c0-2.6-2.2-4.7-4.8-4.7h-95.8c-2.7 0-4.8-2.1-4.8-4.7v-19c0-2.6 2.1-4.7 4.8-4.7h105.4c2.6 0 4.8-2.1 4.8-4.7v-19c0-2.6-2.2-4.8-4.8-4.8H158.1c-2.7 0-4.8 2.1-4.8 4.8v132.8c0 2.6 2.1 4.8 4.8 4.8h143.7c2.7 0 4.8-2.2 4.8-4.8m162.9-23.7V85.4c0-15.7-12.9-28.4-28.7-28.4h-76.7c-5.3 0-9.6-4.2-9.6-9.5V38c0-5.3 4.3-9.5 9.6-9.5h62.3c2.7 0 4.8 2.1 4.8 4.7s2.1 4.7 4.8 4.7h28.8c2.6 0 4.8-2.1 4.8-4.7v-4.7c0-15.7-12.9-28.5-28.7-28.5h-95.8c-15.9 0-28.7 12.8-28.7 28.5V57c0 15.7 12.8 28.4 28.7 28.4h76.7c5.3 0 9.6 4.3 9.6 9.5v9.5c0 5.3-4.3 9.5-9.6 9.5h-62.3c-2.6 0-4.8-2.1-4.8-4.8 0-2.6-2.1-4.7-4.8-4.7H321c-2.6 0-4.8 2.1-4.8 4.7v4.8c0 15.7 12.8 28.5 28.7 28.5h95.8c15.9 0 28.8-12.8 28.8-28.5m162.9-90.1v-19c0-2.6-2.1-4.8-4.8-4.8H483.9c-2.7 0-4.8 2.1-4.8 4.8v19c0 2.6 2.1 4.7 4.8 4.7h47.9c2.6 0 4.8 2.1 4.8 4.7v104.4c0 2.6 2.1 4.8 4.8 4.8h28.7c2.7 0 4.8-2.1 4.8-4.8V33.2c0-2.6 2.1-4.7 4.8-4.7h47.9c2.6 0 4.8-2.1 4.8-4.7m124.5 80.6c0 5.3-4.3 9.5-9.6 9.5h-57.5c-5.3 0-9.6-4.2-9.6-9.5V38c0-5.3 4.3-9.5 9.6-9.5h57.5c5.3 0 9.6 4.2 9.6 9.5v66.4zm38.3 9.5V28.5c0-15.7-12.8-28.5-28.7-28.5h-95.8C654.9 0 642 12.8 642 28.5v85.4c0 15.7 12.9 28.5 28.7 28.5h95.8c15.9 0 28.7-12.8 28.7-28.5"/></svg>
\ No newline at end of file

From 176ebfb72203cef58cfcb8eab9adafc09a5c78ad Mon Sep 17 00:00:00 2001
From: Erik Darling <2136037+erikdarlingdata@users.noreply.github.com>
Date: Wed, 8 Apr 2026 09:52:13 -0400
Subject: [PATCH 29/30] Release v2.6.0: version bumps and changelog

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
---
 CHANGELOG.md                                 | 45 ++++++++++++++++++++
 Dashboard/Dashboard.csproj                   |  8 ++--
 Installer.Core/Installer.Core.csproj         |  8 ++--
 Installer/PerformanceMonitorInstaller.csproj |  8 ++--
 Lite/PerformanceMonitorLite.csproj           |  8 ++--
 5 files changed, 61 insertions(+), 16 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 36b6afd..e0ebd15 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -5,6 +5,51 @@ 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.6.0] - 2026-04-08
+
+### Added
+
+- **Correlated timeline lanes** on Lite Overview and Dashboard — synchronized CPU, memory, waits, and TempDB trend lanes for at-a-glance correlation ([#688])
+- **Dynamic baselines and anomaly detection** in Lite and Dashboard — automatic baseline calculation with anomaly highlighting on key metrics ([#692], [#693])
+- **Query grid comparison** — before/after comparison mode for query grids in Lite and Dashboard with global Compare dropdown ([#687])
+- **Nonclustered index count badge** on modification operators in plan viewer ([#788])
+- **Upgrade detection in Edit Server** dialog — see pending upgrades without adding a new server ([#772])
+- **CLI installer interactive mode** prompts for trust-cert and encryption settings ([#784])
+- **SignPath code signing** — release binaries are now digitally signed via the [SignPath FOSS](https://signpath.io) program
+
+### Changed
+
+- **PlanAnalyzer Rule 3 (Serial Plan)** comprehensively refined — severity demotion for TRIVIAL and 0ms plans, `CouldNotGenerateValidParallelPlan` treated as actionable, all 25 `NonParallelPlanReason` values now covered
+- **PlanAnalyzer warning rules** ported from PerformanceStudio improvements
+- **Text readability** — replaced all muted/dim text colors with full foreground colors for readability
+
+### Fixed
+
+- **Embedded resource upgrade discovery** broken — upgrades silently returned zero results for Dashboard installs ([#772])
+- **Archive compaction OOM** on large parquet groups
+- **CLI installer argument parsing** treating flags as positional args ([#786])
+- **Lite long-running query alerts** firing on stale DuckDB snapshots
+- **FinOps Enterprise feature detection** now queries all databases and filters to TDE only ([#780])
+- **Second launch error** — now brings existing window to foreground instead ([#769])
+- **Overview tab Memory Grant** showing 0 for all timestamps ([#776])
+- **Lite FinOps Enterprise features** query error on servers without `database_id` column ([#777])
+- **Collector health status** incorrect for on-load collectors
+- **CSV and clipboard exports** writing `System.Windows.Controls.StackPanel` as column headers instead of actual header text ([#805])
+
+[#687]: https://github.com/erikdarlingdata/PerformanceMonitor/issues/687
+[#688]: https://github.com/erikdarlingdata/PerformanceMonitor/issues/688
+[#692]: https://github.com/erikdarlingdata/PerformanceMonitor/issues/692
+[#693]: https://github.com/erikdarlingdata/PerformanceMonitor/issues/693
+[#769]: https://github.com/erikdarlingdata/PerformanceMonitor/issues/769
+[#772]: https://github.com/erikdarlingdata/PerformanceMonitor/issues/772
+[#776]: https://github.com/erikdarlingdata/PerformanceMonitor/issues/776
+[#777]: https://github.com/erikdarlingdata/PerformanceMonitor/issues/777
+[#780]: https://github.com/erikdarlingdata/PerformanceMonitor/issues/780
+[#784]: https://github.com/erikdarlingdata/PerformanceMonitor/issues/784
+[#786]: https://github.com/erikdarlingdata/PerformanceMonitor/issues/786
+[#788]: https://github.com/erikdarlingdata/PerformanceMonitor/issues/788
+[#805]: https://github.com/erikdarlingdata/PerformanceMonitor/issues/805
+
 ## [2.5.0] - 2026-03-30
 
 ### Important
diff --git a/Dashboard/Dashboard.csproj b/Dashboard/Dashboard.csproj
index a3585aa..8fc7039 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.5.0</Version>
-    <AssemblyVersion>2.5.0.0</AssemblyVersion>
-    <FileVersion>2.5.0.0</FileVersion>
-    <InformationalVersion>2.5.0</InformationalVersion>
+    <Version>2.6.0</Version>
+    <AssemblyVersion>2.6.0.0</AssemblyVersion>
+    <FileVersion>2.6.0.0</FileVersion>
+    <InformationalVersion>2.6.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 6c4ca00..fbf0387 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.5.0</Version>
-    <AssemblyVersion>2.5.0.0</AssemblyVersion>
-    <FileVersion>2.5.0.0</FileVersion>
-    <InformationalVersion>2.5.0</InformationalVersion>
+    <Version>2.6.0</Version>
+    <AssemblyVersion>2.6.0.0</AssemblyVersion>
+    <FileVersion>2.6.0.0</FileVersion>
+    <InformationalVersion>2.6.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 2f58b54..7c3fa1a 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.5.0</Version>
-    <AssemblyVersion>2.5.0.0</AssemblyVersion>
-    <FileVersion>2.5.0.0</FileVersion>
-    <InformationalVersion>2.5.0</InformationalVersion>
+    <Version>2.6.0</Version>
+    <AssemblyVersion>2.6.0.0</AssemblyVersion>
+    <FileVersion>2.6.0.0</FileVersion>
+    <InformationalVersion>2.6.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 5ccd3c3..d87dde0 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.5.0</Version>
-    <AssemblyVersion>2.5.0.0</AssemblyVersion>
-    <FileVersion>2.5.0.0</FileVersion>
-    <InformationalVersion>2.5.0</InformationalVersion>
+    <Version>2.6.0</Version>
+    <AssemblyVersion>2.6.0.0</AssemblyVersion>
+    <FileVersion>2.6.0.0</FileVersion>
+    <InformationalVersion>2.6.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>

From 58b2db75a2a17f8ef7c94345a418d7664e0d57a2 Mon Sep 17 00:00:00 2001
From: Erik Darling <2136037+erikdarlingdata@users.noreply.github.com>
Date: Wed, 8 Apr 2026 09:54:00 -0400
Subject: [PATCH 30/30] Fix SignPath logo SVG (was wrong image)

Replace incorrect Framer CDN image with the actual SignPath logo
from their official GitHub repo (SignPath/fdn-website).

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
---
 docs/signpath_logo.svg | 22 +++++++++++++++++++++-
 1 file changed, 21 insertions(+), 1 deletion(-)

diff --git a/docs/signpath_logo.svg b/docs/signpath_logo.svg
index 673b327..7b45355 100644
--- a/docs/signpath_logo.svg
+++ b/docs/signpath_logo.svg
@@ -1 +1,21 @@
-<svg xmlns="http://www.w3.org/2000/svg" xml:space="preserve" style="enable-background:new 0 0 795.2 142.4" viewBox="0 0 795.2 142.4"><path fill="#fff" d="M143.7 23.8v-19c0-2.6-2.1-4.8-4.8-4.8H4.8C2.2 0 0 2.1 0 4.8v132.8c0 2.6 2.2 4.8 4.8 4.8h28.7c2.7 0 4.8-2.1 4.8-4.8V90.2c0-2.6 2.2-4.8 4.8-4.8h86.2c2.6 0 4.8-2.1 4.8-4.7v-19c0-2.6-2.2-4.7-4.8-4.7H43.1c-2.6 0-4.8-2.1-4.8-4.7v-19c0-2.6 2.2-4.7 4.8-4.7h95.8c2.7-.1 4.8-2.2 4.8-4.8m162.9 113.8v-19c0-2.6-2.2-4.7-4.8-4.7H196.4c-2.7 0-4.8-2.1-4.8-4.8v-19c0-2.6 2.1-4.8 4.8-4.8h95.8c2.6 0 4.8-2.1 4.8-4.7v-19c0-2.6-2.2-4.7-4.8-4.7h-95.8c-2.7 0-4.8-2.1-4.8-4.7v-19c0-2.6 2.1-4.7 4.8-4.7h105.4c2.6 0 4.8-2.1 4.8-4.7v-19c0-2.6-2.2-4.8-4.8-4.8H158.1c-2.7 0-4.8 2.1-4.8 4.8v132.8c0 2.6 2.1 4.8 4.8 4.8h143.7c2.7 0 4.8-2.2 4.8-4.8m162.9-23.7V85.4c0-15.7-12.9-28.4-28.7-28.4h-76.7c-5.3 0-9.6-4.2-9.6-9.5V38c0-5.3 4.3-9.5 9.6-9.5h62.3c2.7 0 4.8 2.1 4.8 4.7s2.1 4.7 4.8 4.7h28.8c2.6 0 4.8-2.1 4.8-4.7v-4.7c0-15.7-12.9-28.5-28.7-28.5h-95.8c-15.9 0-28.7 12.8-28.7 28.5V57c0 15.7 12.8 28.4 28.7 28.4h76.7c5.3 0 9.6 4.3 9.6 9.5v9.5c0 5.3-4.3 9.5-9.6 9.5h-62.3c-2.6 0-4.8-2.1-4.8-4.8 0-2.6-2.1-4.7-4.8-4.7H321c-2.6 0-4.8 2.1-4.8 4.7v4.8c0 15.7 12.8 28.5 28.7 28.5h95.8c15.9 0 28.8-12.8 28.8-28.5m162.9-90.1v-19c0-2.6-2.1-4.8-4.8-4.8H483.9c-2.7 0-4.8 2.1-4.8 4.8v19c0 2.6 2.1 4.7 4.8 4.7h47.9c2.6 0 4.8 2.1 4.8 4.7v104.4c0 2.6 2.1 4.8 4.8 4.8h28.7c2.7 0 4.8-2.1 4.8-4.8V33.2c0-2.6 2.1-4.7 4.8-4.7h47.9c2.6 0 4.8-2.1 4.8-4.7m124.5 80.6c0 5.3-4.3 9.5-9.6 9.5h-57.5c-5.3 0-9.6-4.2-9.6-9.5V38c0-5.3 4.3-9.5 9.6-9.5h57.5c5.3 0 9.6 4.2 9.6 9.5v66.4zm38.3 9.5V28.5c0-15.7-12.8-28.5-28.7-28.5h-95.8C654.9 0 642 12.8 642 28.5v85.4c0 15.7 12.9 28.5 28.7 28.5h95.8c15.9 0 28.7-12.8 28.7-28.5"/></svg>
\ No newline at end of file
+<?xml version="1.0" encoding="UTF-8" standalone="no"?>
+<svg xmlns="http://www.w3.org/2000/svg" id="Layer_1" viewbox="0,0,620.2,124.6" width="620.20001" height="124.6">
+  <title>SignPath GmbH</title>
+  <g id="g3684" transform="translate(-27.1 -22.8)">
+    <path id="path3682" fill="#22ccff" d="M133.4 22.8H62.6L27.1 84.2l35.4 61.4h70.9l35.4-61.4zm1.7 68.6c-.7 1.6-2.3 2.6-4.1 2.6H94.2c-2.5 0-4.5-2-4.5-4.5s2-4.5 4.5-4.5H121l-10.5-11.9a4.43 4.43 0 0 1 0-5.9L121 55.3H76.7v71.2c0 2.5-2 4.5-4.5 4.5s-4.5-2-4.5-4.5V41.7c0-2.5 2-4.5 4.5-4.5s4.5 2 4.5 4.5v4.6H131c1.8 0 3.4 1 4.1 2.6.7 1.6.4 3.5-.7 4.8L120 70.1l14.4 16.4c1.1 1.4 1.4 3.3.7 4.9z"/>
+  </g>
+  <g id="Inhalt" transform="translate(-27.1 -22.8)">
+    <g id="g3705">
+      <g id="g3703">
+        <path id="path3687" fill="#fff" d="M208.4 104c7.3 5.8 16 9.2 25.3 9.2 9.1 0 15.5-3.2 15.5-10.4 0-6.2-4-8.7-11.2-11.4l-11.6-4.2c-10.6-3.9-18.7-9.6-18.7-22.7 0-14 12.2-21.7 26.9-21.7 9 0 17.1 2.3 23.5 6.5v13.9c-6.6-5.1-13.9-8.6-23.2-8.6-8.1 0-14 3.1-14 9.6 0 5.8 3.8 8.2 10.4 10.5l12.9 4.7c12.5 4.5 18.2 11.6 18.2 23.1 0 14.5-12.3 22.6-28.6 22.6-10.6 0-19.7-3.1-25.3-7z"/>
+        <path id="path3689" fill="#fff" d="M280.5 56.7c-4.3 0-8.1-3.5-8.1-7.9s3.8-7.9 8.1-7.9 8.1 3.5 8.1 7.9-3.8 7.9-8.1 7.9zm6.5 67.2h-13V66.2h13z"/>
+        <path id="path3691" fill="#fff" d="M339.1 118.2c-2.6 3.1-8.1 6-14.5 6-17 0-26.6-14.2-26.6-29.6 0-15.4 9.6-29.6 26.6-29.6 6.5 0 11.9 2.9 14.5 6v-4.7h13v52.9c0 21-16 28.2-29.6 28.2-7.7 0-14.5-1.9-19.2-4.9v-13.8c6 5.3 11.9 7.3 19.2 7.3 9.2 0 16.6-5.5 16.6-15.8zm0-35c-2.2-3.9-6.9-6.9-12.3-6.9-10 0-15.7 7.7-15.7 18.2s5.7 18.2 15.7 18.2c5.5 0 10.1-3 12.3-6.9z"/>
+        <path id="path3693" fill="#fff" d="M367 66.2h13v5.5c3.1-3.6 8.8-6.8 15.6-6.8 13.1 0 20.4 8.7 20.4 21.4v37.5h-13V88.6c0-7.1-3.5-11.8-10.9-11.8-5.6 0-10.6 3.5-12.1 9.2v37.9h-13z"/>
+        <path id="path3695" fill="#fff" d="M445 94.1v29.7h-13.5V44.1h30.8c16.5 0 27.3 8.6 27.3 25.1 0 16.2-10.8 24.9-27.3 24.9zm17.1-38.3h-17v26.6h17c9.4 0 14.2-5.6 14.2-13.2-.1-7.9-4.9-13.4-14.2-13.4z"/>
+        <path id="path3697" fill="#fff" d="M530.1 87c0-6.5-5.2-10.3-13.2-10.3-6.2 0-11.3 1.9-16 5.1V69.9c3.8-2.7 11-4.9 18.3-4.9 14.9 0 23.4 8.1 23.4 21.2V124h-12.5v-3.2c-1.9 1.9-7.7 4.3-14.2 4.3-11.8 0-21.6-7-21.6-18.8 0-10.9 9.7-18.6 22.5-18.6 5.2 0 10.9 1.8 13.2 3.5zm0 16.8c-1.4-3.6-6.5-5.8-11.7-5.8-5.8 0-11.9 2.5-11.9 8.2 0 5.8 6.1 8.3 11.9 8.3 5.2 0 10.3-2.2 11.7-5.8z"/>
+        <path id="path3699" fill="#fff" d="M575.8 123.9h-13V77h-11.7V66.2h11.7V50.8h13v15.5h13V77h-13z"/>
+        <path id="path3701" fill="#fff" d="M598.3 39.5h13v32.2c3.1-3.6 8.8-6.8 15.6-6.8 13.1 0 20.4 8.7 20.4 21.4v37.5h-13V88.6c0-7.1-3.5-11.8-10.9-11.8-5.6 0-10.7 3.5-12.1 9.2v37.9h-13z"/>
+      </g>
+    </g>
+  </g>
+</svg>
\ No newline at end of file