From b442b8f5d668cd2779d16dd8400b92556124ea38 Mon Sep 17 00:00:00 2001
From: Erik Darling <2136037+erikdarlingdata@users.noreply.github.com>
Date: Thu, 19 Mar 2026 21:21:12 -0400
Subject: [PATCH 01/31] Delete .coderabbit.yaml

---
 .coderabbit.yaml | 65 ------------------------------------------------
 1 file changed, 65 deletions(-)
 delete mode 100644 .coderabbit.yaml

diff --git a/.coderabbit.yaml b/.coderabbit.yaml
deleted file mode 100644
index 8eddc00..0000000
--- a/.coderabbit.yaml
+++ /dev/null
@@ -1,65 +0,0 @@
-# yaml-language-server: $schema=https://coderabbit.ai/integrations/schema.v2.json
-
-language: "en-US"
-early_access: false
-enable_free_tier: true
-
-reviews:
-  profile: "chill"
-  high_level_summary: true
-  review_status: true
-  commit_status: true
-  collapse_walkthrough: true
-  sequence_diagrams: false
-  poem: false
-
-  path_filters:
-    - "!**/*.Designer.cs"
-    - "!**/bin/**"
-    - "!**/obj/**"
-    - "!**/publish/**"
-    - "!**/*.user"
-    - "!**/*.suo"
-    - "!**/screenshots/**"
-
-  path_instructions:
-    - path: "src/PlanViewer.App/**/*.cs"
-      instructions: >
-        Avalonia 11.3 desktop app using code-behind pattern (not MVVM).
-        Watch for: null reference risks, proper disposal of resources,
-        async/await patterns, and Avalonia-specific UI threading.
-    - path: "src/PlanViewer.Core/**/*.cs"
-      instructions: >
-        Core library with execution plan analysis (PlanAnalyzer), XML parsing,
-        and shared services. Watch for: XML parsing safety, null handling,
-        and performance with large execution plans.
-    - path: "src/PlanViewer.Mcp/**/*.cs"
-      instructions: >
-        MCP (Model Context Protocol) server integration for AI tools.
-        Watch for: input validation, proper error responses, and serialization safety.
-    - path: "tests/**/*.cs"
-      instructions: >
-        Unit and integration tests. Watch for: test isolation,
-        meaningful assertions, and proper test data setup.
-
-  auto_review:
-    enabled: true
-    drafts: false
-    base_branches:
-      - "dev"
-      - "main"
-
-  tools:
-    gitleaks:
-      enabled: true
-    github-checks:
-      enabled: true
-
-chat:
-  auto_reply: true
-
-knowledge_base:
-  learnings:
-    scope: "local"
-  pull_requests:
-    scope: "local"

From 37cbe0288fda69e888d69e9aa7e54774a798f3d6 Mon Sep 17 00:00:00 2001
From: Erik Darling <2136037+erikdarlingdata@users.noreply.github.com>
Date: Thu, 19 Mar 2026 21:24:37 -0400
Subject: [PATCH 02/31] Shorten update link text to 'click to install'

---
 src/PlanViewer.App/AboutWindow.axaml.cs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/PlanViewer.App/AboutWindow.axaml.cs b/src/PlanViewer.App/AboutWindow.axaml.cs
index c66bdca..d5ce313 100644
--- a/src/PlanViewer.App/AboutWindow.axaml.cs
+++ b/src/PlanViewer.App/AboutWindow.axaml.cs
@@ -97,7 +97,7 @@ private async void CheckUpdate_Click(object? sender, RoutedEventArgs e)
                 if (_velopackUpdate != null)
                 {
                     UpdateStatusText.Text = "Update available:";
-                    UpdateLink.Text = $"v{_velopackUpdate.TargetFullRelease.Version} — click to download and install";
+                    UpdateLink.Text = $"v{_velopackUpdate.TargetFullRelease.Version} — click to install";
                     UpdateLink.IsVisible = true;
                     CheckUpdateButton.IsEnabled = true;
                     return;

From d16a861f1be064927a312281e2188d03269d6c79 Mon Sep 17 00:00:00 2001
From: Erik Darling <2136037+erikdarlingdata@users.noreply.github.com>
Date: Fri, 20 Mar 2026 18:07:02 -0400
Subject: [PATCH 03/31] Fix Query Store time slicer metric label and chart data

- Increase metric label font size from 9 to 12 for readability
- Use ForegroundBrush instead of muted SlicerLabelBrush for metric label
- Fix metric label showing "Total" for avg metrics (e.g., avg-cpu showed
  "Total CPU" instead of "Avg CPU") by splitting combined or-patterns
- Add per-bucket average properties to QueryStoreTimeSlice so the slicer
  chart shape reflects the selected metric (total vs avg) instead of
  always showing totals

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
---
 .../Controls/TimeRangeSlicerControl.axaml.cs  | 40 ++++++++++++-------
 .../Models/QueryStoreTimeSlice.cs             |  7 ++++
 2 files changed, 33 insertions(+), 14 deletions(-)

diff --git a/src/PlanViewer.App/Controls/TimeRangeSlicerControl.axaml.cs b/src/PlanViewer.App/Controls/TimeRangeSlicerControl.axaml.cs
index ca0d453..036aeaf 100644
--- a/src/PlanViewer.App/Controls/TimeRangeSlicerControl.axaml.cs
+++ b/src/PlanViewer.App/Controls/TimeRangeSlicerControl.axaml.cs
@@ -140,12 +140,18 @@ private double[] GetMetricValues()
     {
         return _metric switch
         {
-            "cpu" or "avg-cpu" => _data.Select(d => d.TotalCpu).ToArray(),
-            "duration" or "avg-duration" => _data.Select(d => d.TotalDuration).ToArray(),
-            "reads" or "avg-reads" => _data.Select(d => d.TotalReads).ToArray(),
-            "writes" or "avg-writes" => _data.Select(d => d.TotalWrites).ToArray(),
-            "physical-reads" or "avg-physical-reads" => _data.Select(d => d.TotalPhysicalReads).ToArray(),
-            "memory" or "avg-memory" => _data.Select(d => d.TotalMemory).ToArray(),
+            "cpu" => _data.Select(d => d.TotalCpu).ToArray(),
+            "avg-cpu" => _data.Select(d => d.AvgCpu).ToArray(),
+            "duration" => _data.Select(d => d.TotalDuration).ToArray(),
+            "avg-duration" => _data.Select(d => d.AvgDuration).ToArray(),
+            "reads" => _data.Select(d => d.TotalReads).ToArray(),
+            "avg-reads" => _data.Select(d => d.AvgReads).ToArray(),
+            "writes" => _data.Select(d => d.TotalWrites).ToArray(),
+            "avg-writes" => _data.Select(d => d.AvgWrites).ToArray(),
+            "physical-reads" => _data.Select(d => d.TotalPhysicalReads).ToArray(),
+            "avg-physical-reads" => _data.Select(d => d.AvgPhysicalReads).ToArray(),
+            "memory" => _data.Select(d => d.TotalMemory).ToArray(),
+            "avg-memory" => _data.Select(d => d.AvgMemory).ToArray(),
             "executions" => _data.Select(d => (double)d.TotalExecutions).ToArray(),
             _ => _data.Select(d => d.TotalCpu).ToArray(),
         };
@@ -155,12 +161,18 @@ private string GetMetricLabel()
     {
         return _metric switch
         {
-            "cpu" or "avg-cpu" => "Total CPU (ms)",
-            "duration" or "avg-duration" => "Total Duration (ms)",
-            "reads" or "avg-reads" => "Total Reads",
-            "writes" or "avg-writes" => "Total Writes",
-            "physical-reads" or "avg-physical-reads" => "Total Physical Reads",
-            "memory" or "avg-memory" => "Total Memory (MB)",
+            "cpu" => "Total CPU (ms)",
+            "avg-cpu" => "Avg CPU (ms)",
+            "duration" => "Total Duration (ms)",
+            "avg-duration" => "Avg Duration (ms)",
+            "reads" => "Total Reads",
+            "avg-reads" => "Avg Reads",
+            "writes" => "Total Writes",
+            "avg-writes" => "Avg Writes",
+            "physical-reads" => "Total Physical Reads",
+            "avg-physical-reads" => "Avg Physical Reads",
+            "memory" => "Total Memory (MB)",
+            "avg-memory" => "Avg Memory (MB)",
             "executions" => "Executions",
             _ => "Total CPU (ms)",
         };
@@ -256,8 +268,8 @@ public void Redraw()
         var metricTb = new TextBlock
         {
             Text = GetMetricLabel(),
-            FontSize = 9,
-            Foreground = labelBrush,
+            FontSize = 12,
+            Foreground = TryFindBrush("ForegroundBrush", new SolidColorBrush(Color.Parse("#E4E6EB"))),
         };
         Canvas.SetRight(metricTb, 4);
         Canvas.SetTop(metricTb, 2);
diff --git a/src/PlanViewer.Core/Models/QueryStoreTimeSlice.cs b/src/PlanViewer.Core/Models/QueryStoreTimeSlice.cs
index b27ad4f..ba6c92a 100644
--- a/src/PlanViewer.Core/Models/QueryStoreTimeSlice.cs
+++ b/src/PlanViewer.Core/Models/QueryStoreTimeSlice.cs
@@ -15,4 +15,11 @@ public class QueryStoreTimeSlice
     public double TotalPhysicalReads { get; set; }
     public double TotalMemory { get; set; }
     public long TotalExecutions { get; set; }
+
+    public double AvgCpu => TotalExecutions > 0 ? TotalCpu / TotalExecutions : 0;
+    public double AvgDuration => TotalExecutions > 0 ? TotalDuration / TotalExecutions : 0;
+    public double AvgReads => TotalExecutions > 0 ? TotalReads / TotalExecutions : 0;
+    public double AvgWrites => TotalExecutions > 0 ? TotalWrites / TotalExecutions : 0;
+    public double AvgPhysicalReads => TotalExecutions > 0 ? TotalPhysicalReads / TotalExecutions : 0;
+    public double AvgMemory => TotalExecutions > 0 ? TotalMemory / TotalExecutions : 0;
 }

From 4cca2f718e65c0c37d334d1937a62b67c9cc23ab Mon Sep 17 00:00:00 2001
From: rferraton <16419423+rferraton@users.noreply.github.com>
Date: Sun, 22 Mar 2026 21:33:58 +0100
Subject: [PATCH 04/31] Add Query Store wait stats: global bar/ribbon/table
 charts, per-row wait profile with v/% toggle, resizable separator with
 chevron, ribbon click/double-click interactions

---
 .../Controls/QueryStoreGridControl.axaml      |  45 +++-
 .../Controls/QueryStoreGridControl.axaml.cs   | 231 ++++++++++++++++--
 .../Controls/WaitProfileBarControl.axaml      |   9 +
 .../Controls/WaitProfileBarControl.axaml.cs   | 145 +++++++++++
 .../Controls/WaitStatsProfileControl.axaml    |  48 ++++
 .../Controls/WaitStatsProfileControl.axaml.cs | 132 ++++++++++
 .../Controls/WaitStatsRibbonControl.axaml     |   9 +
 .../Controls/WaitStatsRibbonControl.axaml.cs  | 178 ++++++++++++++
 src/PlanViewer.App/Themes/DarkTheme.axaml     |  27 ++
 src/PlanViewer.Core/Models/WaitStatsModels.cs |  47 ++++
 .../Services/QueryStoreService.cs             | 180 ++++++++++++++
 11 files changed, 1034 insertions(+), 17 deletions(-)
 create mode 100644 src/PlanViewer.App/Controls/WaitProfileBarControl.axaml
 create mode 100644 src/PlanViewer.App/Controls/WaitProfileBarControl.axaml.cs
 create mode 100644 src/PlanViewer.App/Controls/WaitStatsProfileControl.axaml
 create mode 100644 src/PlanViewer.App/Controls/WaitStatsProfileControl.axaml.cs
 create mode 100644 src/PlanViewer.App/Controls/WaitStatsRibbonControl.axaml
 create mode 100644 src/PlanViewer.App/Controls/WaitStatsRibbonControl.axaml.cs
 create mode 100644 src/PlanViewer.Core/Models/WaitStatsModels.cs

diff --git a/src/PlanViewer.App/Controls/QueryStoreGridControl.axaml b/src/PlanViewer.App/Controls/QueryStoreGridControl.axaml
index 697ad74..e3db6b7 100644
--- a/src/PlanViewer.App/Controls/QueryStoreGridControl.axaml
+++ b/src/PlanViewer.App/Controls/QueryStoreGridControl.axaml
@@ -4,8 +4,26 @@
              x:Class="PlanViewer.App.Controls.QueryStoreGridControl"
              Background="{DynamicResource BackgroundBrush}">
     <Grid RowDefinitions="Auto,Auto,*">
-        <!-- Time Range Slicer -->
-        <local:TimeRangeSlicerControl x:Name="TimeRangeSlicer" Grid.Row="0"/>
+        <!-- Time Range Slicer + Wait Stats Profile -->
+        <Grid Grid.Row="0" x:Name="SlicerRow" ColumnDefinitions="2*,Auto,*">
+            <local:TimeRangeSlicerControl x:Name="TimeRangeSlicer" Grid.Column="0"/>
+            <!-- Resizable separator with chevron overlay -->
+            <GridSplitter x:Name="WaitStatsSplitter" Grid.Column="1" Width="14"
+                          Background="{DynamicResource BorderBrush}"
+                          ResizeDirection="Columns"/>
+            <Button x:Name="WaitStatsChevronButton" Grid.Column="1"
+                    Content="»"
+                    Width="14" Height="28" Padding="0"
+                    FontSize="11" FontWeight="Bold"
+                    Background="Transparent" BorderThickness="0"
+                    Foreground="{DynamicResource ForegroundBrush}"
+                    HorizontalAlignment="Center"
+                    VerticalAlignment="Center"
+                    IsHitTestVisible="True"
+                    ToolTip.Tip="Collapse / expand wait stats panel"
+                    Click="WaitStatsChevron_Click"/>
+            <local:WaitStatsProfileControl x:Name="WaitStatsProfile" Grid.Column="2"/>
+        </Grid>
 
         <!-- Toolbar -->
         <Border Grid.Row="1" Background="{DynamicResource BackgroundDarkBrush}" Padding="8,6"
@@ -134,6 +152,29 @@
                 <DataGridTextColumn Header="Query Hash" Binding="{ReflectionBinding QueryHash}" SortMemberPath="QueryHash" Width="150"/>
                 <DataGridTextColumn Header="Plan Hash" Binding="{ReflectionBinding QueryPlanHash}" SortMemberPath="QueryPlanHash" Width="150"/>
                 <DataGridTextColumn Header="Module" Binding="{ReflectionBinding ModuleName}" SortMemberPath="ModuleName" Width="140"/>
+                <DataGridTemplateColumn SortMemberPath="WaitGrandTotalSort" Width="160">
+                    <DataGridTemplateColumn.Header>
+                        <StackPanel Orientation="Horizontal" Spacing="4">
+                            <Button Content="%" Width="20" Height="18" Padding="0"
+                                    FontSize="10" FontWeight="Bold"
+                                    Background="Transparent" BorderThickness="1"
+                                    BorderBrush="{DynamicResource ForegroundMutedBrush}"
+                                    Foreground="{DynamicResource ForegroundBrush}"
+                                    ToolTip.Tip="Toggle value (v) / percent (%) stacked bar"
+                                    Click="WaitModeToggle_Click"/>
+                            <TextBlock Text="Wait Profile" VerticalAlignment="Center"/>
+                        </StackPanel>
+                    </DataGridTemplateColumn.Header>
+                    <DataGridTemplateColumn.CellTemplate>
+                        <DataTemplate x:DataType="local:QueryStoreRow">
+                            <local:WaitProfileBarControl Height="14" Margin="2,1"
+                                                         Profile="{Binding WaitProfile}"
+                                                         HighlightCategory="{Binding WaitHighlightCategory}"
+                                                         PercentMode="{Binding WaitPercentMode}"
+                                                         MaxGrandTotalRatio="{Binding WaitMaxGrandTotal}"/>
+                        </DataTemplate>
+                    </DataGridTemplateColumn.CellTemplate>
+                </DataGridTemplateColumn>
                 <DataGridTextColumn Header="Last Executed (Local)" Binding="{ReflectionBinding LastExecutedLocal}" SortMemberPath="LastExecutedLocal" Width="160"/>
                 <DataGridTemplateColumn Header="Executions" SortMemberPath="ExecsSort" Width="100">
                     <DataGridTemplateColumn.CellTemplate>
diff --git a/src/PlanViewer.App/Controls/QueryStoreGridControl.axaml.cs b/src/PlanViewer.App/Controls/QueryStoreGridControl.axaml.cs
index e6b6b3c..b8f8f7a 100644
--- a/src/PlanViewer.App/Controls/QueryStoreGridControl.axaml.cs
+++ b/src/PlanViewer.App/Controls/QueryStoreGridControl.axaml.cs
@@ -2,6 +2,7 @@
 using System.Collections.Generic;
 using System.Collections.ObjectModel;
 using System.ComponentModel;
+using System.Diagnostics;
 using System.Linq;
 using System.Runtime.CompilerServices;
 using System.Threading;
@@ -39,6 +40,9 @@ public partial class QueryStoreGridControl : UserControl
     private string _lastFetchedOrderBy = "cpu";
     private bool _initialOrderByLoaded;
     private bool _suppressRangeChanged;
+    private string? _waitHighlightCategory;
+    private bool _waitStatsEnabled = true;
+    private bool _waitPercentMode = true;
 
     public event EventHandler<List<QueryStorePlan>>? PlansSelected;
     public event EventHandler<string>? DatabaseChanged;
@@ -61,6 +65,10 @@ public QueryStoreGridControl(ServerConnection serverConnection, ICredentialServi
         TimeRangeSlicer.RangeChanged += OnTimeRangeChanged;
         TimeRangeSlicer.IsExpanded = true;
 
+        WaitStatsProfile.CategoryClicked += OnWaitCategoryClicked;
+        WaitStatsProfile.CategoryDoubleClicked += OnWaitCategoryDoubleClicked;
+        WaitStatsProfile.CollapsedChanged += OnWaitStatsCollapsedChanged;
+
         // Auto-fetch with default settings on connect
         Avalonia.Threading.Dispatcher.UIThread.Post(() =>
         {
@@ -182,6 +190,13 @@ private async System.Threading.Tasks.Task FetchPlansForRangeAsync()
             ApplyFilters();
             LoadButton.IsEnabled = true;
             SelectToggleButton.Content = "Select None";
+
+            // Fetch wait stats in parallel (non-blocking for plan display)
+            Debug.WriteLine($"[WAITSTATS] Gate check: _waitStatsEnabled={_waitStatsEnabled}, start={_slicerStartUtc}, end={_slicerEndUtc}");
+            if (_waitStatsEnabled && _slicerStartUtc.HasValue && _slicerEndUtc.HasValue)
+                _ = FetchWaitStatsAsync(_slicerStartUtc.Value, _slicerEndUtc.Value, ct);
+            else
+                Debug.WriteLine("[WAITSTATS] Skipped FetchWaitStatsAsync (gate failed)");
         }
         catch (OperationCanceledException)
         {
@@ -355,6 +370,153 @@ private async void OnTimeRangeChanged(object? sender, TimeRangeChangedEventArgs
         await FetchPlansForRangeAsync();
     }
 
+    // ── Wait stats ─────────────────────────────────────────────────────────
+
+    private async System.Threading.Tasks.Task FetchWaitStatsAsync(
+        DateTime startUtc, DateTime endUtc, CancellationToken ct)
+    {
+        Debug.WriteLine($"[WAITSTATS] FetchWaitStatsAsync called: {startUtc:O} → {endUtc:O}, _waitStatsEnabled={_waitStatsEnabled}");
+        try
+        {
+            // Global (bar)
+            var globalWaits = await QueryStoreService.FetchGlobalWaitStatsAsync(
+                _connectionString, startUtc, endUtc, ct);
+            Debug.WriteLine($"[WAITSTATS] FetchGlobalWaitStatsAsync returned {globalWaits.Count} rows");
+            foreach (var w in globalWaits)
+                Debug.WriteLine($"[WAITSTATS]   cat={w.WaitCategoryDesc}, ratio={w.WaitRatio}");
+            if (ct.IsCancellationRequested) { Debug.WriteLine("[WAITSTATS] Cancelled after global fetch"); return; }
+            var globalProfile = QueryStoreService.BuildWaitProfile(globalWaits);
+            Debug.WriteLine($"[WAITSTATS] BuildWaitProfile → GrandTotalRatio={globalProfile.GrandTotalRatio}, Segments={globalProfile.Segments.Count}");
+            foreach (var s in globalProfile.Segments)
+                Debug.WriteLine($"[WAITSTATS]   seg: {s.Category} WaitRatio={s.WaitRatio} Ratio={s.Ratio} IsNamed={s.IsNamed}");
+            WaitStatsProfile.SetBarProfile(globalProfile);
+            Debug.WriteLine("[WAITSTATS] SetBarProfile called");
+
+            // Global (ribbon) — fetched lazily, data ready for toggle
+            var ribbonData = await QueryStoreService.FetchGlobalWaitStatsRibbonAsync(
+                _connectionString, startUtc, endUtc, ct);
+            Debug.WriteLine($"[WAITSTATS] FetchGlobalWaitStatsRibbonAsync returned {ribbonData.Count} rows");
+            if (ct.IsCancellationRequested) { Debug.WriteLine("[WAITSTATS] Cancelled after ribbon fetch"); return; }
+            WaitStatsProfile.SetRibbonData(ribbonData);
+
+            // Per-plan
+            var planWaits = await QueryStoreService.FetchPlanWaitStatsAsync(
+                _connectionString, startUtc, endUtc, ct);
+            Debug.WriteLine($"[WAITSTATS] FetchPlanWaitStatsAsync returned {planWaits.Count} rows");
+            if (ct.IsCancellationRequested) { Debug.WriteLine("[WAITSTATS] Cancelled after plan waits fetch"); return; }
+
+            var byPlan = planWaits
+                .GroupBy(x => x.PlanId)
+                .ToDictionary(g => g.Key, g => g.Select(x => x.Wait).ToList());
+
+            foreach (var row in _rows)
+            {
+                if (byPlan.TryGetValue(row.PlanId, out var waits))
+                    row.WaitProfile = QueryStoreService.BuildWaitProfile(waits);
+                else
+                    row.WaitProfile = null;
+            }
+            UpdateWaitBarMode();
+            Debug.WriteLine("[WAITSTATS] FetchWaitStatsAsync completed successfully");
+        }
+        catch (OperationCanceledException) { Debug.WriteLine("[WAITSTATS] FetchWaitStatsAsync CANCELLED"); }
+        catch (Exception ex) { Debug.WriteLine($"[WAITSTATS] FetchWaitStatsAsync EXCEPTION: {ex}"); }
+    }
+
+    private void OnWaitCategoryClicked(object? sender, string category)
+    {
+        // Toggle highlight: click same category again → clear
+        if (_waitHighlightCategory == category)
+            _waitHighlightCategory = null;
+        else
+            _waitHighlightCategory = category;
+
+        ApplyWaitHighlight();
+    }
+
+    private void OnWaitCategoryDoubleClicked(object? sender, string category)
+    {
+        _waitHighlightCategory = category;
+        ApplyWaitHighlight();
+
+        // Sort grid by this category's wait ratio (descending)
+        var sorted = _filteredRows
+            .OrderByDescending(r =>
+                r.WaitProfile?.Segments
+                    .Where(s => s.Category == category)
+                    .Sum(s => s.WaitRatio) ?? 0)
+            .ToList();
+
+        _filteredRows.Clear();
+        foreach (var row in sorted)
+            _filteredRows.Add(row);
+
+        // Clear column sort indicators since we're using custom sort
+        _sortedColumnTag = null;
+        UpdateSortIndicators(null);
+        UpdateBarRatios();
+    }
+
+    private void ApplyWaitHighlight()
+    {
+        WaitStatsProfile.SetHighlight(_waitHighlightCategory);
+        foreach (var row in _rows)
+            row.WaitHighlightCategory = _waitHighlightCategory;
+    }
+
+    private void OnWaitStatsCollapsedChanged(object? sender, bool collapsed)
+    {
+        _waitStatsEnabled = !collapsed;
+        // WaitProfile column is at index 6
+        ResultsGrid.Columns[6].IsVisible = !collapsed;
+
+        if (!collapsed && _slicerStartUtc.HasValue && _slicerEndUtc.HasValue)
+        {
+            // Re-fetch wait stats when expanding
+            var cts = new CancellationTokenSource();
+            _ = FetchWaitStatsAsync(_slicerStartUtc.Value, _slicerEndUtc.Value, cts.Token);
+        }
+    }
+
+    private void WaitStatsChevron_Click(object? sender, RoutedEventArgs e)
+    {
+        if (WaitStatsProfile.IsCollapsed)
+        {
+            WaitStatsProfile.Expand();
+            WaitStatsChevronButton.Content = "»";
+            SlicerRow.ColumnDefinitions[0].Width = new GridLength(2, GridUnitType.Star);
+            SlicerRow.ColumnDefinitions[2].Width = new GridLength(1, GridUnitType.Star);
+        }
+        else
+        {
+            WaitStatsProfile.Collapse();
+            WaitStatsChevronButton.Content = "«";
+            SlicerRow.ColumnDefinitions[0].Width = new GridLength(1, GridUnitType.Star);
+            SlicerRow.ColumnDefinitions[2].Width = new GridLength(0);
+        }
+    }
+
+    private void WaitModeToggle_Click(object? sender, RoutedEventArgs e)
+    {
+        _waitPercentMode = !_waitPercentMode;
+        if (sender is Button btn)
+            btn.Content = _waitPercentMode ? "%" : "v";
+        UpdateWaitBarMode();
+    }
+
+    private void UpdateWaitBarMode()
+    {
+        var maxGrand = _filteredRows.Count > 0
+            ? _filteredRows.Max(r => r.WaitProfile?.GrandTotalRatio ?? 0)
+            : 1.0;
+        if (maxGrand <= 0) maxGrand = 1.0;
+        foreach (var row in _filteredRows)
+        {
+            row.WaitPercentMode = _waitPercentMode;
+            row.WaitMaxGrandTotal = maxGrand;
+        }
+    }
+
     private void SelectToggle_Click(object? sender, RoutedEventArgs e)
     {
         var allSelected = _filteredRows.Count > 0 && _filteredRows.All(r => r.IsSelected);
@@ -488,21 +650,22 @@ private void SetupColumnHeaders()
         SetColumnFilterButton(cols[3],  "QueryHash",      "Query Hash");
         SetColumnFilterButton(cols[4],  "PlanHash",       "Plan Hash");
         SetColumnFilterButton(cols[5],  "ModuleName",     "Module");
-        SetColumnFilterButton(cols[6],  "LastExecuted",   "Last Executed (Local)");
-        SetColumnFilterButton(cols[7],  "Executions",     "Executions");
-        SetColumnFilterButton(cols[8],  "TotalCpu",       "Total CPU (ms)");
-        SetColumnFilterButton(cols[9],  "AvgCpu",         "Avg CPU (ms)");
-        SetColumnFilterButton(cols[10], "TotalDuration",  "Total Duration (ms)");
-        SetColumnFilterButton(cols[11], "AvgDuration",    "Avg Duration (ms)");
-        SetColumnFilterButton(cols[12], "TotalReads",     "Total Reads");
-        SetColumnFilterButton(cols[13], "AvgReads",       "Avg Reads");
-        SetColumnFilterButton(cols[14], "TotalWrites",    "Total Writes");
-        SetColumnFilterButton(cols[15], "AvgWrites",      "Avg Writes");
-        SetColumnFilterButton(cols[16], "TotalPhysReads", "Total Physical Reads");
-        SetColumnFilterButton(cols[17], "AvgPhysReads",   "Avg Physical Reads");
-        SetColumnFilterButton(cols[18], "TotalMemory",    "Total Memory (MB)");
-        SetColumnFilterButton(cols[19], "AvgMemory",      "Avg Memory (MB)");
-        SetColumnFilterButton(cols[20], "QueryText",      "Query Text");
+        // cols[6] = WaitProfile (no filter button)
+        SetColumnFilterButton(cols[7],  "LastExecuted",   "Last Executed (Local)");
+        SetColumnFilterButton(cols[8],  "Executions",     "Executions");
+        SetColumnFilterButton(cols[9],  "TotalCpu",       "Total CPU (ms)");
+        SetColumnFilterButton(cols[10], "AvgCpu",         "Avg CPU (ms)");
+        SetColumnFilterButton(cols[11], "TotalDuration",  "Total Duration (ms)");
+        SetColumnFilterButton(cols[12], "AvgDuration",    "Avg Duration (ms)");
+        SetColumnFilterButton(cols[13], "TotalReads",     "Total Reads");
+        SetColumnFilterButton(cols[14], "AvgReads",       "Avg Reads");
+        SetColumnFilterButton(cols[15], "TotalWrites",    "Total Writes");
+        SetColumnFilterButton(cols[16], "AvgWrites",      "Avg Writes");
+        SetColumnFilterButton(cols[17], "TotalPhysReads", "Total Physical Reads");
+        SetColumnFilterButton(cols[18], "AvgPhysReads",   "Avg Physical Reads");
+        SetColumnFilterButton(cols[19], "TotalMemory",    "Total Memory (MB)");
+        SetColumnFilterButton(cols[20], "AvgMemory",      "Avg Memory (MB)");
+        SetColumnFilterButton(cols[21], "QueryText",      "Query Text");
     }
 
     private void SetColumnFilterButton(DataGridColumn col, string columnId, string label)
@@ -803,6 +966,8 @@ private void UpdateBarRatios()
                 row.SetBar(columnId, ratio, isSorted);
             }
         }
+
+        UpdateWaitBarMode();
     }
 
     private static IComparable GetSortKey(string columnTag, QueryStoreRow r) =>
@@ -829,6 +994,7 @@ private static IComparable GetSortKey(string columnTag, QueryStoreRow r) =>
             "AvgPhysReadsSort"   => r.AvgPhysReadsSort,
             "TotalMemSort"       => r.TotalMemSort,
             "AvgMemSort"         => r.AvgMemSort,
+            "WaitGrandTotalSort" => r.WaitGrandTotalSort,
             _                    => r.LastExecutedLocal,
         };
 }
@@ -867,6 +1033,10 @@ public class QueryStoreRow : INotifyPropertyChanged
     private bool _isSorted_TotalMemory;
     private bool _isSorted_AvgMemory;
 
+    // Wait stats
+    private WaitProfile? _waitProfile;
+    private string? _waitHighlightCategory;
+
     public QueryStoreRow(QueryStorePlan plan)
     {
         Plan = plan;
@@ -931,6 +1101,37 @@ public void SetBar(string columnId, double ratio, bool isSorted)
         }
     }
 
+    // ── Wait profile ───────────────────────────────────────────────────────
+
+    public WaitProfile? WaitProfile
+    {
+        get => _waitProfile;
+        set { _waitProfile = value; OnPropertyChanged(); }
+    }
+
+    public string? WaitHighlightCategory
+    {
+        get => _waitHighlightCategory;
+        set { _waitHighlightCategory = value; OnPropertyChanged(); }
+    }
+
+    private bool _waitPercentMode = true;
+    private double _waitMaxGrandTotal = 1.0;
+
+    public bool WaitPercentMode
+    {
+        get => _waitPercentMode;
+        set { _waitPercentMode = value; OnPropertyChanged(); }
+    }
+
+    public double WaitMaxGrandTotal
+    {
+        get => _waitMaxGrandTotal;
+        set { _waitMaxGrandTotal = value; OnPropertyChanged(); }
+    }
+
+    public double WaitGrandTotalSort => _waitProfile?.GrandTotalRatio ?? 0;
+
     public long QueryId => Plan.QueryId;
     public long PlanId => Plan.PlanId;
     public string QueryHash => Plan.QueryHash;
diff --git a/src/PlanViewer.App/Controls/WaitProfileBarControl.axaml b/src/PlanViewer.App/Controls/WaitProfileBarControl.axaml
new file mode 100644
index 0000000..06721cb
--- /dev/null
+++ b/src/PlanViewer.App/Controls/WaitProfileBarControl.axaml
@@ -0,0 +1,9 @@
+<UserControl xmlns="https://github.com/avaloniaui"
+             xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
+             x:Class="PlanViewer.App.Controls.WaitProfileBarControl">
+    <Border x:Name="BarBorder" CornerRadius="2" ClipToBounds="True"
+            Background="{DynamicResource BackgroundLightBrush}"
+            MinHeight="14">
+        <Canvas x:Name="BarCanvas"/>
+    </Border>
+</UserControl>
diff --git a/src/PlanViewer.App/Controls/WaitProfileBarControl.axaml.cs b/src/PlanViewer.App/Controls/WaitProfileBarControl.axaml.cs
new file mode 100644
index 0000000..61cfb81
--- /dev/null
+++ b/src/PlanViewer.App/Controls/WaitProfileBarControl.axaml.cs
@@ -0,0 +1,145 @@
+using System;
+using Avalonia;
+using Avalonia.Controls;
+using Avalonia.Controls.Shapes;
+using Avalonia.Media;
+using PlanViewer.Core.Models;
+
+namespace PlanViewer.App.Controls;
+
+public partial class WaitProfileBarControl : UserControl
+{
+    public static readonly StyledProperty<WaitProfile?> ProfileProperty =
+        AvaloniaProperty.Register<WaitProfileBarControl, WaitProfile?>(nameof(Profile));
+
+    public static readonly StyledProperty<string?> HighlightCategoryProperty =
+        AvaloniaProperty.Register<WaitProfileBarControl, string?>(nameof(HighlightCategory));
+
+    public static readonly StyledProperty<bool> PercentModeProperty =
+        AvaloniaProperty.Register<WaitProfileBarControl, bool>(nameof(PercentMode));
+
+    public static readonly StyledProperty<double> MaxGrandTotalRatioProperty =
+        AvaloniaProperty.Register<WaitProfileBarControl, double>(nameof(MaxGrandTotalRatio), 1.0);
+
+    public WaitProfile? Profile
+    {
+        get => GetValue(ProfileProperty);
+        set => SetValue(ProfileProperty, value);
+    }
+
+    public string? HighlightCategory
+    {
+        get => GetValue(HighlightCategoryProperty);
+        set => SetValue(HighlightCategoryProperty, value);
+    }
+
+    public bool PercentMode
+    {
+        get => GetValue(PercentModeProperty);
+        set => SetValue(PercentModeProperty, value);
+    }
+
+    public double MaxGrandTotalRatio
+    {
+        get => GetValue(MaxGrandTotalRatioProperty);
+        set => SetValue(MaxGrandTotalRatioProperty, value);
+    }
+
+    public event EventHandler<string>? CategoryClicked;
+    public event EventHandler<string>? CategoryDoubleClicked;
+
+    public WaitProfileBarControl()
+    {
+        InitializeComponent();
+        BarBorder.SizeChanged += (_, _) => Redraw();
+    }
+
+    public void SetProfile(WaitProfile? profile) => Profile = profile;
+    public void SetHighlight(string? category) => HighlightCategory = category;
+
+    protected override void OnPropertyChanged(AvaloniaPropertyChangedEventArgs change)
+    {
+        base.OnPropertyChanged(change);
+        if (change.Property == ProfileProperty || change.Property == HighlightCategoryProperty
+            || change.Property == PercentModeProperty || change.Property == MaxGrandTotalRatioProperty)
+            Redraw();
+    }
+
+    private void Redraw()
+    {
+        BarCanvas.Children.Clear();
+        var profile = Profile;
+        if (profile == null || profile.GrandTotalRatio <= 0) return;
+
+        var w = BarBorder.Bounds.Width;
+        var h = BarBorder.Bounds.Height;
+        if (w <= 0 || h <= 0) return;
+
+        // In percent mode the bar fills 100% width (segments by Ratio).
+        // In value mode the bar is scaled so the row with the highest
+        // GrandTotalRatio fills 100% and others are proportionally shorter.
+        var barScale = PercentMode || MaxGrandTotalRatio <= 0
+            ? 1.0
+            : profile.GrandTotalRatio / MaxGrandTotalRatio;
+        var barW = w * Math.Min(barScale, 1.0);
+
+        var highlight = HighlightCategory;
+        double x = 0;
+        foreach (var seg in profile.Segments)
+        {
+            var segW = seg.Ratio * barW;
+            if (segW < 0.5) continue;
+
+            var brush = ResolveBrush(seg.Category, seg.IsNamed);
+            var rect = new Rectangle
+            {
+                Width = segW,
+                Height = h,
+                Fill = brush,
+            };
+
+            if (highlight != null && seg.Category == highlight)
+            {
+                rect.Opacity = 1.0;
+                rect.StrokeThickness = 1;
+                rect.Stroke = TryFindBrush("WaitCategory.Highlight", Brushes.White);
+            }
+            else if (highlight != null)
+            {
+                rect.Opacity = 0.3;
+            }
+
+            Canvas.SetLeft(rect, x);
+            Canvas.SetTop(rect, 0);
+            BarCanvas.Children.Add(rect);
+
+            ToolTip.SetTip(rect, $"{seg.Category}: {seg.WaitRatio:P2} ({seg.Ratio:P1} of total)");
+
+            var capturedCategory = seg.Category;
+            rect.PointerPressed += (_, e) =>
+            {
+                if (e.ClickCount == 2)
+                    CategoryDoubleClicked?.Invoke(this, capturedCategory);
+                else
+                    CategoryClicked?.Invoke(this, capturedCategory);
+                e.Handled = true;
+            };
+
+            x += segW;
+        }
+    }
+
+    private IBrush ResolveBrush(string category, bool isNamed)
+    {
+        if (!isNamed)
+            return TryFindBrush("WaitCategory.Others", new SolidColorBrush(Color.Parse("#555D66")));
+        return TryFindBrush($"WaitCategory.{category}", new SolidColorBrush(Color.Parse("#555D66")));
+    }
+
+    private IBrush TryFindBrush(string key, IBrush fallback)
+    {
+        if (this.TryFindResource(key, this.ActualThemeVariant, out var resource) && resource is IBrush brush)
+            return brush;
+        return fallback;
+    }
+}
diff --git a/src/PlanViewer.App/Controls/WaitStatsProfileControl.axaml b/src/PlanViewer.App/Controls/WaitStatsProfileControl.axaml
new file mode 100644
index 0000000..0ff8f94
--- /dev/null
+++ b/src/PlanViewer.App/Controls/WaitStatsProfileControl.axaml
@@ -0,0 +1,48 @@
+<UserControl xmlns="https://github.com/avaloniaui"
+             xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
+             xmlns:local="using:PlanViewer.App.Controls"
+             x:Class="PlanViewer.App.Controls.WaitStatsProfileControl">
+    <Grid RowDefinitions="Auto,*">
+        <!-- Header: toggle chart type -->
+        <StackPanel Grid.Row="0" Orientation="Horizontal" Spacing="6" Margin="4,2">
+            <Button x:Name="ToggleChartButton" Content="☰"
+                    Width="22" Height="22" Padding="0"
+                    FontSize="12" Background="Transparent" BorderThickness="0"
+                    Foreground="{DynamicResource ForegroundBrush}"
+                    ToolTip.Tip="Toggle bar / ribbon chart"
+                    Click="ToggleChart_Click"/>
+            <TextBlock x:Name="TitleText" Text="Wait Stats"
+                       FontSize="11" FontWeight="SemiBold"
+                       Foreground="{DynamicResource SlicerToggleBrush}"
+                       VerticalAlignment="Center"/>
+            <Button x:Name="TableViewButton" Content="▦"
+                    Width="22" Height="22" Padding="0"
+                    FontSize="12" Background="Transparent" BorderThickness="0"
+                    Foreground="{DynamicResource ForegroundBrush}"
+                    ToolTip.Tip="Show wait stats as table"
+                    Click="TableView_Click"/>
+        </StackPanel>
+        <!-- Content area -->
+        <Grid Grid.Row="1" x:Name="ContentArea" MinHeight="24">
+            <local:WaitProfileBarControl x:Name="GlobalBar" PercentMode="True"/>
+            <local:WaitStatsRibbonControl x:Name="GlobalRibbon" IsVisible="False"/>
+            <DataGrid x:Name="TableGrid" IsVisible="False"
+                      AutoGenerateColumns="False"
+                      CanUserSortColumns="True"
+                      CanUserResizeColumns="True"
+                      IsReadOnly="True"
+                      SelectionMode="Single"
+                      GridLinesVisibility="Horizontal"
+                      HeadersVisibility="Column"
+                      FontSize="11"
+                      Background="{DynamicResource BackgroundDarkBrush}"
+                      BorderThickness="0">
+                <DataGrid.Columns>
+                    <DataGridTextColumn Header="Category" Binding="{ReflectionBinding Category}" Width="*"/>
+                    <DataGridTextColumn Header="Wait Ratio" Binding="{ReflectionBinding WaitRatioText}" Width="Auto"/>
+                    <DataGridTextColumn Header="% of Total" Binding="{ReflectionBinding RatioText}" Width="Auto"/>
+                </DataGrid.Columns>
+            </DataGrid>
+        </Grid>
+    </Grid>
+</UserControl>
diff --git a/src/PlanViewer.App/Controls/WaitStatsProfileControl.axaml.cs b/src/PlanViewer.App/Controls/WaitStatsProfileControl.axaml.cs
new file mode 100644
index 0000000..b36dbee
--- /dev/null
+++ b/src/PlanViewer.App/Controls/WaitStatsProfileControl.axaml.cs
@@ -0,0 +1,132 @@
+using System;
+using System.Collections.Generic;
+using System.Collections.ObjectModel;
+using System.Diagnostics;
+using System.Linq;
+using Avalonia.Controls;
+using Avalonia.Interactivity;
+using PlanViewer.Core.Models;
+
+namespace PlanViewer.App.Controls;
+
+public partial class WaitStatsProfileControl : UserControl
+{
+    private enum ViewMode { Bar, Ribbon, Table }
+
+    private ViewMode _viewMode = ViewMode.Bar;
+    private bool _isCollapsed;
+    private WaitProfile? _currentProfile;
+    private readonly ObservableCollection<WaitTableRow> _tableRows = new();
+
+    public event EventHandler<string>? CategoryClicked;
+    public event EventHandler<string>? CategoryDoubleClicked;
+    public event EventHandler<bool>? CollapsedChanged;
+
+    public bool IsCollapsed => _isCollapsed;
+
+    public WaitStatsProfileControl()
+    {
+        InitializeComponent();
+        TableGrid.ItemsSource = _tableRows;
+        GlobalBar.CategoryClicked += (_, cat) => CategoryClicked?.Invoke(this, cat);
+        GlobalBar.CategoryDoubleClicked += (_, cat) => CategoryDoubleClicked?.Invoke(this, cat);
+        GlobalRibbon.CategoryClicked += (_, cat) => CategoryClicked?.Invoke(this, cat);
+        GlobalRibbon.CategoryDoubleClicked += (_, cat) => CategoryDoubleClicked?.Invoke(this, cat);
+    }
+
+    public void SetBarProfile(WaitProfile? profile)
+    {
+        _currentProfile = profile;
+        GlobalBar.SetProfile(profile);
+        RefreshTableRows();
+    }
+
+    public void SetRibbonData(List<WaitCategoryTimeSlice> data)
+    {
+        GlobalRibbon.SetData(data);
+    }
+
+    public void SetHighlight(string? category)
+    {
+        GlobalBar.SetHighlight(category);
+        GlobalRibbon.SetHighlight(category);
+    }
+
+    public void Expand()
+    {
+        if (!_isCollapsed) return;
+        _isCollapsed = false;
+        ContentArea.IsVisible = true;
+        TitleText.IsVisible = true;
+        ToggleChartButton.IsVisible = true;
+        TableViewButton.IsVisible = true;
+        CollapsedChanged?.Invoke(this, false);
+    }
+
+    public void Collapse()
+    {
+        if (_isCollapsed) return;
+        _isCollapsed = true;
+        ContentArea.IsVisible = false;
+        TitleText.IsVisible = false;
+        ToggleChartButton.IsVisible = false;
+        TableViewButton.IsVisible = false;
+        CollapsedChanged?.Invoke(this, true);
+    }
+
+    private void ToggleChart_Click(object? sender, RoutedEventArgs e)
+    {
+        // Cycle: Bar -> Ribbon -> Bar (skip table; table has its own button)
+        if (_viewMode == ViewMode.Table)
+        {
+            // If in table mode, toggle goes back to bar
+            _viewMode = ViewMode.Bar;
+        }
+        else
+        {
+            _viewMode = _viewMode == ViewMode.Bar ? ViewMode.Ribbon : ViewMode.Bar;
+        }
+        ApplyViewMode();
+    }
+
+    private void TableView_Click(object? sender, RoutedEventArgs e)
+    {
+        _viewMode = _viewMode == ViewMode.Table ? ViewMode.Bar : ViewMode.Table;
+        ApplyViewMode();
+    }
+
+    private void ApplyViewMode()
+    {
+        GlobalBar.IsVisible = _viewMode == ViewMode.Bar;
+        GlobalRibbon.IsVisible = _viewMode == ViewMode.Ribbon;
+        TableGrid.IsVisible = _viewMode == ViewMode.Table;
+        ToggleChartButton.Content = _viewMode == ViewMode.Ribbon ? "▤" : "☰";
+
+        // The ContentArea lives inside an Auto-sized parent row, so a *-row
+        // DataGrid would collapse to zero height.  Give an explicit height
+        // when in table mode; reset to NaN (auto) for chart modes.
+        ContentArea.Height = _viewMode == ViewMode.Table ? 120 : double.NaN;
+    }
+
+    private void RefreshTableRows()
+    {
+        _tableRows.Clear();
+        if (_currentProfile == null) { return; }
+        foreach (var seg in _currentProfile.Segments.OrderByDescending(s => s.Ratio))
+        {
+            _tableRows.Add(new WaitTableRow
+            {
+                Category = seg.Category,
+                WaitRatioText = seg.WaitRatio.ToString("P2"),
+                RatioText = seg.Ratio.ToString("P1")
+            });
+        }
+    }
+}
+
+public class WaitTableRow
+{
+    public string Category { get; set; } = "";
+    public string WaitRatioText { get; set; } = "";
+    public string RatioText { get; set; } = ""; 
+}
diff --git a/src/PlanViewer.App/Controls/WaitStatsRibbonControl.axaml b/src/PlanViewer.App/Controls/WaitStatsRibbonControl.axaml
new file mode 100644
index 0000000..0683ea9
--- /dev/null
+++ b/src/PlanViewer.App/Controls/WaitStatsRibbonControl.axaml
@@ -0,0 +1,9 @@
+<UserControl xmlns="https://github.com/avaloniaui"
+             xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
+             x:Class="PlanViewer.App.Controls.WaitStatsRibbonControl">
+    <Border x:Name="RibbonBorder" Background="{DynamicResource BackgroundLightBrush}"
+            CornerRadius="4" ClipToBounds="True"
+            MinHeight="24">
+        <Canvas x:Name="RibbonCanvas" Background="Transparent"/>
+    </Border>
+</UserControl>
diff --git a/src/PlanViewer.App/Controls/WaitStatsRibbonControl.axaml.cs b/src/PlanViewer.App/Controls/WaitStatsRibbonControl.axaml.cs
new file mode 100644
index 0000000..94795af
--- /dev/null
+++ b/src/PlanViewer.App/Controls/WaitStatsRibbonControl.axaml.cs
@@ -0,0 +1,178 @@
+using System;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using Avalonia;
+using Avalonia.Controls;
+using Avalonia.Controls.Shapes;
+using Avalonia.Media;
+using PlanViewer.Core.Models;
+using PlanViewer.Core.Services;
+
+namespace PlanViewer.App.Controls;
+
+/// <summary>
+/// Stacked ribbon chart showing wait stats over time (X = hours, Y = stacked ms).
+/// Top 3 categories get distinct colors; the rest go into "Others".
+/// </summary>
+public partial class WaitStatsRibbonControl : UserControl
+{
+    private List<WaitCategoryTimeSlice> _data = new();
+    private string? _highlightCategory;
+
+    public event EventHandler<string>? CategoryClicked;
+    public event EventHandler<string>? CategoryDoubleClicked;
+
+    private const double PaddingTop = 4;
+    private const double PaddingBottom = 16;
+
+    public WaitStatsRibbonControl()
+    {
+        InitializeComponent();
+        RibbonBorder.SizeChanged += (_, _) => Redraw();
+    }
+
+    public void SetData(List<WaitCategoryTimeSlice> data)
+    {
+        _data = data;
+        Redraw();
+    }
+
+    public void SetHighlight(string? category)
+    {
+        _highlightCategory = category;
+        Redraw();
+    }
+
+    private void Redraw()
+    {
+        RibbonCanvas.Children.Clear();
+        if (_data.Count == 0) return;
+
+        var w = RibbonBorder.Bounds.Width;
+        var h = RibbonBorder.Bounds.Height;
+        if (w <= 0 || h <= 0) return;
+
+        var chartH = h - PaddingTop - PaddingBottom;
+        if (chartH <= 0) return;
+
+        // Determine top-3 categories globally
+        var globalTotals = _data
+            .GroupBy(d => d.WaitCategoryDesc)
+            .Select(g => (Cat: g.Key, Total: g.Sum(x => x.WaitRatio)))
+            .OrderByDescending(x => x.Total)
+            .ToList();
+
+        var top3 = new HashSet<string>(globalTotals.Take(3).Select(x => x.Cat));
+
+        // Group by hour
+        var buckets = _data
+            .GroupBy(d => d.IntervalStartUtc)
+            .OrderBy(g => g.Key)
+            .ToList();
+
+        if (buckets.Count == 0) return;
+
+        var n = buckets.Count;
+        var barGap = Math.Min(2.0, Math.Max(0.5, w / n * 0.1));
+        var stepX = w / n;
+
+        // Compute max total per bucket for Y scaling
+        var maxTotal = buckets.Max(b => b.Sum(x => x.WaitRatio));
+        if (maxTotal <= 0) maxTotal = 1;
+
+        // Build ordered category list: top3 first, then "Others"
+        var orderedCats = globalTotals
+            .Where(x => top3.Contains(x.Cat))
+            .Select(x => x.Cat)
+            .ToList();
+        orderedCats.Add("Others");
+
+        for (int i = 0; i < n; i++)
+        {
+            var bucket = buckets[i];
+            var x = i * stepX;
+            double y = PaddingTop + chartH; // bottom
+
+            // Aggregate into top3 + Others per bucket
+            var catValues = new Dictionary<string, double>();
+            foreach (var cat in orderedCats)
+                catValues[cat] = 0;
+
+            foreach (var s in bucket)
+            {
+                if (top3.Contains(s.WaitCategoryDesc))
+                    catValues[s.WaitCategoryDesc] += s.WaitRatio;
+                else
+                    catValues["Others"] += s.WaitRatio;
+            }
+
+            // Draw stacked from bottom
+            foreach (var cat in orderedCats)
+            {
+                var ratio = catValues[cat];
+                if (ratio <= 0) continue;
+
+                var segH = (ratio / maxTotal) * chartH;
+                y -= segH;
+
+                var brush = ResolveBrush(cat, cat != "Others");
+                var opacity = (_highlightCategory != null && cat != _highlightCategory) ? 0.25 : 1.0;
+
+                var rect = new Rectangle
+                {
+                    Width = Math.Max(1, stepX - barGap),
+                    Height = Math.Max(0.5, segH),
+                    Fill = brush,
+                    Opacity = opacity,
+                };
+                Canvas.SetLeft(rect, x);
+                Canvas.SetTop(rect, y);
+                RibbonCanvas.Children.Add(rect);
+
+                ToolTip.SetTip(rect, $"{cat}: {ratio:P2}");
+
+                var capturedCat = cat;
+                rect.PointerPressed += (_, pe) =>
+                {
+                    if (pe.ClickCount == 2)
+                        CategoryDoubleClicked?.Invoke(this, capturedCat);
+                    else
+                        CategoryClicked?.Invoke(this, capturedCat);
+                    pe.Handled = true;
+                };
+            }
+        }
+
+        // X-axis labels
+        var labelBrush = TryFindBrush("SlicerLabelBrush", new SolidColorBrush(Color.Parse("#99E4E6EB")));
+        int labelInterval = Math.Max(1, n / 6);
+        for (int i = 0; i < n; i += labelInterval)
+        {
+            var dt = buckets[i].Key;
+            var tb = new TextBlock
+            {
+                Text = TimeDisplayHelper.FormatForDisplay(dt, "MM/dd HH:mm"),
+                FontSize = 8,
+                Foreground = labelBrush,
+            };
+            Canvas.SetLeft(tb, i * stepX);
+            Canvas.SetTop(tb, h - PaddingBottom + 1);
+            RibbonCanvas.Children.Add(tb);
+        }
+    }
+
+    private IBrush ResolveBrush(string category, bool isNamed)
+    {
+        if (!isNamed)
+            return TryFindBrush("WaitCategory.Others", new SolidColorBrush(Color.Parse("#555D66")));
+        return TryFindBrush($"WaitCategory.{category}", new SolidColorBrush(Color.Parse("#555D66")));
+    }
+
+    private IBrush TryFindBrush(string key, IBrush fallback)
+    {
+        if (this.TryFindResource(key, this.ActualThemeVariant, out var resource) && resource is IBrush brush)
+            return brush;
+        return fallback;
+    }
+}
diff --git a/src/PlanViewer.App/Themes/DarkTheme.axaml b/src/PlanViewer.App/Themes/DarkTheme.axaml
index 45b56d9..559f68f 100644
--- a/src/PlanViewer.App/Themes/DarkTheme.axaml
+++ b/src/PlanViewer.App/Themes/DarkTheme.axaml
@@ -64,4 +64,31 @@
     <SolidColorBrush x:Key="SlicerLabelBrush" Color="#99E4E6EB"/>
     <SolidColorBrush x:Key="SlicerToggleBrush" Color="#E4E6EB"/>
 
+    <!-- Wait Stats category colors (fixed per category) -->
+    <SolidColorBrush x:Key="WaitCategory.Unknown"            Color="#8E8E93"/>
+    <SolidColorBrush x:Key="WaitCategory.CPU"                Color="#00bd23"/>
+    <SolidColorBrush x:Key="WaitCategory.Worker Thread"      Color="#19ff25"/>
+    <SolidColorBrush x:Key="WaitCategory.Lock"               Color="#EE5A24"/>
+    <SolidColorBrush x:Key="WaitCategory.Latch"              Color="#F368E0"/>
+    <SolidColorBrush x:Key="WaitCategory.Buffer Latch"       Color="#f5069e"/>
+    <SolidColorBrush x:Key="WaitCategory.Buffer IO"          Color="#2d13f2"/>
+    <SolidColorBrush x:Key="WaitCategory.Compilation"        Color="#A29BFE"/>
+    <SolidColorBrush x:Key="WaitCategory.SQL CLR"            Color="#b8dcdc"/>
+    <SolidColorBrush x:Key="WaitCategory.Mirroring"          Color="#54625f"/>
+    <SolidColorBrush x:Key="WaitCategory.Transaction"        Color="#c77416"/>
+    <SolidColorBrush x:Key="WaitCategory.Preemptive"         Color="#FD79A8"/>
+    <SolidColorBrush x:Key="WaitCategory.Service Broker"     Color="#E17055"/>
+    <SolidColorBrush x:Key="WaitCategory.Tran Log IO"        Color="#0984E3"/>
+    <SolidColorBrush x:Key="WaitCategory.Network IO"         Color="#75bbf8"/>
+    <SolidColorBrush x:Key="WaitCategory.Parallelism"        Color="#fd01d3"/>
+    <SolidColorBrush x:Key="WaitCategory.Memory"             Color="#FDCB6E"/>
+    <SolidColorBrush x:Key="WaitCategory.Tracing"            Color="#B2BEC3"/>
+    <SolidColorBrush x:Key="WaitCategory.Full Text Search"   Color="#DFE6E9"/>
+    <SolidColorBrush x:Key="WaitCategory.Other Disk IO"      Color="#636E72"/>
+    <SolidColorBrush x:Key="WaitCategory.Replication"        Color="#81ECEC"/>
+    <SolidColorBrush x:Key="WaitCategory.Log Rate Governor"  Color="#FAB1A0"/>
+    <SolidColorBrush x:Key="WaitCategory.Others"             Color="#555D66"/>
+    <SolidColorBrush x:Key="WaitCategory.Highlight"          Color="#FFFFFF"/>
+
 </ResourceDictionary>
+ 
\ No newline at end of file
diff --git a/src/PlanViewer.Core/Models/WaitStatsModels.cs b/src/PlanViewer.Core/Models/WaitStatsModels.cs
new file mode 100644
index 0000000..64b3282
--- /dev/null
+++ b/src/PlanViewer.Core/Models/WaitStatsModels.cs
@@ -0,0 +1,47 @@
+using System;
+using System.Collections.Generic;
+
+namespace PlanViewer.Core.Models;
+
+/// <summary>
+/// A single wait category aggregated over a time range.
+/// WaitRatio = SUM(total_query_wait_time_ms) / interval_ms.
+/// </summary>
+public class WaitCategoryTotal
+{
+    public int WaitCategory { get; set; }
+    public string WaitCategoryDesc { get; set; } = "";
+    public double WaitRatio { get; set; }
+}
+
+/// <summary>
+/// One hourly bucket of wait stats for the ribbon chart.
+/// WaitRatio = SUM(total_query_wait_time_ms) / 3_600_000.
+/// </summary>
+public class WaitCategoryTimeSlice
+{
+    public DateTime IntervalStartUtc { get; set; }
+    public int WaitCategory { get; set; }
+    public string WaitCategoryDesc { get; set; } = "";
+    public double WaitRatio { get; set; }
+}
+
+/// <summary>
+/// Processed wait profile ready for display.
+/// Top 3 categories are named; the rest are consolidated into "Others".
+/// </summary>
+public class WaitProfile
+{
+    public List<WaitProfileSegment> Segments { get; set; } = new();
+    public double GrandTotalRatio { get; set; }
+}
+
+public class WaitProfileSegment
+{
+    public string Category { get; set; } = "";
+    public double WaitRatio { get; set; }
+    /// <summary>Fraction of the grand total [0..1].</summary>
+    public double Ratio { get; set; }
+    /// <summary>True for one of the top-3 named categories, false for "Others".</summary>
+    public bool IsNamed { get; set; }
+}
diff --git a/src/PlanViewer.Core/Services/QueryStoreService.cs b/src/PlanViewer.Core/Services/QueryStoreService.cs
index 1f59c07..dd8d468 100644
--- a/src/PlanViewer.Core/Services/QueryStoreService.cs
+++ b/src/PlanViewer.Core/Services/QueryStoreService.cs
@@ -424,4 +424,184 @@ GROUP BY DATEADD(HOUR, DATEDIFF(HOUR, 0, rsi.start_time), 0)
         rows.Reverse();
         return rows;
     }
+
+    // ── Wait stats ─────────────────────────────────────────────────────────
+
+    // Excluded: 11 = Idle, 18 = User Wait
+    private const string WaitCategoryExclusion = "AND ws.wait_category NOT IN (11, 18)";
+
+    /// <summary>
+    /// Global wait stats aggregated across all plans for a time range, grouped by category.
+    /// WaitRatio = SUM(total_query_wait_time_ms) / interval_duration_ms.
+    /// </summary>
+    public static async Task<List<WaitCategoryTotal>> FetchGlobalWaitStatsAsync(
+        string connectionString, DateTime startUtc, DateTime endUtc,
+        CancellationToken ct = default)
+    {
+        const string sql = @"
+SET TRANSACTION ISOLATION LEVEL READ UNCOMMITTED;
+SELECT
+    ws.wait_category,
+    ws.wait_category_desc,
+    1.0 * SUM(ws.total_query_wait_time_ms)
+        / (1000.0 * DATEDIFF(SECOND, @start, @end)) AS wait_ratio
+FROM sys.query_store_wait_stats ws
+JOIN sys.query_store_runtime_stats_interval rsi
+    ON ws.runtime_stats_interval_id = rsi.runtime_stats_interval_id
+WHERE rsi.start_time >= @start AND rsi.start_time < @end
+AND   ws.execution_type = 0
+" + WaitCategoryExclusion + @"
+GROUP BY ws.wait_category, ws.wait_category_desc
+ORDER BY wait_ratio DESC;";
+
+        var rows = new List<WaitCategoryTotal>();
+        await using var conn = new SqlConnection(connectionString);
+        await conn.OpenAsync(ct);
+        await using var cmd = new SqlCommand(sql, conn) { CommandTimeout = 120 };
+        cmd.Parameters.Add(new SqlParameter("@start", startUtc));
+        cmd.Parameters.Add(new SqlParameter("@end", endUtc));
+        await using var reader = await cmd.ExecuteReaderAsync(ct);
+        while (await reader.ReadAsync(ct))
+        {
+            rows.Add(new WaitCategoryTotal
+            {
+                WaitCategory = reader.GetInt16(0),
+                WaitCategoryDesc = reader.GetString(1),
+                WaitRatio = (double)reader.GetDecimal(2),
+            });
+        }
+        return rows;
+    }
+
+    /// <summary>
+    /// Per-plan wait stats aggregated for a time range, grouped by plan_id + category.
+    /// WaitRatio = SUM(total_query_wait_time_ms) / interval_duration_ms.
+    /// </summary>
+    public static async Task<List<(long PlanId, WaitCategoryTotal Wait)>> FetchPlanWaitStatsAsync(
+        string connectionString, DateTime startUtc, DateTime endUtc,
+        CancellationToken ct = default)
+    {
+        const string sql = @"
+SET TRANSACTION ISOLATION LEVEL READ UNCOMMITTED;
+SELECT
+    ws.plan_id,
+    ws.wait_category,
+    ws.wait_category_desc,
+    1.0 * SUM(ws.total_query_wait_time_ms)
+        / (1000.0 * DATEDIFF(SECOND, @start, @end)) AS wait_ratio
+FROM sys.query_store_wait_stats ws
+JOIN sys.query_store_runtime_stats_interval rsi
+    ON ws.runtime_stats_interval_id = rsi.runtime_stats_interval_id
+WHERE rsi.start_time >= @start AND rsi.start_time < @end
+AND   ws.execution_type = 0
+" + WaitCategoryExclusion + @"
+GROUP BY ws.plan_id, ws.wait_category, ws.wait_category_desc
+ORDER BY ws.plan_id, wait_ratio DESC;";
+
+        var rows = new List<(long, WaitCategoryTotal)>();
+        await using var conn = new SqlConnection(connectionString);
+        await conn.OpenAsync(ct);
+        await using var cmd = new SqlCommand(sql, conn) { CommandTimeout = 120 };
+        cmd.Parameters.Add(new SqlParameter("@start", startUtc));
+        cmd.Parameters.Add(new SqlParameter("@end", endUtc));
+        await using var reader = await cmd.ExecuteReaderAsync(ct);
+        while (await reader.ReadAsync(ct))
+        {
+            rows.Add((reader.GetInt64(0), new WaitCategoryTotal
+            {
+                WaitCategory = reader.GetInt16(1),
+                WaitCategoryDesc = reader.GetString(2),
+                WaitRatio = (double)reader.GetDecimal(3),
+            }));
+        }
+        return rows;
+    }
+
+    /// <summary>
+    /// Hourly wait stats for the ribbon chart, grouped by hour + category.
+    /// WaitRatio = SUM(total_query_wait_time_ms) / 3_600_000 (one hour in ms).
+    /// </summary>
+    public static async Task<List<WaitCategoryTimeSlice>> FetchGlobalWaitStatsRibbonAsync(
+        string connectionString, DateTime startUtc, DateTime endUtc,
+        CancellationToken ct = default)
+    {
+        const string sql = @"
+SET TRANSACTION ISOLATION LEVEL READ UNCOMMITTED;
+SELECT
+    DATEADD(HOUR, DATEDIFF(HOUR, 0, rsi.start_time), 0) AS bucket_hour,
+    ws.wait_category,
+    ws.wait_category_desc,
+    1.0 * SUM(ws.total_query_wait_time_ms) / (3600.0 * 1000.0) AS wait_ratio
+FROM sys.query_store_wait_stats ws
+JOIN sys.query_store_runtime_stats_interval rsi
+    ON ws.runtime_stats_interval_id = rsi.runtime_stats_interval_id
+WHERE rsi.start_time >= @start AND rsi.start_time < @end
+AND   ws.execution_type = 0
+" + WaitCategoryExclusion + @"
+GROUP BY DATEADD(HOUR, DATEDIFF(HOUR, 0, rsi.start_time), 0),
+         ws.wait_category, ws.wait_category_desc
+ORDER BY bucket_hour, wait_ratio DESC;";
+
+        var rows = new List<WaitCategoryTimeSlice>();
+        await using var conn = new SqlConnection(connectionString);
+        await conn.OpenAsync(ct);
+        await using var cmd = new SqlCommand(sql, conn) { CommandTimeout = 120 };
+        cmd.Parameters.Add(new SqlParameter("@start", startUtc));
+        cmd.Parameters.Add(new SqlParameter("@end", endUtc));
+        await using var reader = await cmd.ExecuteReaderAsync(ct);
+        while (await reader.ReadAsync(ct))
+        {
+            var bucketHour = reader.GetDateTime(0);
+            rows.Add(new WaitCategoryTimeSlice
+            {
+                IntervalStartUtc = DateTime.SpecifyKind(bucketHour, DateTimeKind.Utc),
+                WaitCategory = reader.GetInt16(1),
+                WaitCategoryDesc = reader.GetString(2),
+                WaitRatio = (double)reader.GetDecimal(3),
+            });
+        }
+        return rows;
+    }
+
+    /// <summary>
+    /// Builds a WaitProfile from raw category totals.
+    /// Top 3 categories are kept; everything else is consolidated into "Others".
+    /// </summary>
+    public static WaitProfile BuildWaitProfile(IEnumerable<WaitCategoryTotal> waits)
+    {
+        var sorted = waits.OrderByDescending(w => w.WaitRatio).ToList();
+        var grand = sorted.Sum(w => w.WaitRatio);
+        if (grand <= 0) return new WaitProfile();
+
+        var profile = new WaitProfile { GrandTotalRatio = grand };
+        double othersRatio = 0;
+        for (int i = 0; i < sorted.Count; i++)
+        {
+            if (i < 3)
+            {
+                profile.Segments.Add(new WaitProfileSegment
+                {
+                    Category = sorted[i].WaitCategoryDesc,
+                    WaitRatio = sorted[i].WaitRatio,
+                    Ratio = sorted[i].WaitRatio / grand,
+                    IsNamed = true,
+                });
+            }
+            else
+            {
+                othersRatio += sorted[i].WaitRatio;
+            }
+        }
+        if (othersRatio > 0)
+        {
+            profile.Segments.Add(new WaitProfileSegment
+            {
+                Category = "Others",
+                WaitRatio = othersRatio,
+                Ratio = othersRatio / grand,
+                IsNamed = false,
+            });
+        }
+        return profile;
+    }
 }

From 00c5c7e4116e68214f4ad45124273f70022c7d01 Mon Sep 17 00:00:00 2001
From: rferraton <16419423+rferraton@users.noreply.github.com>
Date: Sun, 22 Mar 2026 22:48:31 +0100
Subject: [PATCH 05/31] - display gap on waitstats evolution - display simple
 stacked wait profile per default instead on %stacked

---
 .../Controls/QueryStoreGridControl.axaml      |  2 +-
 .../Controls/QueryStoreGridControl.axaml.cs   |  4 +-
 .../Controls/WaitStatsRibbonControl.axaml.cs  | 51 ++++++++++++++-----
 .../Services/QueryStoreService.cs             | 19 ++++---
 4 files changed, 53 insertions(+), 23 deletions(-)

diff --git a/src/PlanViewer.App/Controls/QueryStoreGridControl.axaml b/src/PlanViewer.App/Controls/QueryStoreGridControl.axaml
index e3db6b7..d5a1e16 100644
--- a/src/PlanViewer.App/Controls/QueryStoreGridControl.axaml
+++ b/src/PlanViewer.App/Controls/QueryStoreGridControl.axaml
@@ -155,7 +155,7 @@
                 <DataGridTemplateColumn SortMemberPath="WaitGrandTotalSort" Width="160">
                     <DataGridTemplateColumn.Header>
                         <StackPanel Orientation="Horizontal" Spacing="4">
-                            <Button Content="%" Width="20" Height="18" Padding="0"
+                            <Button Content="v" Width="20" Height="18" Padding="0"
                                     FontSize="10" FontWeight="Bold"
                                     Background="Transparent" BorderThickness="1"
                                     BorderBrush="{DynamicResource ForegroundMutedBrush}"
diff --git a/src/PlanViewer.App/Controls/QueryStoreGridControl.axaml.cs b/src/PlanViewer.App/Controls/QueryStoreGridControl.axaml.cs
index b8f8f7a..d305d0d 100644
--- a/src/PlanViewer.App/Controls/QueryStoreGridControl.axaml.cs
+++ b/src/PlanViewer.App/Controls/QueryStoreGridControl.axaml.cs
@@ -42,7 +42,7 @@ public partial class QueryStoreGridControl : UserControl
     private bool _suppressRangeChanged;
     private string? _waitHighlightCategory;
     private bool _waitStatsEnabled = true;
-    private bool _waitPercentMode = true;
+    private bool _waitPercentMode;
 
     public event EventHandler<List<QueryStorePlan>>? PlansSelected;
     public event EventHandler<string>? DatabaseChanged;
@@ -1115,7 +1115,7 @@ public string? WaitHighlightCategory
         set { _waitHighlightCategory = value; OnPropertyChanged(); }
     }
 
-    private bool _waitPercentMode = true;
+    private bool _waitPercentMode;
     private double _waitMaxGrandTotal = 1.0;
 
     public bool WaitPercentMode
diff --git a/src/PlanViewer.App/Controls/WaitStatsRibbonControl.axaml.cs b/src/PlanViewer.App/Controls/WaitStatsRibbonControl.axaml.cs
index 94795af..a56f1dd 100644
--- a/src/PlanViewer.App/Controls/WaitStatsRibbonControl.axaml.cs
+++ b/src/PlanViewer.App/Controls/WaitStatsRibbonControl.axaml.cs
@@ -1,5 +1,4 @@
 using System;
-using System;
 using System.Collections.Generic;
 using System.Linq;
 using Avalonia;
@@ -65,20 +64,27 @@ private void Redraw()
 
         var top3 = new HashSet<string>(globalTotals.Take(3).Select(x => x.Cat));
 
-        // Group by hour
-        var buckets = _data
+        // Group by hour into a lookup
+        var bucketLookup = _data
             .GroupBy(d => d.IntervalStartUtc)
-            .OrderBy(g => g.Key)
-            .ToList();
+            .ToDictionary(g => g.Key, g => g.ToList());
 
-        if (buckets.Count == 0) return;
+        if (bucketLookup.Count == 0) return;
 
-        var n = buckets.Count;
+        // Build a complete hourly timeline from min to max
+        var minHour = bucketLookup.Keys.Min();
+        var maxHour = bucketLookup.Keys.Max();
+        var allHours = new List<DateTime>();
+        for (var hr = minHour; hr <= maxHour; hr = hr.AddHours(1))
+            allHours.Add(hr);
+
+        var n = allHours.Count;
+        if (n == 0) return;
         var barGap = Math.Min(2.0, Math.Max(0.5, w / n * 0.1));
         var stepX = w / n;
 
-        // Compute max total per bucket for Y scaling
-        var maxTotal = buckets.Max(b => b.Sum(x => x.WaitRatio));
+        // Compute max total per bucket for Y scaling (only buckets with data)
+        var maxTotal = bucketLookup.Values.Max(b => b.Sum(x => x.WaitRatio));
         if (maxTotal <= 0) maxTotal = 1;
 
         // Build ordered category list: top3 first, then "Others"
@@ -90,8 +96,13 @@ private void Redraw()
 
         for (int i = 0; i < n; i++)
         {
-            var bucket = buckets[i];
+            var hour = allHours[i];
             var x = i * stepX;
+
+            // Skip drawing if no data for this hour (gap in timeline)
+            if (!bucketLookup.TryGetValue(hour, out var bucketItems))
+                continue;
+
             double y = PaddingTop + chartH; // bottom
 
             // Aggregate into top3 + Others per bucket
@@ -99,7 +110,7 @@ private void Redraw()
             foreach (var cat in orderedCats)
                 catValues[cat] = 0;
 
-            foreach (var s in bucket)
+            foreach (var s in bucketItems)
             {
                 if (top3.Contains(s.WaitCategoryDesc))
                     catValues[s.WaitCategoryDesc] += s.WaitRatio;
@@ -130,7 +141,21 @@ private void Redraw()
                 Canvas.SetTop(rect, y);
                 RibbonCanvas.Children.Add(rect);
 
-                ToolTip.SetTip(rect, $"{cat}: {ratio:P2}");
+                var intervalStart = hour;
+                var intervalEnd = intervalStart.AddHours(1);
+                var startDisplay = TimeDisplayHelper.FormatForDisplay(intervalStart, "yyyy-MM-dd HH:mm");
+                var endDisplay = intervalStart.Date == intervalEnd.Date
+                    ? TimeDisplayHelper.FormatForDisplay(intervalEnd, "HH:mm")
+                    : TimeDisplayHelper.FormatForDisplay(intervalEnd, "yyyy-MM-dd HH:mm");
+                var tipBlock = new TextBlock
+                {
+                    Text = $"{cat}: {ratio:P2}\n{startDisplay} \u2013 {endDisplay}",
+                    FontSize = 13,
+                    Padding = new Thickness(6, 4),
+                };
+                ToolTip.SetTip(rect, tipBlock);
+                ToolTip.SetVerticalOffset(rect, 12);
+                ToolTip.SetShowDelay(rect, 200);
 
                 var capturedCat = cat;
                 rect.PointerPressed += (_, pe) =>
@@ -149,7 +174,7 @@ private void Redraw()
         int labelInterval = Math.Max(1, n / 6);
         for (int i = 0; i < n; i += labelInterval)
         {
-            var dt = buckets[i].Key;
+            var dt = allHours[i];
             var tb = new TextBlock
             {
                 Text = TimeDisplayHelper.FormatForDisplay(dt, "MM/dd HH:mm"),
diff --git a/src/PlanViewer.Core/Services/QueryStoreService.cs b/src/PlanViewer.Core/Services/QueryStoreService.cs
index dd8d468..b59113a 100644
--- a/src/PlanViewer.Core/Services/QueryStoreService.cs
+++ b/src/PlanViewer.Core/Services/QueryStoreService.cs
@@ -473,11 +473,15 @@ JOIN sys.query_store_runtime_stats_interval rsi
         return rows;
     }
 
-    /// <summary>
-    /// Per-plan wait stats aggregated for a time range, grouped by plan_id + category.
-    /// WaitRatio = SUM(total_query_wait_time_ms) / interval_duration_ms.
-    /// </summary>
-    public static async Task<List<(long PlanId, WaitCategoryTotal Wait)>> FetchPlanWaitStatsAsync(
+	/// <summary>
+	/// Per-plan wait stats aggregated for a time range, grouped by plan_id + category.
+	/// WaitRatio = SUM(total_query_wait_time_ms) / sum(rs.avg_duration*rs.count_executions 
+	/// ==> May be challenged. But at the detail level we use the plan duration use query stats. 
+    /// So it is different from the other wait ratio calculation, which is based on the interval duration. 
+    /// We can consider to align them in the future if needed. 
+	/// 
+	/// </summary>
+	public static async Task<List<(long PlanId, WaitCategoryTotal Wait)>> FetchPlanWaitStatsAsync(
         string connectionString, DateTime startUtc, DateTime endUtc,
         CancellationToken ct = default)
     {
@@ -488,10 +492,11 @@ JOIN sys.query_store_runtime_stats_interval rsi
     ws.wait_category,
     ws.wait_category_desc,
     1.0 * SUM(ws.total_query_wait_time_ms)
-        / (1000.0 * DATEDIFF(SECOND, @start, @end)) AS wait_ratio
+        / sum(rs.avg_duration*rs.count_executions) AS wait_ratio
 FROM sys.query_store_wait_stats ws
 JOIN sys.query_store_runtime_stats_interval rsi
     ON ws.runtime_stats_interval_id = rsi.runtime_stats_interval_id
+JOIN sys.query_store_runtime_stats rs ON rs.runtime_stats_interval_id = rsi.runtime_stats_interval_id and rs.plan_id=ws.plan_id
 WHERE rsi.start_time >= @start AND rsi.start_time < @end
 AND   ws.execution_type = 0
 " + WaitCategoryExclusion + @"
@@ -511,7 +516,7 @@ JOIN sys.query_store_runtime_stats_interval rsi
             {
                 WaitCategory = reader.GetInt16(1),
                 WaitCategoryDesc = reader.GetString(2),
-                WaitRatio = (double)reader.GetDecimal(3),
+                WaitRatio = reader.GetDouble(3),
             }));
         }
         return rows;

From 91cf796f4ad2d48d90567a546ec13408eee3027c Mon Sep 17 00:00:00 2001
From: rferraton <16419423+rferraton@users.noreply.github.com>
Date: Mon, 23 Mar 2026 21:00:39 +0100
Subject: [PATCH 06/31] Remove verbose wait stats debug logs; improve column
 toggle

Most Debug.WriteLine statements for wait stats have been removed, leaving only exception logging. The WaitProfile column visibility toggle now uses SortMemberPath instead of a hardcoded index, making the code more robust to column order changes.
---
 .../Controls/QueryStoreGridControl.axaml.cs   | 26 ++++++-------------
 1 file changed, 8 insertions(+), 18 deletions(-)

diff --git a/src/PlanViewer.App/Controls/QueryStoreGridControl.axaml.cs b/src/PlanViewer.App/Controls/QueryStoreGridControl.axaml.cs
index d305d0d..1769992 100644
--- a/src/PlanViewer.App/Controls/QueryStoreGridControl.axaml.cs
+++ b/src/PlanViewer.App/Controls/QueryStoreGridControl.axaml.cs
@@ -192,11 +192,8 @@ private async System.Threading.Tasks.Task FetchPlansForRangeAsync()
             SelectToggleButton.Content = "Select None";
 
             // Fetch wait stats in parallel (non-blocking for plan display)
-            Debug.WriteLine($"[WAITSTATS] Gate check: _waitStatsEnabled={_waitStatsEnabled}, start={_slicerStartUtc}, end={_slicerEndUtc}");
             if (_waitStatsEnabled && _slicerStartUtc.HasValue && _slicerEndUtc.HasValue)
                 _ = FetchWaitStatsAsync(_slicerStartUtc.Value, _slicerEndUtc.Value, ct);
-            else
-                Debug.WriteLine("[WAITSTATS] Skipped FetchWaitStatsAsync (gate failed)");
         }
         catch (OperationCanceledException)
         {
@@ -375,35 +372,27 @@ private async void OnTimeRangeChanged(object? sender, TimeRangeChangedEventArgs
     private async System.Threading.Tasks.Task FetchWaitStatsAsync(
         DateTime startUtc, DateTime endUtc, CancellationToken ct)
     {
-        Debug.WriteLine($"[WAITSTATS] FetchWaitStatsAsync called: {startUtc:O} → {endUtc:O}, _waitStatsEnabled={_waitStatsEnabled}");
         try
         {
             // Global (bar)
             var globalWaits = await QueryStoreService.FetchGlobalWaitStatsAsync(
                 _connectionString, startUtc, endUtc, ct);
-            Debug.WriteLine($"[WAITSTATS] FetchGlobalWaitStatsAsync returned {globalWaits.Count} rows");
             foreach (var w in globalWaits)
-                Debug.WriteLine($"[WAITSTATS]   cat={w.WaitCategoryDesc}, ratio={w.WaitRatio}");
-            if (ct.IsCancellationRequested) { Debug.WriteLine("[WAITSTATS] Cancelled after global fetch"); return; }
+            if (ct.IsCancellationRequested) { return; }
             var globalProfile = QueryStoreService.BuildWaitProfile(globalWaits);
-            Debug.WriteLine($"[WAITSTATS] BuildWaitProfile → GrandTotalRatio={globalProfile.GrandTotalRatio}, Segments={globalProfile.Segments.Count}");
             foreach (var s in globalProfile.Segments)
-                Debug.WriteLine($"[WAITSTATS]   seg: {s.Category} WaitRatio={s.WaitRatio} Ratio={s.Ratio} IsNamed={s.IsNamed}");
             WaitStatsProfile.SetBarProfile(globalProfile);
-            Debug.WriteLine("[WAITSTATS] SetBarProfile called");
 
             // Global (ribbon) — fetched lazily, data ready for toggle
             var ribbonData = await QueryStoreService.FetchGlobalWaitStatsRibbonAsync(
                 _connectionString, startUtc, endUtc, ct);
-            Debug.WriteLine($"[WAITSTATS] FetchGlobalWaitStatsRibbonAsync returned {ribbonData.Count} rows");
-            if (ct.IsCancellationRequested) { Debug.WriteLine("[WAITSTATS] Cancelled after ribbon fetch"); return; }
+            if (ct.IsCancellationRequested) { return; }
             WaitStatsProfile.SetRibbonData(ribbonData);
 
             // Per-plan
             var planWaits = await QueryStoreService.FetchPlanWaitStatsAsync(
                 _connectionString, startUtc, endUtc, ct);
-            Debug.WriteLine($"[WAITSTATS] FetchPlanWaitStatsAsync returned {planWaits.Count} rows");
-            if (ct.IsCancellationRequested) { Debug.WriteLine("[WAITSTATS] Cancelled after plan waits fetch"); return; }
+            if (ct.IsCancellationRequested) { return; }
 
             var byPlan = planWaits
                 .GroupBy(x => x.PlanId)
@@ -417,9 +406,7 @@ private async System.Threading.Tasks.Task FetchWaitStatsAsync(
                     row.WaitProfile = null;
             }
             UpdateWaitBarMode();
-            Debug.WriteLine("[WAITSTATS] FetchWaitStatsAsync completed successfully");
         }
-        catch (OperationCanceledException) { Debug.WriteLine("[WAITSTATS] FetchWaitStatsAsync CANCELLED"); }
         catch (Exception ex) { Debug.WriteLine($"[WAITSTATS] FetchWaitStatsAsync EXCEPTION: {ex}"); }
     }
 
@@ -467,8 +454,11 @@ private void ApplyWaitHighlight()
     private void OnWaitStatsCollapsedChanged(object? sender, bool collapsed)
     {
         _waitStatsEnabled = !collapsed;
-        // WaitProfile column is at index 6
-        ResultsGrid.Columns[6].IsVisible = !collapsed;
+
+        var waitProfileCol = ResultsGrid.Columns
+            .FirstOrDefault(c => c.SortMemberPath == "WaitGrandTotalSort");
+        if (waitProfileCol != null)
+            waitProfileCol.IsVisible = !collapsed;
 
         if (!collapsed && _slicerStartUtc.HasValue && _slicerEndUtc.HasValue)
         {

From 133c9b0c493f857073c7e9f131e278a2bd95c593 Mon Sep 17 00:00:00 2001
From: rferraton <16419423+rferraton@users.noreply.github.com>
Date: Mon, 23 Mar 2026 21:01:14 +0100
Subject: [PATCH 07/31] Prevent division by zero in wait_ratio calculation

Wrapped denominator in NULLIF to avoid division by zero errors
when calculating wait_ratio in QueryStoreService.cs.

Also made
minor formatting and comment improvements for clarity.
---
 src/PlanViewer.Core/Services/QueryStoreService.cs | 7 +++----
 1 file changed, 3 insertions(+), 4 deletions(-)

diff --git a/src/PlanViewer.Core/Services/QueryStoreService.cs b/src/PlanViewer.Core/Services/QueryStoreService.cs
index b59113a..dec2e83 100644
--- a/src/PlanViewer.Core/Services/QueryStoreService.cs
+++ b/src/PlanViewer.Core/Services/QueryStoreService.cs
@@ -475,11 +475,10 @@ JOIN sys.query_store_runtime_stats_interval rsi
 
 	/// <summary>
 	/// Per-plan wait stats aggregated for a time range, grouped by plan_id + category.
-	/// WaitRatio = SUM(total_query_wait_time_ms) / sum(rs.avg_duration*rs.count_executions 
+	/// WaitRatio = SUM(total_query_wait_time_ms) / sum(rs.avg_duration*rs.count_executions) 
 	/// ==> May be challenged. But at the detail level we use the plan duration use query stats. 
     /// So it is different from the other wait ratio calculation, which is based on the interval duration. 
-    /// We can consider to align them in the future if needed. 
-	/// 
+    /// We can consider to align them in the future if needed.
 	/// </summary>
 	public static async Task<List<(long PlanId, WaitCategoryTotal Wait)>> FetchPlanWaitStatsAsync(
         string connectionString, DateTime startUtc, DateTime endUtc,
@@ -492,7 +491,7 @@ JOIN sys.query_store_runtime_stats_interval rsi
     ws.wait_category,
     ws.wait_category_desc,
     1.0 * SUM(ws.total_query_wait_time_ms)
-        / sum(rs.avg_duration*rs.count_executions) AS wait_ratio
+        / NULLIF(SUM(rs.avg_duration*rs.count_executions),0) AS wait_ratio
 FROM sys.query_store_wait_stats ws
 JOIN sys.query_store_runtime_stats_interval rsi
     ON ws.runtime_stats_interval_id = rsi.runtime_stats_interval_id

From 2d2ac093e8fa7b948cecac3613cf21aac6829e77 Mon Sep 17 00:00:00 2001
From: Erik Darling <2136037+erikdarlingdata@users.noreply.github.com>
Date: Mon, 23 Mar 2026 18:58:39 -0400
Subject: [PATCH 08/31] Fix wait stats cleanup: tab indentation and
 CancellationToken leak

- Replace tab indentation with spaces in FetchPlanWaitStatsAsync doc
  comments to match file convention
- Rewrite doc comment for clarity (explain why plan-level WTR differs)
- Use existing _fetchCts instead of creating untracked CancellationTokenSource
  in OnWaitStatsCollapsedChanged

Follow-up to PR #137.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
---
 .../Controls/QueryStoreGridControl.axaml.cs       |  6 +++---
 src/PlanViewer.Core/Services/QueryStoreService.cs | 15 +++++++--------
 2 files changed, 10 insertions(+), 11 deletions(-)

diff --git a/src/PlanViewer.App/Controls/QueryStoreGridControl.axaml.cs b/src/PlanViewer.App/Controls/QueryStoreGridControl.axaml.cs
index 1769992..077c394 100644
--- a/src/PlanViewer.App/Controls/QueryStoreGridControl.axaml.cs
+++ b/src/PlanViewer.App/Controls/QueryStoreGridControl.axaml.cs
@@ -462,9 +462,9 @@ private void OnWaitStatsCollapsedChanged(object? sender, bool collapsed)
 
         if (!collapsed && _slicerStartUtc.HasValue && _slicerEndUtc.HasValue)
         {
-            // Re-fetch wait stats when expanding
-            var cts = new CancellationTokenSource();
-            _ = FetchWaitStatsAsync(_slicerStartUtc.Value, _slicerEndUtc.Value, cts.Token);
+            // Re-fetch wait stats when expanding — reuse the shared CTS
+            var ct = _fetchCts?.Token ?? CancellationToken.None;
+            _ = FetchWaitStatsAsync(_slicerStartUtc.Value, _slicerEndUtc.Value, ct);
         }
     }
 
diff --git a/src/PlanViewer.Core/Services/QueryStoreService.cs b/src/PlanViewer.Core/Services/QueryStoreService.cs
index dec2e83..aeb78f5 100644
--- a/src/PlanViewer.Core/Services/QueryStoreService.cs
+++ b/src/PlanViewer.Core/Services/QueryStoreService.cs
@@ -473,14 +473,13 @@ JOIN sys.query_store_runtime_stats_interval rsi
         return rows;
     }
 
-	/// <summary>
-	/// Per-plan wait stats aggregated for a time range, grouped by plan_id + category.
-	/// WaitRatio = SUM(total_query_wait_time_ms) / sum(rs.avg_duration*rs.count_executions) 
-	/// ==> May be challenged. But at the detail level we use the plan duration use query stats. 
-    /// So it is different from the other wait ratio calculation, which is based on the interval duration. 
-    /// We can consider to align them in the future if needed.
-	/// </summary>
-	public static async Task<List<(long PlanId, WaitCategoryTotal Wait)>> FetchPlanWaitStatsAsync(
+    /// <summary>
+    /// Per-plan wait stats aggregated for a time range, grouped by plan_id + category.
+    /// WaitRatio = SUM(total_query_wait_time_ms) / SUM(avg_duration * count_executions).
+    /// This differs from the global/hourly WTR (which divides by wall-clock interval) because
+    /// at plan level we measure what fraction of actual execution time was spent waiting.
+    /// </summary>
+    public static async Task<List<(long PlanId, WaitCategoryTotal Wait)>> FetchPlanWaitStatsAsync(
         string connectionString, DateTime startUtc, DateTime endUtc,
         CancellationToken ct = default)
     {

From ad52d543e6d3a34edf190646b09b5d8871921e9d Mon Sep 17 00:00:00 2001
From: rferraton <16419423+rferraton@users.noreply.github.com>
Date: Tue, 24 Mar 2026 23:48:21 +0100
Subject: [PATCH 09/31] - box selector for time range selection : adapt the
 selected period - tooltips for data and time in RangeTimeSlicer - vertical
 bands to display days (even with gaps)

---
 .../Controls/TimeRangeSlicerControl.axaml.cs  | 239 ++++++++++++++++--
 1 file changed, 220 insertions(+), 19 deletions(-)

diff --git a/src/PlanViewer.App/Controls/TimeRangeSlicerControl.axaml.cs b/src/PlanViewer.App/Controls/TimeRangeSlicerControl.axaml.cs
index 036aeaf..a3303ae 100644
--- a/src/PlanViewer.App/Controls/TimeRangeSlicerControl.axaml.cs
+++ b/src/PlanViewer.App/Controls/TimeRangeSlicerControl.axaml.cs
@@ -28,11 +28,19 @@ public partial class TimeRangeSlicerControl : UserControl
     private const double ChartPaddingTop = 16;
     private const double ChartPaddingBottom = 20;
 
-    private enum DragMode { None, MoveRange, DragStart, DragEnd }
+    // Line points computed in Redraw(), used for hover hit-testing
+    private Point[] _linePoints = Array.Empty<Point>();
+    private double  _stepX;
+
+    private enum DragMode { None, MoveRange, DragStart, DragEnd, SelectRect }
     private DragMode _dragMode = DragMode.None;
     private double _dragOriginX;
     private double _dragOriginRangeStart;
     private double _dragOriginRangeEnd;
+    private double _selectRectOriginX;   // canvas-x where drag-select started
+    private double _selectRectCurrentX;  // canvas-x of current pointer during drag-select
+
+    private int _hoveredIndex = -1;  // bucket index under the mouse (-1 = none)
 
     public event EventHandler<TimeRangeChangedEventArgs>? RangeChanged;
 
@@ -103,19 +111,29 @@ public void SetMetric(string metric)
     private DateTime GetDateTimeAtNorm(double norm)
     {
         if (_data.Count == 0) return DateTime.UtcNow;
-        var first = _data[0].IntervalStartUtc;
+        var n = _data.Count;
+        // norm is in bucket-index space: 0 = start of first bucket, 1 = end of last bucket
+        var pos = norm * n;                       // fractional bucket index
+        var idx = (int)Math.Floor(pos);
+        idx = Math.Clamp(idx, 0, n - 1);
+        var frac = pos - idx;                     // fraction within that bucket [0..1)
+        var bucketStart = _data[idx].IntervalStartUtc;
+        var ticks = bucketStart.Ticks + (long)(frac * TimeSpan.TicksPerHour);
         var last = _data[^1].IntervalStartUtc.AddHours(1);
-        var ticks = first.Ticks + (long)((last.Ticks - first.Ticks) * norm);
-        return new DateTime(Math.Clamp(ticks, first.Ticks, last.Ticks), DateTimeKind.Utc);
+        ticks = Math.Clamp(ticks, _data[0].IntervalStartUtc.Ticks, last.Ticks);
+        return new DateTime(ticks, DateTimeKind.Utc);
     }
 
     private double GetNormFromDateTime(DateTime dt)
     {
         if (_data.Count == 0) return 0;
-        var first = _data[0].IntervalStartUtc;
-        var last = _data[^1].IntervalStartUtc.AddHours(1);
-        if (last <= first) return 0;
-        return Math.Clamp((double)(dt.Ticks - first.Ticks) / (last.Ticks - first.Ticks), 0, 1);
+        var n = _data.Count;
+        // Binary-search for the bucket containing dt
+        var idx = _data.FindIndex(b => b.IntervalStartUtc.AddHours(1) > dt);
+        if (idx < 0) return 1.0; // dt is past all buckets
+        if (dt < _data[0].IntervalStartUtc) return 0;
+        var frac = (double)(dt.Ticks - _data[idx].IntervalStartUtc.Ticks) / TimeSpan.TicksPerHour;
+        return Math.Clamp((idx + Math.Clamp(frac, 0, 1)) / n, 0, 1);
     }
 
     private double MinNormInterval
@@ -123,11 +141,8 @@ private double MinNormInterval
         get
         {
             if (_data.Count == 0) return 0;
-            var first = _data[0].IntervalStartUtc;
-            var last = _data[^1].IntervalStartUtc.AddHours(1);
-            var totalHours = (last - first).TotalHours;
-            if (totalHours <= 0) return 1;
-            return Math.Min(MinIntervalHours / totalHours, 1);
+            var n = _data.Count;
+            return Math.Min(MinIntervalHours / n, 1);
         }
     }
 
@@ -210,6 +225,9 @@ public void Redraw()
             var y = chartBottom - (values[i] / max) * chartHeight;
             linePoints.Add(new Point(x, y));
         }
+        // Cache for Y-proximity hit-testing in pointer events
+        _linePoints = linePoints.ToArray();
+        _stepX      = stepX;
 
         // Area fill
         var fillBrush = TryFindBrush("SlicerChartFillBrush", new SolidColorBrush(Color.Parse("#332EAEF1")));
@@ -275,6 +293,38 @@ public void Redraw()
         Canvas.SetTop(metricTb, 2);
         SlicerCanvas.Children.Add(metricTb);
 
+        // ── Day-boundary vertical dashed lines ─────────────────────────────
+        // Walk buckets and detect when the display-mode date changes.
+        var dayLineBrush = TryFindBrush("SlicerLabelBrush", new SolidColorBrush(Color.Parse("#55E4E6EB")));
+        for (int di = 1; di < n; di++)
+        {
+            var prevDisplay = TimeDisplayHelper.ConvertForDisplay(_data[di - 1].IntervalStartUtc);
+            var curDisplay  = TimeDisplayHelper.ConvertForDisplay(_data[di].IntervalStartUtc);
+            if (curDisplay.Date != prevDisplay.Date)
+            {
+                var xDay = di * stepX; // left edge of the bucket where the new day starts
+                SlicerCanvas.Children.Add(new Line
+                {
+                    StartPoint = new Point(xDay, chartTop),
+                    EndPoint   = new Point(xDay, chartBottom),
+                    Stroke = dayLineBrush,
+                    StrokeThickness = 1,
+                    StrokeDashArray = new Avalonia.Collections.AvaloniaList<double> { 3, 3 },
+                    Opacity = 0.5,
+                });
+                var dayLabel = new TextBlock
+                {
+                    Text = curDisplay.ToString("MM/dd"),
+                    FontSize = 8,
+                    Foreground = dayLineBrush,
+                    Opacity = 0.8,
+                };
+                Canvas.SetLeft(dayLabel, xDay + 2);
+                Canvas.SetTop(dayLabel, chartTop);
+                SlicerCanvas.Children.Add(dayLabel);
+            }
+        }
+
         // ── Overlays + selection ───────────────────────────────────────────
         var overlayBrush = TryFindBrush("SlicerOverlayBrush", new SolidColorBrush(Color.Parse("#99000000")));
         var selectedBrush = TryFindBrush("SlicerSelectedBrush", new SolidColorBrush(Color.Parse("#22FFFFFF")));
@@ -344,6 +394,91 @@ public void Redraw()
             StrokeThickness = 1,
             Opacity = 0.5,
         });
+
+        // ── Drag-select rectangle overlay ──────────────────────────────────
+        if (_dragMode == DragMode.SelectRect)
+        {
+            var rx1 = Math.Min(_selectRectOriginX, _selectRectCurrentX);
+            var rx2 = Math.Max(_selectRectOriginX, _selectRectCurrentX);
+            var selRectBrush = TryFindBrush("SlicerChartLineBrush", new SolidColorBrush(Color.Parse("#2EAEF1")));
+            // Semi-transparent fill
+            SlicerCanvas.Children.Add(new Rectangle
+            {
+                Width = rx2 - rx1,
+                Height = h,
+                Fill = new SolidColorBrush(Color.Parse("#442EAEF1")),
+            });
+            Canvas.SetLeft(SlicerCanvas.Children[^1], rx1);
+            Canvas.SetTop(SlicerCanvas.Children[^1], 0);
+            // Border
+            SlicerCanvas.Children.Add(new Rectangle
+            {
+                Width = rx2 - rx1,
+                Height = h,
+                Stroke = selRectBrush,
+                StrokeThickness = 1.5,
+                Fill = Brushes.Transparent,
+            });
+            Canvas.SetLeft(SlicerCanvas.Children[^1], rx1);
+            Canvas.SetTop(SlicerCanvas.Children[^1], 0);
+        }
+
+        // ── Per-bucket hit rectangles: tooltip + hover dot ───────────────────────────
+        // Drawn last so they are on top of all overlays and receive pointer events.
+        var metricLabel = GetMetricLabel();
+        var dotBrush = TryFindBrush("SlicerChartLineBrush", new SolidColorBrush(Color.Parse("#2EAEF1")));
+        for (int i = 0; i < n; i++)
+        {
+            var bucketDisplay    = TimeDisplayHelper.ConvertForDisplay(_data[i].IntervalStartUtc);
+            var bucketDisplayEnd = bucketDisplay.AddHours(1);
+            var val              = values[i];
+            var valText          = _metric is "executions" ? $"{val:N0}" : $"{val:N2}";
+
+            TextBlock MakeTipContent() => new TextBlock
+            {
+                Text = $"{metricLabel}: {valText}\n" +
+                       $"{bucketDisplay:yyyy-MM-dd HH:mm} \u2013 {bucketDisplayEnd:HH:mm}{TimeDisplayHelper.Suffix}",
+                FontSize   = 12,
+                FontFamily = new FontFamily("Cascadia Mono,Consolas,monospace"),
+                Padding    = new Thickness(6, 4),
+            };
+
+            var hitRect = new Rectangle
+            {
+                Width   = Math.Max(1, stepX),
+                Height  = chartHeight,
+                Fill    = Brushes.Transparent,
+                Opacity = 1,
+            };
+
+            ToolTip.SetTip(hitRect, MakeTipContent());
+            ToolTip.SetShowDelay(hitRect, 300);
+            ToolTip.SetVerticalOffset(hitRect, 10);
+
+            Canvas.SetLeft(hitRect, i * stepX);
+            Canvas.SetTop(hitRect, chartTop);
+            SlicerCanvas.Children.Add(hitRect);
+        }
+
+        // ── Hover dot ──────────────────────────────────────────────────
+        var dotIdx = _hoveredIndex;
+        if (dotIdx >= 0 && dotIdx < n)
+        {
+            const double DotR = 7;
+            var dotX = dotIdx * stepX + stepX / 2;
+            var dotY = chartBottom - (values[dotIdx] / max) * chartHeight;
+            var dot = new Ellipse
+            {
+                Width           = DotR * 2,
+                Height          = DotR * 2,
+                Fill            = dotBrush,
+                Stroke          = TryFindBrush("BackgroundBrush", Brushes.Black),
+                StrokeThickness = 2,
+            };
+            Canvas.SetLeft(dot, dotX - DotR);
+            Canvas.SetTop(dot,  dotY - DotR);
+            SlicerCanvas.Children.Add(dot);
+        }
     }
 
     private void DrawHandle(double x, double canvasHeight, IBrush brush)
@@ -382,6 +517,28 @@ private IBrush TryFindBrush(string key, IBrush fallback)
         return fallback;
     }
 
+    /// <summary>
+    /// Finds the bucket index whose line point is closest horizontally to <paramref name="pos"/>,
+    /// or -1 if none qualifies.
+    /// </summary>
+    private int FindNearestLineIndex(Point pos)
+    {
+        if (_linePoints.Length == 0) return -1;
+        var best = -1;
+        var bestDist = double.MaxValue;
+        for (int i = 0; i < _linePoints.Length; i++)
+        {
+            var lp = _linePoints[i];
+            var dx = Math.Abs(pos.X - lp.X);
+            if (dx <= _stepX / 2 + 2 && dx < bestDist)
+            {
+                bestDist = dx;
+                best = i;
+            }
+        }
+        return best;
+    }
+
     // ── Interaction ────────────────────────────────────────────────────────
 
     private void Canvas_PointerPressed(object? sender, PointerPressedEventArgs e)
@@ -424,6 +581,13 @@ private void Canvas_PointerPressed(object? sender, PointerPressedEventArgs e)
             e.Handled = true;
             return;
         }
+
+        // Click outside selection → start drag-select rectangle
+        _selectRectOriginX = pos.X;
+        _selectRectCurrentX = pos.X;
+        _dragMode = DragMode.SelectRect;
+        e.Pointer.Capture(SlicerCanvas);
+        e.Handled = true;
     }
 
     private void Canvas_PointerMoved(object? sender, PointerEventArgs e)
@@ -437,7 +601,7 @@ private void Canvas_PointerMoved(object? sender, PointerEventArgs e)
         if (_dragMode == DragMode.None)
         {
             // Update cursor
-            var selLeft = _rangeStart * w;
+            var selLeft  = _rangeStart * w;
             var selRight = _rangeEnd * w;
 
             if (Math.Abs(pos.X - selLeft) <= HandleGripWidthPx ||
@@ -453,6 +617,14 @@ private void Canvas_PointerMoved(object? sender, PointerEventArgs e)
             {
                 SlicerCanvas.Cursor = Cursor.Default;
             }
+
+            // Y-proximity hover for dot
+            var newHover = FindNearestLineIndex(pos);
+            if (newHover != _hoveredIndex)
+            {
+                _hoveredIndex = newHover;
+                Redraw();
+            }
             return;
         }
 
@@ -484,6 +656,14 @@ private void Canvas_PointerMoved(object? sender, PointerEventArgs e)
                 _rangeEnd = newStart + span;
                 break;
             }
+            case DragMode.SelectRect:
+            {
+                _selectRectCurrentX = Math.Clamp(pos.X, 0, w);
+                UpdateRangeLabel();
+                Redraw();
+                e.Handled = true;
+                return;
+            }
         }
 
         UpdateRangeLabel();
@@ -493,13 +673,33 @@ private void Canvas_PointerMoved(object? sender, PointerEventArgs e)
 
     private void Canvas_PointerReleased(object? sender, PointerReleasedEventArgs e)
     {
-        if (_dragMode != DragMode.None)
+        if (_dragMode == DragMode.None) return;
+
+        if (_dragMode == DragMode.SelectRect)
         {
-            _dragMode = DragMode.None;
-            e.Pointer.Capture(null);
-            FireRangeChanged();
-            e.Handled = true;
+            var w = SlicerBorder.Bounds.Width;
+            if (w > 0)
+            {
+                var rx1 = Math.Min(_selectRectOriginX, _selectRectCurrentX);
+                var rx2 = Math.Max(_selectRectOriginX, _selectRectCurrentX);
+                // Only apply if the rectangle has meaningful width (> 4px)
+                if (rx2 - rx1 > 4)
+                {
+                    _rangeStart = Math.Clamp(rx1 / w, 0, 1);
+                    _rangeEnd   = Math.Clamp(rx2 / w, 0, 1);
+                    // Enforce minimum interval
+                    if (_rangeEnd - _rangeStart < MinNormInterval)
+                        _rangeEnd = Math.Min(1, _rangeStart + MinNormInterval);
+                }
+            }
         }
+
+        _dragMode = DragMode.None;
+        e.Pointer.Capture(null);
+        UpdateRangeLabel();
+        Redraw();
+        FireRangeChanged();
+        e.Handled = true;
     }
 
     private void Canvas_PointerWheelChanged(object? sender, PointerWheelEventArgs e)
@@ -570,3 +770,4 @@ public TimeRangeChangedEventArgs(DateTime startUtc, DateTime endUtc)
         EndUtc = endUtc;
     }
 }
+

From 97c1192e8081e3de97216de2260080b2b21a423a Mon Sep 17 00:00:00 2001
From: rferraton <16419423+rferraton@users.noreply.github.com>
Date: Wed, 25 Mar 2026 00:14:37 +0100
Subject: [PATCH 10/31] - add a "move bar" at the top of the selected period -
 allow to move RangeTimeSlicer period using keyboards arrows left and right

---
 .../Controls/TimeRangeSlicerControl.axaml.cs  | 89 +++++++++++++++++--
 1 file changed, 80 insertions(+), 9 deletions(-)

diff --git a/src/PlanViewer.App/Controls/TimeRangeSlicerControl.axaml.cs b/src/PlanViewer.App/Controls/TimeRangeSlicerControl.axaml.cs
index a3303ae..8f4261d 100644
--- a/src/PlanViewer.App/Controls/TimeRangeSlicerControl.axaml.cs
+++ b/src/PlanViewer.App/Controls/TimeRangeSlicerControl.axaml.cs
@@ -27,6 +27,7 @@ public partial class TimeRangeSlicerControl : UserControl
     private const double MinIntervalHours = 3;
     private const double ChartPaddingTop = 16;
     private const double ChartPaddingBottom = 20;
+    private const double MoveBarHeight = 14; // height of the draggable move bar at the top of the selection
 
     // Line points computed in Redraw(), used for hover hit-testing
     private Point[] _linePoints = Array.Empty<Point>();
@@ -48,6 +49,8 @@ public TimeRangeSlicerControl()
     {
         InitializeComponent();
         SlicerBorder.SizeChanged += (_, _) => Redraw();
+        SlicerCanvas.Focusable = true;
+        SlicerCanvas.KeyDown += Canvas_KeyDown;
     }
 
     public bool IsExpanded
@@ -395,6 +398,34 @@ public void Redraw()
             Opacity = 0.5,
         });
 
+        // ── Move bar at the top of the selection ────────────────────────────
+        var moveBarBrush = new SolidColorBrush(Color.Parse("#33FFFFFF"));
+        var moveBar = new Rectangle
+        {
+            Width  = Math.Max(0, selRight - selLeft),
+            Height = MoveBarHeight,
+            Fill   = moveBarBrush,
+            Cursor = new Cursor(StandardCursorType.SizeAll),
+        };
+        Canvas.SetLeft(moveBar, selLeft);
+        Canvas.SetTop(moveBar, 0);
+        SlicerCanvas.Children.Add(moveBar);
+        // Grip dots in the move bar centre
+        var moveBarMidX = (selLeft + selRight) / 2;
+        var moveBarMidY = MoveBarHeight / 2;
+        for (int gi = -1; gi <= 1; gi++)
+        {
+            var dot = new Ellipse
+            {
+                Width = 3, Height = 3,
+                Fill = handleBrush,
+                Opacity = 0.5,
+            };
+            Canvas.SetLeft(dot, moveBarMidX + gi * 6 - 1.5);
+            Canvas.SetTop(dot, moveBarMidY - 1.5);
+            SlicerCanvas.Children.Add(dot);
+        }
+
         // ── Drag-select rectangle overlay ──────────────────────────────────
         if (_dragMode == DragMode.SelectRect)
         {
@@ -452,8 +483,10 @@ public void Redraw()
             };
 
             ToolTip.SetTip(hitRect, MakeTipContent());
+            ToolTip.SetPlacement(hitRect, PlacementMode.Pointer);
+            ToolTip.SetHorizontalOffset(hitRect, 0);
+            ToolTip.SetVerticalOffset(hitRect, -16);
             ToolTip.SetShowDelay(hitRect, 300);
-            ToolTip.SetVerticalOffset(hitRect, 10);
 
             Canvas.SetLeft(hitRect, i * stepX);
             Canvas.SetTop(hitRect, chartTop);
@@ -544,6 +577,7 @@ private int FindNearestLineIndex(Point pos)
     private void Canvas_PointerPressed(object? sender, PointerPressedEventArgs e)
     {
         if (_data.Count < 2) return;
+        SlicerCanvas.Focus();
         var pos = e.GetPosition(SlicerCanvas);
         var w = SlicerBorder.Bounds.Width;
         if (w <= 0) return;
@@ -555,6 +589,15 @@ private void Canvas_PointerPressed(object? sender, PointerPressedEventArgs e)
         _dragOriginRangeStart = _rangeStart;
         _dragOriginRangeEnd = _rangeEnd;
 
+        // Click on move bar (top strip of the selection) → move
+        if (pos.Y <= MoveBarHeight && pos.X >= selLeft && pos.X <= selRight)
+        {
+            _dragMode = DragMode.MoveRange;
+            e.Pointer.Capture(SlicerCanvas);
+            e.Handled = true;
+            return;
+        }
+
         // Check if near left handle
         if (Math.Abs(pos.X - selLeft) <= HandleGripWidthPx)
         {
@@ -573,8 +616,9 @@ private void Canvas_PointerPressed(object? sender, PointerPressedEventArgs e)
             return;
         }
 
-        // Check if inside selection → move
-        if (pos.X >= selLeft && pos.X <= selRight)
+        // Inside selection: Shift+click → move, plain click → box-select (refine)
+        if (pos.X >= selLeft && pos.X <= selRight
+            && e.KeyModifiers.HasFlag(KeyModifiers.Shift))
         {
             _dragMode = DragMode.MoveRange;
             e.Pointer.Capture(SlicerCanvas);
@@ -582,7 +626,7 @@ private void Canvas_PointerPressed(object? sender, PointerPressedEventArgs e)
             return;
         }
 
-        // Click outside selection → start drag-select rectangle
+        // Default: start drag-select rectangle (works both inside and outside selection)
         _selectRectOriginX = pos.X;
         _selectRectCurrentX = pos.X;
         _dragMode = DragMode.SelectRect;
@@ -604,14 +648,14 @@ private void Canvas_PointerMoved(object? sender, PointerEventArgs e)
             var selLeft  = _rangeStart * w;
             var selRight = _rangeEnd * w;
 
-            if (Math.Abs(pos.X - selLeft) <= HandleGripWidthPx ||
-                Math.Abs(pos.X - selRight) <= HandleGripWidthPx)
+            if (pos.Y <= MoveBarHeight && pos.X >= selLeft && pos.X <= selRight)
             {
-                SlicerCanvas.Cursor = new Cursor(StandardCursorType.SizeWestEast);
+                SlicerCanvas.Cursor = new Cursor(StandardCursorType.SizeAll);
             }
-            else if (pos.X >= selLeft && pos.X <= selRight)
+            else if (Math.Abs(pos.X - selLeft) <= HandleGripWidthPx ||
+                     Math.Abs(pos.X - selRight) <= HandleGripWidthPx)
             {
-                SlicerCanvas.Cursor = new Cursor(StandardCursorType.SizeAll);
+                SlicerCanvas.Cursor = new Cursor(StandardCursorType.SizeWestEast);
             }
             else
             {
@@ -737,6 +781,33 @@ private void Canvas_PointerWheelChanged(object? sender, PointerWheelEventArgs e)
         e.Handled = true;
     }
 
+    private void Canvas_KeyDown(object? sender, KeyEventArgs e)
+    {
+        if (_data.Count < 2) return;
+        var n = _data.Count;
+        var step = 1.0 / n; // one bucket
+
+        double delta = e.Key switch
+        {
+            Key.Left  => -step,
+            Key.Right =>  step,
+            _ => 0,
+        };
+        if (delta == 0) return;
+
+        var span = _rangeEnd - _rangeStart;
+        var newStart = _rangeStart + delta;
+        if (newStart < 0) newStart = 0;
+        if (newStart + span > 1) newStart = 1 - span;
+        _rangeStart = newStart;
+        _rangeEnd = newStart + span;
+
+        UpdateRangeLabel();
+        Redraw();
+        FireRangeChanged();
+        e.Handled = true;
+    }
+
     private void UpdateRangeLabel()
     {
         if (_data.Count == 0)

From dbfaf21c7954dc3eb6d4ea258125ffd057eb6ad3 Mon Sep 17 00:00:00 2001
From: rferraton <16419423+rferraton@users.noreply.github.com>
Date: Wed, 25 Mar 2026 00:55:41 +0100
Subject: [PATCH 11/31] improve perf and stability

---
 .../Controls/TimeRangeSlicerControl.axaml.cs  | 81 +++++++++++++------
 1 file changed, 58 insertions(+), 23 deletions(-)

diff --git a/src/PlanViewer.App/Controls/TimeRangeSlicerControl.axaml.cs b/src/PlanViewer.App/Controls/TimeRangeSlicerControl.axaml.cs
index 8f4261d..2b4912c 100644
--- a/src/PlanViewer.App/Controls/TimeRangeSlicerControl.axaml.cs
+++ b/src/PlanViewer.App/Controls/TimeRangeSlicerControl.axaml.cs
@@ -7,6 +7,7 @@
 using Avalonia.Input;
 using Avalonia.Interactivity;
 using Avalonia.Media;
+using Avalonia.Threading;
 using PlanViewer.Core.Models;
 using PlanViewer.Core.Services;
 
@@ -29,6 +30,22 @@ public partial class TimeRangeSlicerControl : UserControl
     private const double ChartPaddingBottom = 20;
     private const double MoveBarHeight = 14; // height of the draggable move bar at the top of the selection
 
+    // Cached brushes and objects to avoid allocations on every Redraw
+    private static readonly SolidColorBrush FallbackChartFillBrush   = new(Color.Parse("#332EAEF1"));
+    private static readonly SolidColorBrush FallbackChartLineBrush   = new(Color.Parse("#2EAEF1"));
+    private static readonly SolidColorBrush FallbackLabelBrush       = new(Color.Parse("#99E4E6EB"));
+    private static readonly SolidColorBrush FallbackDayLineBrush     = new(Color.Parse("#55E4E6EB"));
+    private static readonly SolidColorBrush FallbackForegroundBrush  = new(Color.Parse("#E4E6EB"));
+    private static readonly SolidColorBrush FallbackOverlayBrush     = new(Color.Parse("#99000000"));
+    private static readonly SolidColorBrush FallbackSelectedBrush    = new(Color.Parse("#22FFFFFF"));
+    private static readonly SolidColorBrush FallbackHandleBrush      = new(Color.Parse("#E4E6EB"));
+    private static readonly SolidColorBrush MoveBarBrush             = new(Color.Parse("#33FFFFFF"));
+    private static readonly SolidColorBrush SelectRectFillBrush      = new(Color.Parse("#442EAEF1"));
+    private static readonly Avalonia.Collections.AvaloniaList<double> DashArray = new() { 3, 3 };
+    private static readonly Cursor CursorSizeAll     = new(StandardCursorType.SizeAll);
+    private static readonly Cursor CursorSizeWE      = new(StandardCursorType.SizeWestEast);
+    private static readonly FontFamily TooltipFont   = new("Cascadia Mono,Consolas,monospace");
+
     // Line points computed in Redraw(), used for hover hit-testing
     private Point[] _linePoints = Array.Empty<Point>();
     private double  _stepX;
@@ -42,6 +59,7 @@ private enum DragMode { None, MoveRange, DragStart, DragEnd, SelectRect }
     private double _selectRectCurrentX;  // canvas-x of current pointer during drag-select
 
     private int _hoveredIndex = -1;  // bucket index under the mouse (-1 = none)
+    private DispatcherTimer? _rangeChangedDebounce;
 
     public event EventHandler<TimeRangeChangedEventArgs>? RangeChanged;
 
@@ -131,10 +149,13 @@ private double GetNormFromDateTime(DateTime dt)
     {
         if (_data.Count == 0) return 0;
         var n = _data.Count;
-        // Binary-search for the bucket containing dt
+        if (dt < _data[0].IntervalStartUtc) return 0;
+        // Find first bucket whose end is past dt
         var idx = _data.FindIndex(b => b.IntervalStartUtc.AddHours(1) > dt);
         if (idx < 0) return 1.0; // dt is past all buckets
-        if (dt < _data[0].IntervalStartUtc) return 0;
+        // If dt is before this bucket's start (gap), snap to this bucket's start
+        if (dt < _data[idx].IntervalStartUtc)
+            return (double)idx / n;
         var frac = (double)(dt.Ticks - _data[idx].IntervalStartUtc.Ticks) / TimeSpan.TicksPerHour;
         return Math.Clamp((idx + Math.Clamp(frac, 0, 1)) / n, 0, 1);
     }
@@ -233,7 +254,7 @@ public void Redraw()
         _stepX      = stepX;
 
         // Area fill
-        var fillBrush = TryFindBrush("SlicerChartFillBrush", new SolidColorBrush(Color.Parse("#332EAEF1")));
+        var fillBrush = TryFindBrush("SlicerChartFillBrush", FallbackChartFillBrush);
         var areaGeometry = new StreamGeometry();
         using (var ctx = areaGeometry.Open())
         {
@@ -250,7 +271,7 @@ public void Redraw()
         });
 
         // Line
-        var lineBrush = TryFindBrush("SlicerChartLineBrush", new SolidColorBrush(Color.Parse("#2EAEF1")));
+        var lineBrush = TryFindBrush("SlicerChartLineBrush", FallbackChartLineBrush);
         var lineGeometry = new StreamGeometry();
         using (var ctx = lineGeometry.Open())
         {
@@ -267,7 +288,7 @@ public void Redraw()
         });
 
         // X-axis labels (show a few ticks)
-        var labelBrush = TryFindBrush("SlicerLabelBrush", new SolidColorBrush(Color.Parse("#99E4E6EB")));
+        var labelBrush = TryFindBrush("SlicerLabelBrush", FallbackLabelBrush);
         int labelInterval = Math.Max(1, n / 8);
         for (int i = 0; i < n; i += labelInterval)
         {
@@ -290,7 +311,7 @@ public void Redraw()
         {
             Text = GetMetricLabel(),
             FontSize = 12,
-            Foreground = TryFindBrush("ForegroundBrush", new SolidColorBrush(Color.Parse("#E4E6EB"))),
+            Foreground = TryFindBrush("ForegroundBrush", FallbackForegroundBrush),
         };
         Canvas.SetRight(metricTb, 4);
         Canvas.SetTop(metricTb, 2);
@@ -298,7 +319,7 @@ public void Redraw()
 
         // ── Day-boundary vertical dashed lines ─────────────────────────────
         // Walk buckets and detect when the display-mode date changes.
-        var dayLineBrush = TryFindBrush("SlicerLabelBrush", new SolidColorBrush(Color.Parse("#55E4E6EB")));
+        var dayLineBrush = TryFindBrush("SlicerLabelBrush", FallbackDayLineBrush);
         for (int di = 1; di < n; di++)
         {
             var prevDisplay = TimeDisplayHelper.ConvertForDisplay(_data[di - 1].IntervalStartUtc);
@@ -312,7 +333,7 @@ public void Redraw()
                     EndPoint   = new Point(xDay, chartBottom),
                     Stroke = dayLineBrush,
                     StrokeThickness = 1,
-                    StrokeDashArray = new Avalonia.Collections.AvaloniaList<double> { 3, 3 },
+                    StrokeDashArray = DashArray,
                     Opacity = 0.5,
                 });
                 var dayLabel = new TextBlock
@@ -329,9 +350,9 @@ public void Redraw()
         }
 
         // ── Overlays + selection ───────────────────────────────────────────
-        var overlayBrush = TryFindBrush("SlicerOverlayBrush", new SolidColorBrush(Color.Parse("#99000000")));
-        var selectedBrush = TryFindBrush("SlicerSelectedBrush", new SolidColorBrush(Color.Parse("#22FFFFFF")));
-        var handleBrush = TryFindBrush("SlicerHandleBrush", new SolidColorBrush(Color.Parse("#E4E6EB")));
+        var overlayBrush = TryFindBrush("SlicerOverlayBrush", FallbackOverlayBrush);
+        var selectedBrush = TryFindBrush("SlicerSelectedBrush", FallbackSelectedBrush);
+        var handleBrush = TryFindBrush("SlicerHandleBrush", FallbackHandleBrush);
 
         var selLeft = _rangeStart * w;
         var selRight = _rangeEnd * w;
@@ -399,13 +420,12 @@ public void Redraw()
         });
 
         // ── Move bar at the top of the selection ────────────────────────────
-        var moveBarBrush = new SolidColorBrush(Color.Parse("#33FFFFFF"));
         var moveBar = new Rectangle
         {
             Width  = Math.Max(0, selRight - selLeft),
             Height = MoveBarHeight,
-            Fill   = moveBarBrush,
-            Cursor = new Cursor(StandardCursorType.SizeAll),
+            Fill   = MoveBarBrush,
+            Cursor = CursorSizeAll,
         };
         Canvas.SetLeft(moveBar, selLeft);
         Canvas.SetTop(moveBar, 0);
@@ -431,13 +451,13 @@ public void Redraw()
         {
             var rx1 = Math.Min(_selectRectOriginX, _selectRectCurrentX);
             var rx2 = Math.Max(_selectRectOriginX, _selectRectCurrentX);
-            var selRectBrush = TryFindBrush("SlicerChartLineBrush", new SolidColorBrush(Color.Parse("#2EAEF1")));
+            var selRectBrush = TryFindBrush("SlicerChartLineBrush", FallbackChartLineBrush);
             // Semi-transparent fill
             SlicerCanvas.Children.Add(new Rectangle
             {
                 Width = rx2 - rx1,
                 Height = h,
-                Fill = new SolidColorBrush(Color.Parse("#442EAEF1")),
+                Fill = SelectRectFillBrush,
             });
             Canvas.SetLeft(SlicerCanvas.Children[^1], rx1);
             Canvas.SetTop(SlicerCanvas.Children[^1], 0);
@@ -457,7 +477,7 @@ public void Redraw()
         // ── Per-bucket hit rectangles: tooltip + hover dot ───────────────────────────
         // Drawn last so they are on top of all overlays and receive pointer events.
         var metricLabel = GetMetricLabel();
-        var dotBrush = TryFindBrush("SlicerChartLineBrush", new SolidColorBrush(Color.Parse("#2EAEF1")));
+        var dotBrush = TryFindBrush("SlicerChartLineBrush", FallbackChartLineBrush);
         for (int i = 0; i < n; i++)
         {
             var bucketDisplay    = TimeDisplayHelper.ConvertForDisplay(_data[i].IntervalStartUtc);
@@ -465,12 +485,12 @@ public void Redraw()
             var val              = values[i];
             var valText          = _metric is "executions" ? $"{val:N0}" : $"{val:N2}";
 
-            TextBlock MakeTipContent() => new TextBlock
+            var tipContent = new TextBlock
             {
                 Text = $"{metricLabel}: {valText}\n" +
                        $"{bucketDisplay:yyyy-MM-dd HH:mm} \u2013 {bucketDisplayEnd:HH:mm}{TimeDisplayHelper.Suffix}",
                 FontSize   = 12,
-                FontFamily = new FontFamily("Cascadia Mono,Consolas,monospace"),
+                FontFamily = TooltipFont,
                 Padding    = new Thickness(6, 4),
             };
 
@@ -482,7 +502,7 @@ public void Redraw()
                 Opacity = 1,
             };
 
-            ToolTip.SetTip(hitRect, MakeTipContent());
+            ToolTip.SetTip(hitRect, tipContent);
             ToolTip.SetPlacement(hitRect, PlacementMode.Pointer);
             ToolTip.SetHorizontalOffset(hitRect, 0);
             ToolTip.SetVerticalOffset(hitRect, -16);
@@ -650,12 +670,12 @@ private void Canvas_PointerMoved(object? sender, PointerEventArgs e)
 
             if (pos.Y <= MoveBarHeight && pos.X >= selLeft && pos.X <= selRight)
             {
-                SlicerCanvas.Cursor = new Cursor(StandardCursorType.SizeAll);
+                SlicerCanvas.Cursor = CursorSizeAll;
             }
             else if (Math.Abs(pos.X - selLeft) <= HandleGripWidthPx ||
                      Math.Abs(pos.X - selRight) <= HandleGripWidthPx)
             {
-                SlicerCanvas.Cursor = new Cursor(StandardCursorType.SizeWestEast);
+                SlicerCanvas.Cursor = CursorSizeWE;
             }
             else
             {
@@ -804,10 +824,25 @@ private void Canvas_KeyDown(object? sender, KeyEventArgs e)
 
         UpdateRangeLabel();
         Redraw();
-        FireRangeChanged();
+        DebouncedFireRangeChanged();
         e.Handled = true;
     }
 
+    private void DebouncedFireRangeChanged()
+    {
+        _rangeChangedDebounce?.Stop();
+        _rangeChangedDebounce = new DispatcherTimer
+        {
+            Interval = TimeSpan.FromMilliseconds(250),
+        };
+        _rangeChangedDebounce.Tick += (_, _) =>
+        {
+            _rangeChangedDebounce.Stop();
+            FireRangeChanged();
+        };
+        _rangeChangedDebounce.Start();
+    }
+
     private void UpdateRangeLabel()
     {
         if (_data.Count == 0)

From 2d8c595a78062461f720d06ab7f734ccfc554f34 Mon Sep 17 00:00:00 2001
From: Erik Darling <2136037+erikdarlingdata@users.noreply.github.com>
Date: Tue, 24 Mar 2026 22:32:45 -0400
Subject: [PATCH 12/31] Fix SkiaSharp native library version mismatch on Linux
 (#139)

Avalonia.Skia 11.3.12 transitively pulls SkiaSharp.NativeAssets.Linux
2.88.9 (libSkiaSharp.so v88.1), but the managed SkiaSharp 3.119.0
requires native libs in the [119.0, 120.0) range. At publish time the
old .so overwrites the correct one, causing a TypeInitializationException
on startup.

Pin SkiaSharp.NativeAssets.Linux to 3.119.0 so NuGet resolution picks
the correct native library. macOS and Win32 were already at 3.119.0.

Fixes #139

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
---
 src/PlanViewer.App/PlanViewer.App.csproj | 7 +++++++
 1 file changed, 7 insertions(+)

diff --git a/src/PlanViewer.App/PlanViewer.App.csproj b/src/PlanViewer.App/PlanViewer.App.csproj
index 54f8908..689e095 100644
--- a/src/PlanViewer.App/PlanViewer.App.csproj
+++ b/src/PlanViewer.App/PlanViewer.App.csproj
@@ -33,6 +33,13 @@
     <PackageReference Include="ModelContextProtocol.AspNetCore" Version="0.7.0-preview.1" />
     <PackageReference Include="TextMateSharp.Grammars" Version="2.0.3" />
     <PackageReference Include="Velopack" Version="0.0.1298" />
+
+    <!-- Pin SkiaSharp native assets to match SkiaSharp 3.119.0.
+         Avalonia.Skia 11.3.12 transitively pulls in 2.88.9 for Linux and WebAssembly,
+         but the managed SkiaSharp 3.x requires native libs in the [119.0, 120.0) range.
+         Without these pins, the old 2.88.x .so overwrites the correct one at publish time,
+         causing a TypeInitializationException on Linux (GitHub issue #139). -->
+    <PackageReference Include="SkiaSharp.NativeAssets.Linux" Version="3.119.0" />
   </ItemGroup>
 
   <ItemGroup>

From 5a2d4c0e74a1baa548f6eda3e14a0afe95cdac03 Mon Sep 17 00:00:00 2001
From: Erik Darling <2136037+erikdarlingdata@users.noreply.github.com>
Date: Tue, 24 Mar 2026 22:43:24 -0400
Subject: [PATCH 13/31] Gate Query Store wait stats for SQL 2017+ with capture
 mode check
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

sys.query_store_wait_stats only exists on SQL Server 2017+ (major >= 14)
and Azure SQL DB. Additionally, wait stats capture can be disabled per
database via WAIT_STATS_CAPTURE_MODE = OFF.

Changes:
- Add SupportsQueryStoreWaitStats property to ServerMetadata (major >= 14 or Azure)
- Add IsWaitStatsCaptureEnabledAsync to QueryStoreService — checks
  wait_stats_capture_mode_desc in sys.database_query_store_options
- Gate QueryStoreGridControl: accept supportsWaitStats flag, hide wait
  stats panel/column/splitter when unsupported, skip all fetch calls
- Wire both checks in QuerySessionControl before constructing the grid

On SQL 2016 or when capture is OFF: no wait stats queries are issued,
the panel is collapsed, and the Wait Profile column is hidden.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
---
 .../Controls/QuerySessionControl.axaml.cs     | 17 ++++++++++-
 .../Controls/QueryStoreGridControl.axaml.cs   | 21 +++++++++++--
 src/PlanViewer.Core/Models/ServerMetadata.cs  |  6 ++++
 .../Services/QueryStoreService.cs             | 30 +++++++++++++++++++
 4 files changed, 70 insertions(+), 4 deletions(-)

diff --git a/src/PlanViewer.App/Controls/QuerySessionControl.axaml.cs b/src/PlanViewer.App/Controls/QuerySessionControl.axaml.cs
index 2764dc9..b277089 100644
--- a/src/PlanViewer.App/Controls/QuerySessionControl.axaml.cs
+++ b/src/PlanViewer.App/Controls/QuerySessionControl.axaml.cs
@@ -1021,11 +1021,26 @@ private async void QueryStore_Click(object? sender, RoutedEventArgs e)
 
         SetStatus("");
 
+        // Check if wait stats are supported (SQL 2017+ / Azure) and capture is enabled
+        var supportsWaitStats = _serverMetadata?.SupportsQueryStoreWaitStats ?? false;
+        if (supportsWaitStats)
+        {
+            try
+            {
+                var connStr = _serverConnection!.GetConnectionString(_credentialService, _selectedDatabase!);
+                supportsWaitStats = await QueryStoreService.IsWaitStatsCaptureEnabledAsync(connStr);
+            }
+            catch
+            {
+                supportsWaitStats = false;
+            }
+        }
+
         // Build database list from the current DatabaseBox
         var databases = DatabaseBox.Items.OfType<string>().ToList();
 
         var grid = new QueryStoreGridControl(_serverConnection!, _credentialService,
-            _selectedDatabase!, databases);
+            _selectedDatabase!, databases, supportsWaitStats);
         grid.PlansSelected += OnQueryStorePlansSelected;
 
         var headerText = new TextBlock
diff --git a/src/PlanViewer.App/Controls/QueryStoreGridControl.axaml.cs b/src/PlanViewer.App/Controls/QueryStoreGridControl.axaml.cs
index 077c394..a977d9e 100644
--- a/src/PlanViewer.App/Controls/QueryStoreGridControl.axaml.cs
+++ b/src/PlanViewer.App/Controls/QueryStoreGridControl.axaml.cs
@@ -41,6 +41,7 @@ public partial class QueryStoreGridControl : UserControl
     private bool _initialOrderByLoaded;
     private bool _suppressRangeChanged;
     private string? _waitHighlightCategory;
+    private bool _waitStatsSupported;  // false until version + capture mode confirmed
     private bool _waitStatsEnabled = true;
     private bool _waitPercentMode;
 
@@ -50,12 +51,13 @@ public partial class QueryStoreGridControl : UserControl
     public string Database => _database;
 
     public QueryStoreGridControl(ServerConnection serverConnection, ICredentialService credentialService,
-        string initialDatabase, List<string> databases)
+        string initialDatabase, List<string> databases, bool supportsWaitStats = false)
     {
         _serverConnection = serverConnection;
         _credentialService = credentialService;
         _database = initialDatabase;
         _connectionString = serverConnection.GetConnectionString(credentialService, initialDatabase);
+        _waitStatsSupported = supportsWaitStats;
         _slicerDaysBack = AppSettingsService.Load().QueryStoreSlicerDays;
         InitializeComponent();
         ResultsGrid.ItemsSource = _filteredRows;
@@ -69,6 +71,19 @@ public QueryStoreGridControl(ServerConnection serverConnection, ICredentialServi
         WaitStatsProfile.CategoryDoubleClicked += OnWaitCategoryDoubleClicked;
         WaitStatsProfile.CollapsedChanged += OnWaitStatsCollapsedChanged;
 
+        if (!_waitStatsSupported)
+        {
+            // Hide wait stats panel and column when server doesn't support it
+            WaitStatsProfile.Collapse();
+            WaitStatsChevronButton.IsVisible = false;
+            WaitStatsSplitter.IsVisible = false;
+            SlicerRow.ColumnDefinitions[2].Width = new GridLength(0);
+            var waitProfileCol = ResultsGrid.Columns
+                .FirstOrDefault(c => c.SortMemberPath == "WaitGrandTotalSort");
+            if (waitProfileCol != null)
+                waitProfileCol.IsVisible = false;
+        }
+
         // Auto-fetch with default settings on connect
         Avalonia.Threading.Dispatcher.UIThread.Post(() =>
         {
@@ -192,7 +207,7 @@ private async System.Threading.Tasks.Task FetchPlansForRangeAsync()
             SelectToggleButton.Content = "Select None";
 
             // Fetch wait stats in parallel (non-blocking for plan display)
-            if (_waitStatsEnabled && _slicerStartUtc.HasValue && _slicerEndUtc.HasValue)
+            if (_waitStatsSupported && _waitStatsEnabled && _slicerStartUtc.HasValue && _slicerEndUtc.HasValue)
                 _ = FetchWaitStatsAsync(_slicerStartUtc.Value, _slicerEndUtc.Value, ct);
         }
         catch (OperationCanceledException)
@@ -460,7 +475,7 @@ private void OnWaitStatsCollapsedChanged(object? sender, bool collapsed)
         if (waitProfileCol != null)
             waitProfileCol.IsVisible = !collapsed;
 
-        if (!collapsed && _slicerStartUtc.HasValue && _slicerEndUtc.HasValue)
+        if (!collapsed && _waitStatsSupported && _slicerStartUtc.HasValue && _slicerEndUtc.HasValue)
         {
             // Re-fetch wait stats when expanding — reuse the shared CTS
             var ct = _fetchCts?.Token ?? CancellationToken.None;
diff --git a/src/PlanViewer.Core/Models/ServerMetadata.cs b/src/PlanViewer.Core/Models/ServerMetadata.cs
index bee3395..5c2c12e 100644
--- a/src/PlanViewer.Core/Models/ServerMetadata.cs
+++ b/src/PlanViewer.Core/Models/ServerMetadata.cs
@@ -28,6 +28,12 @@ public class ServerMetadata
     /// </summary>
     public bool SupportsScopedConfigs =>
         IsAzure || (int.TryParse(ProductVersion?.Split('.')[0], out var major) && major >= 13);
+
+    /// <summary>
+    /// Whether sys.query_store_wait_stats is available (SQL 2017+ or Azure).
+    /// </summary>
+    public bool SupportsQueryStoreWaitStats =>
+        IsAzure || (int.TryParse(ProductVersion?.Split('.')[0], out var major) && major >= 14);
 }
 
 public class DatabaseMetadata
diff --git a/src/PlanViewer.Core/Services/QueryStoreService.cs b/src/PlanViewer.Core/Services/QueryStoreService.cs
index aeb78f5..4b0d51e 100644
--- a/src/PlanViewer.Core/Services/QueryStoreService.cs
+++ b/src/PlanViewer.Core/Services/QueryStoreService.cs
@@ -427,6 +427,36 @@ GROUP BY DATEADD(HOUR, DATEDIFF(HOUR, 0, rsi.start_time), 0)
 
     // ── Wait stats ─────────────────────────────────────────────────────────
 
+    /// <summary>
+    /// Checks whether Query Store wait stats capture is enabled for the connected database.
+    /// Returns false on SQL Server 2016 (where the option doesn't exist) or when capture is OFF.
+    /// </summary>
+    public static async Task<bool> IsWaitStatsCaptureEnabledAsync(
+        string connectionString, CancellationToken ct = default)
+    {
+        const string sql = @"
+SET TRANSACTION ISOLATION LEVEL READ UNCOMMITTED;
+SELECT CASE
+    WHEN EXISTS (
+        SELECT 1 FROM sys.database_query_store_options
+        WHERE wait_stats_capture_mode_desc = 'ON'
+    ) THEN 1 ELSE 0 END;";
+
+        try
+        {
+            await using var conn = new SqlConnection(connectionString);
+            await conn.OpenAsync(ct);
+            await using var cmd = new SqlCommand(sql, conn) { CommandTimeout = 10 };
+            var result = await cmd.ExecuteScalarAsync(ct);
+            return result is int i && i == 1;
+        }
+        catch
+        {
+            // Column doesn't exist on SQL 2016, or query store not enabled
+            return false;
+        }
+    }
+
     // Excluded: 11 = Idle, 18 = User Wait
     private const string WaitCategoryExclusion = "AND ws.wait_category NOT IN (11, 18)";
 

From 7e906f2d40644a1270e29c8ea332df4433e66a76 Mon Sep 17 00:00:00 2001
From: Erik Darling <2136037+erikdarlingdata@users.noreply.github.com>
Date: Wed, 25 Mar 2026 09:13:47 -0400
Subject: [PATCH 14/31] Improve Query Store grid query performance (#143)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Three changes from community feedback (41s → 3s on slow machines):

1. Remove WHERE p.query_plan IS NOT NULL from the ranked CTE — this
   predicate on nvarchar(max) causes an expensive implicit conversion
   scan. NULL plans are already handled by the C# reader (skip row).

2. Two-phase approach: materialize TOP N into #top_plans first using
   only numeric columns, then join to query_text/plan XML tables for
   just the winners. Avoids dragging expensive nvarchar(max) columns
   through the entire CTE evaluation.

3. Remove OPTION (LOOP JOIN) — reported 3x faster without it on
   multiple test environments.

Tested on SQL2022 with PerformanceMonitor Query Store data.

Closes #143

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
---
 .../Services/QueryStoreService.cs             | 64 +++++++++++++------
 1 file changed, 43 insertions(+), 21 deletions(-)

diff --git a/src/PlanViewer.Core/Services/QueryStoreService.cs b/src/PlanViewer.Core/Services/QueryStoreService.cs
index 4b0d51e..a04ebd1 100644
--- a/src/PlanViewer.Core/Services/QueryStoreService.cs
+++ b/src/PlanViewer.Core/Services/QueryStoreService.cs
@@ -143,15 +143,17 @@ public static async Task<List<QueryStorePlan>> FetchTopPlansAsync(
             parameters.Add(new SqlParameter("@hoursBack", hoursBack));
         }
 
-        // 1. plan_agg: aggregate runtime_stats by plan_id only (cheapest grouping,
-        //    avoids joining query_text for the entire dataset).
-        // 2. ranked: join the small aggregated result to plan to get query_id,
-        //    ROW_NUMBER to pick best plan per query.
-        // 3. Final SELECT: TOP N, then join query_text + plan XML only for winners.
-        //    Filter clauses applied here where q/p are available.
+        // Two-phase approach for performance (see GitHub issue #143):
+        // Phase 1: Aggregate + rank into #top_plans using only numeric columns.
+        //   - No join to query_text/plan XML (expensive nvarchar(max) columns).
+        //   - Removed WHERE p.query_plan IS NOT NULL (implicit conversion on nvarchar(max)).
+        //   - Removed OPTION (LOOP JOIN) — hurts more than it helps in testing.
+        // Phase 2: Join only the TOP N winners to text/plan/metadata tables.
         var sql = $@"
 SET TRANSACTION ISOLATION LEVEL READ UNCOMMITTED;
 
+DROP TABLE IF EXISTS #top_plans;
+
 WITH plan_agg AS (
     SELECT
         rs.plan_id,
@@ -195,13 +197,10 @@ CASE WHEN pa.total_executions > 0
         ROW_NUMBER() OVER (PARTITION BY p.query_id ORDER BY {orderClause} DESC) AS rn
     FROM plan_agg pa
     JOIN sys.query_store_plan p ON pa.plan_id = p.plan_id
-    WHERE p.query_plan IS NOT NULL
 )
 SELECT TOP ({topN})
     r.query_id,
     r.plan_id,
-    qt.query_sql_text,
-    CAST(p.query_plan AS nvarchar(max)) AS query_plan,
     r.avg_cpu_us,
     r.avg_duration_us,
     r.avg_reads,
@@ -209,13 +208,37 @@ SELECT TOP ({topN})
     r.avg_physical_reads,
     r.avg_memory_pages,
     r.total_executions,
-    CAST(r.total_cpu_us AS bigint),
-    CAST(r.total_duration_us AS bigint),
-    CAST(r.total_reads AS bigint),
-    CAST(r.total_writes AS bigint),
-    CAST(r.total_physical_reads AS bigint),
-    CAST(r.total_memory_pages AS bigint),
-    r.last_execution_time,
+    CAST(r.total_cpu_us AS bigint) AS total_cpu_us,
+    CAST(r.total_duration_us AS bigint) AS total_duration_us,
+    CAST(r.total_reads AS bigint) AS total_reads,
+    CAST(r.total_writes AS bigint) AS total_writes,
+    CAST(r.total_physical_reads AS bigint) AS total_physical_reads,
+    CAST(r.total_memory_pages AS bigint) AS total_memory_pages,
+    r.last_execution_time
+INTO #top_plans
+FROM ranked r
+WHERE 1 = 1 {rnClause}
+ORDER BY {outerOrder} DESC;
+
+SELECT
+    tp.query_id,
+    tp.plan_id,
+    qt.query_sql_text,
+    CAST(p.query_plan AS nvarchar(max)) AS query_plan,
+    tp.avg_cpu_us,
+    tp.avg_duration_us,
+    tp.avg_reads,
+    tp.avg_writes,
+    tp.avg_physical_reads,
+    tp.avg_memory_pages,
+    tp.total_executions,
+    tp.total_cpu_us,
+    tp.total_duration_us,
+    tp.total_reads,
+    tp.total_writes,
+    tp.total_physical_reads,
+    tp.total_memory_pages,
+    tp.last_execution_time,
     CONVERT(varchar(18), q.query_hash, 1),
     CONVERT(varchar(18), p.query_plan_hash, 1),
     CASE
@@ -223,13 +246,12 @@ WHEN q.object_id <> 0
         THEN OBJECT_SCHEMA_NAME(q.object_id) + N'.' + OBJECT_NAME(q.object_id)
         ELSE N''
     END
-FROM ranked r
-JOIN sys.query_store_plan p ON r.plan_id = p.plan_id
+FROM #top_plans tp
+JOIN sys.query_store_plan p ON tp.plan_id = p.plan_id
 JOIN sys.query_store_query q ON p.query_id = q.query_id
 JOIN sys.query_store_query_text qt ON q.query_text_id = qt.query_text_id
-WHERE 1 = 1 {rnClause}{filterSql}
-ORDER BY {outerOrder} DESC
-OPTION (LOOP JOIN);";
+WHERE 1 = 1{filterSql}
+ORDER BY {outerOrder} DESC;";
 
         var plans = new List<QueryStorePlan>();
 

From c72125a0bf46c011f4087252632077810b904b5c Mon Sep 17 00:00:00 2001
From: Erik Darling <2136037+erikdarlingdata@users.noreply.github.com>
Date: Wed, 25 Mar 2026 11:38:35 -0400
Subject: [PATCH 15/31] Rewrite Query Store grid query using sp_QuickieStore
 patterns (#143)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Multi-phase materialization approach for drastically better performance
on large Query Store datasets:

Phase 1: Pre-filter matching interval IDs into #intervals (clustered PK).
  All subsequent phases use EXISTS semi-join against this tiny table
  instead of re-evaluating the time predicate.

Phase 2: Aggregate runtime_stats by plan_id into #plan_stats (clustered
  PK on plan_id). Uses EXISTS against #intervals — semi-join avoids
  materializing the full interval join.

Phase 3: Rank best plan per query_id, materialize TOP N into #top_plans.
  Still no nvarchar(max) columns touched.

Phase 4: Hydrate only the TOP N winners with text, plan XML, and metadata.
  Uses TRY_CONVERT for safe plan XML handling.

Additional improvements:
- Both time filter paths now use rsi.start_time (indexed) instead of
  rs.last_execution_time (requires scanning all runtime_stats rows)
- OPTION(RECOMPILE) on aggregation phases prevents parameter sniffing
  on date range parameters producing stale plans
- Clustered PKs on temp tables enable index seeks in subsequent joins

Tested on SQL2022: ~22ms total for all 4 phases (24 intervals, 546 plans).

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
---
 .../Services/QueryStoreService.cs             | 179 +++++++++++-------
 1 file changed, 112 insertions(+), 67 deletions(-)

diff --git a/src/PlanViewer.Core/Services/QueryStoreService.cs b/src/PlanViewer.Core/Services/QueryStoreService.cs
index a04ebd1..6fcbb15 100644
--- a/src/PlanViewer.Core/Services/QueryStoreService.cs
+++ b/src/PlanViewer.Core/Services/QueryStoreService.cs
@@ -52,18 +52,18 @@ public static async Task<List<QueryStorePlan>> FetchTopPlansAsync(
         var key = orderBy.ToLowerInvariant();
 
         // ROW_NUMBER order: pick the "best" plan per query_id.
-        // References pre-aggregated columns from plan_agg CTE.
+        // References pre-aggregated columns from #plan_stats temp table.
         // avg- variants still rank by total CPU (most impactful plan).
         var orderClause = key switch
         {
-            "cpu"              => "pa.total_cpu_us",
-            "duration"         => "pa.total_duration_us",
-            "reads"            => "pa.total_reads",
-            "writes"           => "pa.total_writes",
-            "physical-reads"   => "pa.total_physical_reads",
-            "memory"           => "pa.total_memory_pages",
-            "executions"       => "pa.total_executions",
-            _ => "pa.total_cpu_us"
+            "cpu"              => "ps.total_cpu_us",
+            "duration"         => "ps.total_duration_us",
+            "reads"            => "ps.total_reads",
+            "writes"           => "ps.total_writes",
+            "physical-reads"   => "ps.total_physical_reads",
+            "memory"           => "ps.total_memory_pages",
+            "executions"       => "ps.total_executions",
+            _ => "ps.total_cpu_us"
         };
 
         // Final ORDER BY — either a total or avg column from ranked CTE.
@@ -96,7 +96,7 @@ public static async Task<List<QueryStorePlan>> FetchTopPlansAsync(
         }
         if (filter?.PlanId != null)
         {
-            filterClauses.Add("AND r.plan_id = @filterPlanId");
+            filterClauses.Add("AND tp.plan_id = @filterPlanId");
             parameters.Add(new SqlParameter("@filterPlanId", filter.PlanId.Value));
         }
         if (!string.IsNullOrWhiteSpace(filter?.QueryHash))
@@ -129,74 +129,118 @@ public static async Task<List<QueryStorePlan>> FetchTopPlansAsync(
             ? "\n" + string.Join("\n", filterClauses)
             : "";
 
-        // Time-range filter: prefer explicit start/end over hoursBack
-        string timeWhereClause;
+        // Time-range filter: always filter on interval start_time (indexed).
+        // The hoursBack fallback also uses interval start_time instead of
+        // rs.last_execution_time to avoid scanning all of runtime_stats.
+        string intervalWhereClause;
         if (startUtc.HasValue && endUtc.HasValue)
         {
-            timeWhereClause = "WHERE rsi.start_time >= @rangeStart AND rsi.end_time < @rangeEnd";
+            intervalWhereClause = "WHERE rsi.start_time >= @rangeStart AND rsi.start_time < @rangeEnd";
             parameters.Add(new SqlParameter("@rangeStart", startUtc.Value));
             parameters.Add(new SqlParameter("@rangeEnd", endUtc.Value));
         }
         else
         {
-            timeWhereClause = "WHERE rs.last_execution_time >= DATEADD(HOUR, -@hoursBack, GETUTCDATE())";
+            intervalWhereClause = "WHERE rsi.start_time >= DATEADD(HOUR, -@hoursBack, GETUTCDATE())";
             parameters.Add(new SqlParameter("@hoursBack", hoursBack));
         }
 
-        // Two-phase approach for performance (see GitHub issue #143):
-        // Phase 1: Aggregate + rank into #top_plans using only numeric columns.
-        //   - No join to query_text/plan XML (expensive nvarchar(max) columns).
-        //   - Removed WHERE p.query_plan IS NOT NULL (implicit conversion on nvarchar(max)).
-        //   - Removed OPTION (LOOP JOIN) — hurts more than it helps in testing.
-        // Phase 2: Join only the TOP N winners to text/plan/metadata tables.
+        // Multi-phase approach modeled on sp_QuickieStore (see GitHub issue #143):
+        //
+        // Phase 1: Materialize matching interval IDs into #intervals (tiny table,
+        //          clustered PK). All subsequent phases reference this via EXISTS
+        //          semi-join instead of re-evaluating the time predicate.
+        //
+        // Phase 2: Aggregate runtime_stats by plan_id into #plan_stats (clustered
+        //          PK on plan_id). Uses EXISTS against #intervals — no direct join
+        //          to the interval table, letting the optimizer use a semi-join.
+        //
+        // Phase 3: Rank plans per query_id, pick best per query, materialize TOP N
+        //          into #top_plans. Still no nvarchar(max) columns.
+        //
+        // Phase 4: Final SELECT — join only the TOP N winners to query_text, plan
+        //          XML, and query metadata. Uses OUTER APPLY + TRY_CONVERT for
+        //          safe plan XML retrieval.
+        //
+        // OPTION (RECOMPILE) on aggregation phases prevents parameter sniffing on
+        // date range parameters producing bad plans for different time windows.
         var sql = $@"
 SET TRANSACTION ISOLATION LEVEL READ UNCOMMITTED;
 
-DROP TABLE IF EXISTS #top_plans;
+/* Phase 1: Pre-filter matching interval IDs */
+DROP TABLE IF EXISTS #intervals;
+CREATE TABLE #intervals (
+    runtime_stats_interval_id bigint NOT NULL PRIMARY KEY CLUSTERED
+);
+INSERT INTO #intervals (runtime_stats_interval_id)
+SELECT rsi.runtime_stats_interval_id
+FROM sys.query_store_runtime_stats_interval AS rsi
+{intervalWhereClause}
+OPTION (RECOMPILE);
+
+/* Phase 2: Aggregate runtime stats by plan_id */
+DROP TABLE IF EXISTS #plan_stats;
+CREATE TABLE #plan_stats (
+    plan_id bigint NOT NULL PRIMARY KEY CLUSTERED,
+    total_cpu_us float NOT NULL,
+    total_duration_us float NOT NULL,
+    total_reads float NOT NULL,
+    total_writes float NOT NULL,
+    total_physical_reads float NOT NULL,
+    total_memory_pages float NOT NULL,
+    total_executions bigint NOT NULL,
+    last_execution_time datetimeoffset NOT NULL
+);
+INSERT INTO #plan_stats
+SELECT
+    rs.plan_id,
+    SUM(rs.avg_cpu_time * rs.count_executions),
+    SUM(rs.avg_duration * rs.count_executions),
+    SUM(rs.avg_logical_io_reads * rs.count_executions),
+    SUM(rs.avg_logical_io_writes * rs.count_executions),
+    SUM(rs.avg_physical_io_reads * rs.count_executions),
+    SUM(rs.avg_query_max_used_memory * rs.count_executions),
+    SUM(rs.count_executions),
+    MAX(rs.last_execution_time)
+FROM sys.query_store_runtime_stats AS rs
+WHERE EXISTS
+(
+    SELECT 1
+    FROM #intervals AS i
+    WHERE i.runtime_stats_interval_id = rs.runtime_stats_interval_id
+)
+GROUP BY rs.plan_id
+OPTION (RECOMPILE);
 
-WITH plan_agg AS (
-    SELECT
-        rs.plan_id,
-        SUM(rs.avg_cpu_time * rs.count_executions) AS total_cpu_us,
-        SUM(rs.avg_duration * rs.count_executions) AS total_duration_us,
-        SUM(rs.avg_logical_io_reads * rs.count_executions) AS total_reads,
-        SUM(rs.avg_logical_io_writes * rs.count_executions) AS total_writes,
-        SUM(rs.avg_physical_io_reads * rs.count_executions) AS total_physical_reads,
-        SUM(rs.avg_query_max_used_memory * rs.count_executions) AS total_memory_pages,
-        SUM(rs.count_executions) AS total_executions,
-        MAX(rs.last_execution_time) AS last_execution_time
-    FROM sys.query_store_runtime_stats rs
-    JOIN sys.query_store_runtime_stats_interval rsi on rs.runtime_stats_interval_id=rsi.runtime_stats_interval_id
-    {timeWhereClause}
-    GROUP BY rs.plan_id
-),
-ranked AS (
+/* Phase 3: Rank best plan per query, materialize TOP N */
+DROP TABLE IF EXISTS #top_plans;
+WITH ranked AS (
     SELECT
         p.query_id,
-        pa.plan_id,
-        pa.total_cpu_us,
-        pa.total_duration_us,
-        pa.total_reads,
-        pa.total_writes,
-        pa.total_physical_reads,
-        pa.total_memory_pages,
-        pa.total_executions,
-        pa.last_execution_time,
-        CASE WHEN pa.total_executions > 0
-             THEN pa.total_cpu_us / pa.total_executions ELSE 0 END AS avg_cpu_us,
-        CASE WHEN pa.total_executions > 0
-             THEN pa.total_duration_us / pa.total_executions ELSE 0 END AS avg_duration_us,
-        CASE WHEN pa.total_executions > 0
-             THEN pa.total_reads / pa.total_executions ELSE 0 END AS avg_reads,
-        CASE WHEN pa.total_executions > 0
-             THEN pa.total_writes / pa.total_executions ELSE 0 END AS avg_writes,
-        CASE WHEN pa.total_executions > 0
-             THEN pa.total_physical_reads / pa.total_executions ELSE 0 END AS avg_physical_reads,
-        CASE WHEN pa.total_executions > 0
-             THEN pa.total_memory_pages / pa.total_executions ELSE 0 END AS avg_memory_pages,
+        ps.plan_id,
+        ps.total_cpu_us,
+        ps.total_duration_us,
+        ps.total_reads,
+        ps.total_writes,
+        ps.total_physical_reads,
+        ps.total_memory_pages,
+        ps.total_executions,
+        ps.last_execution_time,
+        CASE WHEN ps.total_executions > 0
+             THEN ps.total_cpu_us / ps.total_executions ELSE 0 END AS avg_cpu_us,
+        CASE WHEN ps.total_executions > 0
+             THEN ps.total_duration_us / ps.total_executions ELSE 0 END AS avg_duration_us,
+        CASE WHEN ps.total_executions > 0
+             THEN ps.total_reads / ps.total_executions ELSE 0 END AS avg_reads,
+        CASE WHEN ps.total_executions > 0
+             THEN ps.total_writes / ps.total_executions ELSE 0 END AS avg_writes,
+        CASE WHEN ps.total_executions > 0
+             THEN ps.total_physical_reads / ps.total_executions ELSE 0 END AS avg_physical_reads,
+        CASE WHEN ps.total_executions > 0
+             THEN ps.total_memory_pages / ps.total_executions ELSE 0 END AS avg_memory_pages,
         ROW_NUMBER() OVER (PARTITION BY p.query_id ORDER BY {orderClause} DESC) AS rn
-    FROM plan_agg pa
-    JOIN sys.query_store_plan p ON pa.plan_id = p.plan_id
+    FROM #plan_stats AS ps
+    JOIN sys.query_store_plan AS p ON ps.plan_id = p.plan_id
 )
 SELECT TOP ({topN})
     r.query_id,
@@ -216,15 +260,16 @@ SELECT TOP ({topN})
     CAST(r.total_memory_pages AS bigint) AS total_memory_pages,
     r.last_execution_time
 INTO #top_plans
-FROM ranked r
+FROM ranked AS r
 WHERE 1 = 1 {rnClause}
 ORDER BY {outerOrder} DESC;
 
+/* Phase 4: Hydrate winners with text, plan XML, and metadata */
 SELECT
     tp.query_id,
     tp.plan_id,
     qt.query_sql_text,
-    CAST(p.query_plan AS nvarchar(max)) AS query_plan,
+    TRY_CONVERT(nvarchar(max), p.query_plan) AS query_plan,
     tp.avg_cpu_us,
     tp.avg_duration_us,
     tp.avg_reads,
@@ -246,10 +291,10 @@ WHEN q.object_id <> 0
         THEN OBJECT_SCHEMA_NAME(q.object_id) + N'.' + OBJECT_NAME(q.object_id)
         ELSE N''
     END
-FROM #top_plans tp
-JOIN sys.query_store_plan p ON tp.plan_id = p.plan_id
-JOIN sys.query_store_query q ON p.query_id = q.query_id
-JOIN sys.query_store_query_text qt ON q.query_text_id = qt.query_text_id
+FROM #top_plans AS tp
+JOIN sys.query_store_plan AS p ON tp.plan_id = p.plan_id
+JOIN sys.query_store_query AS q ON p.query_id = q.query_id
+JOIN sys.query_store_query_text AS qt ON q.query_text_id = qt.query_text_id
 WHERE 1 = 1{filterSql}
 ORDER BY {outerOrder} DESC;";
 

From 1ad13d2f703561f6e72e46b6832e521e7294cf92 Mon Sep 17 00:00:00 2001
From: rferraton <16419423+rferraton@users.noreply.github.com>
Date: Wed, 25 Mar 2026 15:10:48 +0100
Subject: [PATCH 16/31] adding a progress status bar for fetching grid data in
 the querystore plan grid and try improve performance of querystore grid fetch

---
 .../Controls/QueryStoreGridControl.axaml      | 17 +++++-
 .../Controls/QueryStoreGridControl.axaml.cs   | 54 ++++++++++++++++---
 .../Controls/WaitStatsProfileControl.axaml    | 11 ++++
 .../Controls/WaitStatsProfileControl.axaml.cs |  5 ++
 4 files changed, 77 insertions(+), 10 deletions(-)

diff --git a/src/PlanViewer.App/Controls/QueryStoreGridControl.axaml b/src/PlanViewer.App/Controls/QueryStoreGridControl.axaml
index d5a1e16..758b21f 100644
--- a/src/PlanViewer.App/Controls/QueryStoreGridControl.axaml
+++ b/src/PlanViewer.App/Controls/QueryStoreGridControl.axaml
@@ -109,8 +109,9 @@
             </StackPanel>
         </Border>
 
-        <!-- DataGrid -->
-        <DataGrid Grid.Row="2" x:Name="ResultsGrid"
+        <!-- DataGrid + loading overlay -->
+        <Grid Grid.Row="2">
+        <DataGrid x:Name="ResultsGrid"
                   AutoGenerateColumns="False"
                   CanUserSortColumns="True"
                   CanUserReorderColumns="True"
@@ -318,5 +319,17 @@
                 </DataGridTemplateColumn>
             </DataGrid.Columns>
         </DataGrid>
+        <!-- Loading overlay -->
+        <Border x:Name="GridLoadingOverlay" IsVisible="False"
+                Background="#80000000" CornerRadius="0"
+                HorizontalAlignment="Stretch" VerticalAlignment="Stretch">
+            <StackPanel HorizontalAlignment="Center" VerticalAlignment="Center" Spacing="8">
+                <ProgressBar IsIndeterminate="True" Width="200" Height="4"/>
+                <TextBlock x:Name="GridLoadingText" Text="Fetching plans..."
+                           FontSize="12" HorizontalAlignment="Center"
+                           Foreground="{DynamicResource ForegroundBrush}"/>
+            </StackPanel>
+        </Border>
+        </Grid>
     </Grid>
 </UserControl>
diff --git a/src/PlanViewer.App/Controls/QueryStoreGridControl.axaml.cs b/src/PlanViewer.App/Controls/QueryStoreGridControl.axaml.cs
index a977d9e..595acd6 100644
--- a/src/PlanViewer.App/Controls/QueryStoreGridControl.axaml.cs
+++ b/src/PlanViewer.App/Controls/QueryStoreGridControl.axaml.cs
@@ -184,15 +184,24 @@ private async System.Threading.Tasks.Task FetchPlansForRangeAsync()
         FetchButton.IsEnabled = false;
         LoadButton.IsEnabled = false;
         StatusText.Text = "Fetching plans...";
+        GridLoadingOverlay.IsVisible = true;
+        GridLoadingText.Text = "Fetching plans...";
         _rows.Clear();
         _filteredRows.Clear();
 
+        // Start global + ribbon wait stats early (they don't depend on plan results)
+        System.Threading.Tasks.Task? globalWaitTask = null;
+        if (_waitStatsSupported && _waitStatsEnabled && _slicerStartUtc.HasValue && _slicerEndUtc.HasValue)
+            globalWaitTask = FetchGlobalWaitStatsOnlyAsync(_slicerStartUtc.Value, _slicerEndUtc.Value, ct);
+
         try
         {
             var plans = await QueryStoreService.FetchTopPlansAsync(
                 _connectionString, topN, orderBy, ct: ct,
                 startUtc: _slicerStartUtc, endUtc: _slicerEndUtc);
 
+            GridLoadingOverlay.IsVisible = false;
+
             if (plans.Count == 0)
             {
                 StatusText.Text = "No Query Store data found for the selected range.";
@@ -206,9 +215,9 @@ private async System.Threading.Tasks.Task FetchPlansForRangeAsync()
             LoadButton.IsEnabled = true;
             SelectToggleButton.Content = "Select None";
 
-            // Fetch wait stats in parallel (non-blocking for plan display)
+            // Fetch per-plan wait stats after grid is populated (needs plan IDs)
             if (_waitStatsSupported && _waitStatsEnabled && _slicerStartUtc.HasValue && _slicerEndUtc.HasValue)
-                _ = FetchWaitStatsAsync(_slicerStartUtc.Value, _slicerEndUtc.Value, ct);
+                _ = FetchPerPlanWaitStatsAsync(_slicerStartUtc.Value, _slicerEndUtc.Value, ct);
         }
         catch (OperationCanceledException)
         {
@@ -220,6 +229,7 @@ private async System.Threading.Tasks.Task FetchPlansForRangeAsync()
         }
         finally
         {
+            GridLoadingOverlay.IsVisible = false;
             FetchButton.IsEnabled = true;
         }
     }
@@ -384,18 +394,21 @@ private async void OnTimeRangeChanged(object? sender, TimeRangeChangedEventArgs
 
     // ── Wait stats ─────────────────────────────────────────────────────────
 
-    private async System.Threading.Tasks.Task FetchWaitStatsAsync(
+    /// <summary>
+    /// Fetches global bar + ribbon wait stats (independent of grid plan IDs).
+    /// Shows loading indicator on the wait stats panel.
+    /// </summary>
+    private async System.Threading.Tasks.Task FetchGlobalWaitStatsOnlyAsync(
         DateTime startUtc, DateTime endUtc, CancellationToken ct)
     {
+        WaitStatsProfile.SetLoading(true);
         try
         {
             // Global (bar)
             var globalWaits = await QueryStoreService.FetchGlobalWaitStatsAsync(
                 _connectionString, startUtc, endUtc, ct);
-            foreach (var w in globalWaits)
             if (ct.IsCancellationRequested) { return; }
             var globalProfile = QueryStoreService.BuildWaitProfile(globalWaits);
-            foreach (var s in globalProfile.Segments)
             WaitStatsProfile.SetBarProfile(globalProfile);
 
             // Global (ribbon) — fetched lazily, data ready for toggle
@@ -403,10 +416,25 @@ private async System.Threading.Tasks.Task FetchWaitStatsAsync(
                 _connectionString, startUtc, endUtc, ct);
             if (ct.IsCancellationRequested) { return; }
             WaitStatsProfile.SetRibbonData(ribbonData);
+        }
+        catch (Exception ex) { Debug.WriteLine($"[WAITSTATS] FetchGlobalWaitStatsOnlyAsync EXCEPTION: {ex}"); }
+        finally
+        {
+            WaitStatsProfile.SetLoading(false);
+        }
+    }
 
-            // Per-plan
+    /// <summary>
+    /// Fetches per-plan wait stats for the plan IDs currently in the grid.
+    /// </summary>
+    private async System.Threading.Tasks.Task FetchPerPlanWaitStatsAsync(
+        DateTime startUtc, DateTime endUtc, CancellationToken ct)
+    {
+        try
+        {
+            var visiblePlanIds = _rows.Select(r => r.PlanId).ToList();
             var planWaits = await QueryStoreService.FetchPlanWaitStatsAsync(
-                _connectionString, startUtc, endUtc, ct);
+                _connectionString, startUtc, endUtc, visiblePlanIds, ct);
             if (ct.IsCancellationRequested) { return; }
 
             var byPlan = planWaits
@@ -422,7 +450,17 @@ private async System.Threading.Tasks.Task FetchWaitStatsAsync(
             }
             UpdateWaitBarMode();
         }
-        catch (Exception ex) { Debug.WriteLine($"[WAITSTATS] FetchWaitStatsAsync EXCEPTION: {ex}"); }
+        catch (Exception ex) { Debug.WriteLine($"[WAITSTATS] FetchPerPlanWaitStatsAsync EXCEPTION: {ex}"); }
+    }
+
+    /// <summary>
+    /// Full wait stats fetch (global + ribbon + per-plan). Used when re-expanding the wait stats panel.
+    /// </summary>
+    private async System.Threading.Tasks.Task FetchWaitStatsAsync(
+        DateTime startUtc, DateTime endUtc, CancellationToken ct)
+    {
+        await FetchGlobalWaitStatsOnlyAsync(startUtc, endUtc, ct);
+        await FetchPerPlanWaitStatsAsync(startUtc, endUtc, ct);
     }
 
     private void OnWaitCategoryClicked(object? sender, string category)
diff --git a/src/PlanViewer.App/Controls/WaitStatsProfileControl.axaml b/src/PlanViewer.App/Controls/WaitStatsProfileControl.axaml
index 0ff8f94..66bd23b 100644
--- a/src/PlanViewer.App/Controls/WaitStatsProfileControl.axaml
+++ b/src/PlanViewer.App/Controls/WaitStatsProfileControl.axaml
@@ -43,6 +43,17 @@
                     <DataGridTextColumn Header="% of Total" Binding="{ReflectionBinding RatioText}" Width="Auto"/>
                 </DataGrid.Columns>
             </DataGrid>
+            <!-- Loading overlay -->
+            <Border x:Name="WaitLoadingOverlay" IsVisible="False"
+                    Background="#80000000" CornerRadius="0"
+                    HorizontalAlignment="Stretch" VerticalAlignment="Stretch">
+                <StackPanel HorizontalAlignment="Center" VerticalAlignment="Center" Spacing="6">
+                    <ProgressBar IsIndeterminate="True" Width="140" Height="3"/>
+                    <TextBlock Text="Loading wait stats..."
+                               FontSize="11" HorizontalAlignment="Center"
+                               Foreground="{DynamicResource ForegroundBrush}"/>
+                </StackPanel>
+            </Border>
         </Grid>
     </Grid>
 </UserControl>
diff --git a/src/PlanViewer.App/Controls/WaitStatsProfileControl.axaml.cs b/src/PlanViewer.App/Controls/WaitStatsProfileControl.axaml.cs
index b36dbee..f25a39c 100644
--- a/src/PlanViewer.App/Controls/WaitStatsProfileControl.axaml.cs
+++ b/src/PlanViewer.App/Controls/WaitStatsProfileControl.axaml.cs
@@ -74,6 +74,11 @@ public void Collapse()
         CollapsedChanged?.Invoke(this, true);
     }
 
+    public void SetLoading(bool isLoading)
+    {
+        WaitLoadingOverlay.IsVisible = isLoading;
+    }
+
     private void ToggleChart_Click(object? sender, RoutedEventArgs e)
     {
         // Cycle: Bar -> Ribbon -> Bar (skip table; table has its own button)

From 7b9346c377c6999c96ffbc09dc1bd2e65b0bddba Mon Sep 17 00:00:00 2001
From: rferraton <16419423+rferraton@users.noreply.github.com>
Date: Wed, 25 Mar 2026 17:45:40 +0100
Subject: [PATCH 17/31] fix issue with lateral handled of the time range
 selector

---
 .../Controls/TimeRangeSlicerControl.axaml.cs  | 25 +++++++++++++++++++
 1 file changed, 25 insertions(+)

diff --git a/src/PlanViewer.App/Controls/TimeRangeSlicerControl.axaml.cs b/src/PlanViewer.App/Controls/TimeRangeSlicerControl.axaml.cs
index 2b4912c..29bec9a 100644
--- a/src/PlanViewer.App/Controls/TimeRangeSlicerControl.axaml.cs
+++ b/src/PlanViewer.App/Controls/TimeRangeSlicerControl.axaml.cs
@@ -532,6 +532,31 @@ public void Redraw()
             Canvas.SetTop(dot,  dotY - DotR);
             SlicerCanvas.Children.Add(dot);
         }
+
+        // ── Handle hit zones ──────────────────────────────────────────────
+        // Drawn last so they sit above per-bucket tooltip rectangles and
+        // receive pointer events in the handle areas without interference.
+        var leftHitZone = new Rectangle
+        {
+            Width  = HandleGripWidthPx * 2,
+            Height = h,
+            Fill   = Brushes.Transparent,
+            Cursor = CursorSizeWE,
+        };
+        Canvas.SetLeft(leftHitZone, selLeft - HandleGripWidthPx);
+        Canvas.SetTop(leftHitZone, 0);
+        SlicerCanvas.Children.Add(leftHitZone);
+
+        var rightHitZone = new Rectangle
+        {
+            Width  = HandleGripWidthPx * 2,
+            Height = h,
+            Fill   = Brushes.Transparent,
+            Cursor = CursorSizeWE,
+        };
+        Canvas.SetLeft(rightHitZone, selRight - HandleGripWidthPx);
+        Canvas.SetTop(rightHitZone, 0);
+        SlicerCanvas.Children.Add(rightHitZone);
     }
 
     private void DrawHandle(double x, double canvasHeight, IBrush brush)

From 46fdaa835b6d9c088faadf35a58e951279ecf358 Mon Sep 17 00:00:00 2001
From: rferraton <16419423+rferraton@users.noreply.github.com>
Date: Thu, 26 Mar 2026 22:05:45 +0100
Subject: [PATCH 18/31] Add planIds filter to FetchPlanWaitStatsAsync

FetchPlanWaitStatsAsync now accepts an optional planIds parameter. When provided, the method creates a temp table and filters results to only those plan IDs for efficient querying. SQL construction and connection logic were refactored to support this feature.
---
 .../Services/QueryStoreService.cs             | 39 ++++++++++++++++---
 1 file changed, 34 insertions(+), 5 deletions(-)

diff --git a/src/PlanViewer.Core/Services/QueryStoreService.cs b/src/PlanViewer.Core/Services/QueryStoreService.cs
index 6fcbb15..bde7417 100644
--- a/src/PlanViewer.Core/Services/QueryStoreService.cs
+++ b/src/PlanViewer.Core/Services/QueryStoreService.cs
@@ -575,12 +575,44 @@ JOIN sys.query_store_runtime_stats_interval rsi
     /// WaitRatio = SUM(total_query_wait_time_ms) / SUM(avg_duration * count_executions).
     /// This differs from the global/hourly WTR (which divides by wall-clock interval) because
     /// at plan level we measure what fraction of actual execution time was spent waiting.
+    /// When <paramref name="planIds"/> is provided, only those plan IDs are queried (via temp table).
     /// </summary>
     public static async Task<List<(long PlanId, WaitCategoryTotal Wait)>> FetchPlanWaitStatsAsync(
         string connectionString, DateTime startUtc, DateTime endUtc,
+        IEnumerable<long>? planIds = null,
         CancellationToken ct = default)
     {
-        const string sql = @"
+        var rows = new List<(long, WaitCategoryTotal)>();
+        await using var conn = new SqlConnection(connectionString);
+        await conn.OpenAsync(ct);
+
+        // When plan IDs are supplied, load them into a temp table for an efficient JOIN filter.
+        var planIdFilter = "";
+        if (planIds != null)
+        {
+            var ids = planIds.Distinct().ToList();
+            if (ids.Count == 0)
+                return rows;
+
+            const string createTmp = @"
+CREATE TABLE #plan_ids (plan_id bigint NOT NULL PRIMARY KEY);";
+            await using (var createCmd = new SqlCommand(createTmp, conn))
+                await createCmd.ExecuteNonQueryAsync(ct);
+
+            // Bulk-insert in batches of 1000 using VALUES rows
+            for (int i = 0; i < ids.Count; i += 1000)
+            {
+                var batch = ids.Skip(i).Take(1000);
+                var valuesSql = "INSERT INTO #plan_ids (plan_id) VALUES " +
+                    string.Join(",", batch.Select(id => $"({id})")) + ";";
+                await using var insertCmd = new SqlCommand(valuesSql, conn);
+                await insertCmd.ExecuteNonQueryAsync(ct);
+            }
+
+            planIdFilter = "\nAND   EXISTS (SELECT 1 FROM #plan_ids pid WHERE pid.plan_id = ws.plan_id)";
+        }
+
+        var sql = @"
 SET TRANSACTION ISOLATION LEVEL READ UNCOMMITTED;
 SELECT
     ws.plan_id,
@@ -594,13 +626,10 @@ JOIN sys.query_store_runtime_stats_interval rsi
 JOIN sys.query_store_runtime_stats rs ON rs.runtime_stats_interval_id = rsi.runtime_stats_interval_id and rs.plan_id=ws.plan_id
 WHERE rsi.start_time >= @start AND rsi.start_time < @end
 AND   ws.execution_type = 0
-" + WaitCategoryExclusion + @"
+" + WaitCategoryExclusion + planIdFilter + @"
 GROUP BY ws.plan_id, ws.wait_category, ws.wait_category_desc
 ORDER BY ws.plan_id, wait_ratio DESC;";
 
-        var rows = new List<(long, WaitCategoryTotal)>();
-        await using var conn = new SqlConnection(connectionString);
-        await conn.OpenAsync(ct);
         await using var cmd = new SqlCommand(sql, conn) { CommandTimeout = 120 };
         cmd.Parameters.Add(new SqlParameter("@start", startUtc));
         cmd.Parameters.Add(new SqlParameter("@end", endUtc));

From bcdb290c48f978aa68f870442532f0f5cf65e500 Mon Sep 17 00:00:00 2001
From: rferraton <16419423+rferraton@users.noreply.github.com>
Date: Thu, 26 Mar 2026 22:09:59 +0100
Subject: [PATCH 19/31] Fix bug due to alias on order by clause that are no
 more relevant and cause grid query crash

---
 .../Services/QueryStoreService.cs             | 44 +++++++++----------
 1 file changed, 22 insertions(+), 22 deletions(-)

diff --git a/src/PlanViewer.Core/Services/QueryStoreService.cs b/src/PlanViewer.Core/Services/QueryStoreService.cs
index bde7417..08b3624 100644
--- a/src/PlanViewer.Core/Services/QueryStoreService.cs
+++ b/src/PlanViewer.Core/Services/QueryStoreService.cs
@@ -56,33 +56,33 @@ public static async Task<List<QueryStorePlan>> FetchTopPlansAsync(
         // avg- variants still rank by total CPU (most impactful plan).
         var orderClause = key switch
         {
-            "cpu"              => "ps.total_cpu_us",
-            "duration"         => "ps.total_duration_us",
-            "reads"            => "ps.total_reads",
-            "writes"           => "ps.total_writes",
-            "physical-reads"   => "ps.total_physical_reads",
-            "memory"           => "ps.total_memory_pages",
-            "executions"       => "ps.total_executions",
-            _ => "ps.total_cpu_us"
+            "cpu"              => "total_cpu_us",
+            "duration"         => "total_duration_us",
+            "reads"            => "total_reads",
+            "writes"           => "total_writes",
+            "physical-reads"   => "total_physical_reads",
+            "memory"           => "total_memory_pages",
+            "executions"       => "total_executions",
+            _ => "total_cpu_us"
         };
 
         // Final ORDER BY — either a total or avg column from ranked CTE.
         var outerOrder = key switch
         {
-            "cpu"              => "r.total_cpu_us",
-            "duration"         => "r.total_duration_us",
-            "reads"            => "r.total_reads",
-            "writes"           => "r.total_writes",
-            "physical-reads"   => "r.total_physical_reads",
-            "memory"           => "r.total_memory_pages",
-            "executions"       => "r.total_executions",
-            "avg-cpu"          => "r.avg_cpu_us",
-            "avg-duration"     => "r.avg_duration_us",
-            "avg-reads"        => "r.avg_reads",
-            "avg-writes"       => "r.avg_writes",
-            "avg-physical-reads" => "r.avg_physical_reads",
-            "avg-memory"       => "r.avg_memory_pages",
-            _ => "r.total_cpu_us"
+            "cpu"                => "total_cpu_us",
+            "duration"           => "total_duration_us",
+            "reads"              => "total_reads",
+            "writes"             => "total_writes",
+            "physical-reads"     => "total_physical_reads",
+            "memory"             => "total_memory_pages",
+            "executions"         => "total_executions",
+            "avg-cpu"            => "avg_cpu_us",
+            "avg-duration"       => "avg_duration_us",
+            "avg-reads"          => "avg_reads",
+            "avg-writes"         => "avg_writes",
+            "avg-physical-reads" => "avg_physical_reads",
+            "avg-memory"         => "avg_memory_pages",
+            _ => "total_cpu_us"
         };
 
         // Build optional WHERE clauses from filter (parameterized for safety).

From 3a8422135880e880f1ca5fbe251352a60220d81c Mon Sep 17 00:00:00 2001
From: Erik Darling <2136037+erikdarlingdata@users.noreply.github.com>
Date: Thu, 26 Mar 2026 18:10:36 -0400
Subject: [PATCH 20/31] Post-merge cleanup for PR #148

- Fix fire-and-forget: globalWaitTask variable replaced with _ = discard
- Remove Debug.WriteLines from wait stats catch blocks, add separate
  OperationCanceledException handler for clean cancellation
- Remove unused System.Diagnostics using
- Restore ps. prefix on orderClause (used in ranked CTE where ps is
  the correct alias for #plan_stats)

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
---
 .../Controls/QueryStoreGridControl.axaml.cs      | 10 +++++-----
 .../Services/QueryStoreService.cs                | 16 ++++++++--------
 2 files changed, 13 insertions(+), 13 deletions(-)

diff --git a/src/PlanViewer.App/Controls/QueryStoreGridControl.axaml.cs b/src/PlanViewer.App/Controls/QueryStoreGridControl.axaml.cs
index 595acd6..f47df61 100644
--- a/src/PlanViewer.App/Controls/QueryStoreGridControl.axaml.cs
+++ b/src/PlanViewer.App/Controls/QueryStoreGridControl.axaml.cs
@@ -2,7 +2,6 @@
 using System.Collections.Generic;
 using System.Collections.ObjectModel;
 using System.ComponentModel;
-using System.Diagnostics;
 using System.Linq;
 using System.Runtime.CompilerServices;
 using System.Threading;
@@ -190,9 +189,8 @@ private async System.Threading.Tasks.Task FetchPlansForRangeAsync()
         _filteredRows.Clear();
 
         // Start global + ribbon wait stats early (they don't depend on plan results)
-        System.Threading.Tasks.Task? globalWaitTask = null;
         if (_waitStatsSupported && _waitStatsEnabled && _slicerStartUtc.HasValue && _slicerEndUtc.HasValue)
-            globalWaitTask = FetchGlobalWaitStatsOnlyAsync(_slicerStartUtc.Value, _slicerEndUtc.Value, ct);
+            _ = FetchGlobalWaitStatsOnlyAsync(_slicerStartUtc.Value, _slicerEndUtc.Value, ct);
 
         try
         {
@@ -417,7 +415,8 @@ private async System.Threading.Tasks.Task FetchGlobalWaitStatsOnlyAsync(
             if (ct.IsCancellationRequested) { return; }
             WaitStatsProfile.SetRibbonData(ribbonData);
         }
-        catch (Exception ex) { Debug.WriteLine($"[WAITSTATS] FetchGlobalWaitStatsOnlyAsync EXCEPTION: {ex}"); }
+        catch (OperationCanceledException) { }
+        catch (Exception) { }
         finally
         {
             WaitStatsProfile.SetLoading(false);
@@ -450,7 +449,8 @@ private async System.Threading.Tasks.Task FetchPerPlanWaitStatsAsync(
             }
             UpdateWaitBarMode();
         }
-        catch (Exception ex) { Debug.WriteLine($"[WAITSTATS] FetchPerPlanWaitStatsAsync EXCEPTION: {ex}"); }
+        catch (OperationCanceledException) { }
+        catch (Exception) { }
     }
 
     /// <summary>
diff --git a/src/PlanViewer.Core/Services/QueryStoreService.cs b/src/PlanViewer.Core/Services/QueryStoreService.cs
index 08b3624..7692981 100644
--- a/src/PlanViewer.Core/Services/QueryStoreService.cs
+++ b/src/PlanViewer.Core/Services/QueryStoreService.cs
@@ -56,14 +56,14 @@ public static async Task<List<QueryStorePlan>> FetchTopPlansAsync(
         // avg- variants still rank by total CPU (most impactful plan).
         var orderClause = key switch
         {
-            "cpu"              => "total_cpu_us",
-            "duration"         => "total_duration_us",
-            "reads"            => "total_reads",
-            "writes"           => "total_writes",
-            "physical-reads"   => "total_physical_reads",
-            "memory"           => "total_memory_pages",
-            "executions"       => "total_executions",
-            _ => "total_cpu_us"
+            "cpu"              => "ps.total_cpu_us",
+            "duration"         => "ps.total_duration_us",
+            "reads"            => "ps.total_reads",
+            "writes"           => "ps.total_writes",
+            "physical-reads"   => "ps.total_physical_reads",
+            "memory"           => "ps.total_memory_pages",
+            "executions"       => "ps.total_executions",
+            _ => "ps.total_cpu_us"
         };
 
         // Final ORDER BY — either a total or avg column from ranked CTE.

From fef35fbf4807452926a5da83337a8025c1de076e Mon Sep 17 00:00:00 2001
From: Erik Darling <2136037+erikdarlingdata@users.noreply.github.com>
Date: Thu, 26 Mar 2026 18:37:32 -0400
Subject: [PATCH 21/31] Fix search filter not applied and slicer reset on Fetch
 (#147)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Two regressions introduced in the time slicer PR (#114):

1. Search filter (module, query_id, etc.) was built via BuildSearchFilter()
   but never passed to FetchTopPlansAsync — the filter parameter was
   dropped when the call site switched to named parameters for startUtc/
   endUtc. Add filter: back to the call.

2. Clicking Fetch reloads the slicer via LoadTimeSlicerDataAsync, which
   calls LoadData without preserving the current selection. LoadData
   defaults to last 24h when no selection is provided, discarding the
   user's custom range. Pass the current _slicerStartUtc/_slicerEndUtc
   through to LoadData's selectionStart/selectionEnd parameters.

Fixes #147

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
---
 .../Controls/QueryStoreGridControl.axaml.cs        | 14 ++++++++------
 1 file changed, 8 insertions(+), 6 deletions(-)

diff --git a/src/PlanViewer.App/Controls/QueryStoreGridControl.axaml.cs b/src/PlanViewer.App/Controls/QueryStoreGridControl.axaml.cs
index f47df61..1b1f617 100644
--- a/src/PlanViewer.App/Controls/QueryStoreGridControl.axaml.cs
+++ b/src/PlanViewer.App/Controls/QueryStoreGridControl.axaml.cs
@@ -151,9 +151,9 @@ private async void Fetch_Click(object? sender, RoutedEventArgs e)
 
         try
         {
-            // Load slicer data first — LoadData sets a default 24h selection and
-            // fires RangeChanged which triggers FetchPlansForRangeAsync.
-            await LoadTimeSlicerDataAsync(orderBy, ct);
+            // Load slicer data, preserving the current selection if one exists.
+            // Without this, LoadData defaults to last 24h and the user's range is lost.
+            await LoadTimeSlicerDataAsync(orderBy, ct, _slicerStartUtc, _slicerEndUtc);
         }
         catch (OperationCanceledException)
         {
@@ -195,7 +195,7 @@ private async System.Threading.Tasks.Task FetchPlansForRangeAsync()
         try
         {
             var plans = await QueryStoreService.FetchTopPlansAsync(
-                _connectionString, topN, orderBy, ct: ct,
+                _connectionString, topN, orderBy, filter: filter, ct: ct,
                 startUtc: _slicerStartUtc, endUtc: _slicerEndUtc);
 
             GridLoadingOverlay.IsVisible = false;
@@ -363,7 +363,9 @@ private void ClearSearch_Click(object? sender, RoutedEventArgs e)
         SearchValueBox.Text = "";
     }
 
-    private async System.Threading.Tasks.Task LoadTimeSlicerDataAsync(string metric, CancellationToken ct)
+    private async System.Threading.Tasks.Task LoadTimeSlicerDataAsync(
+        string metric, CancellationToken ct,
+        DateTime? preserveStart = null, DateTime? preserveEnd = null)
     {
         try
         {
@@ -371,7 +373,7 @@ private async System.Threading.Tasks.Task LoadTimeSlicerDataAsync(string metric,
                 _connectionString, metric, _slicerDaysBack, ct);
             if (ct.IsCancellationRequested) return;
             if (sliceData.Count > 0)
-                TimeRangeSlicer.LoadData(sliceData, metric);
+                TimeRangeSlicer.LoadData(sliceData, metric, preserveStart, preserveEnd);
             else
                 StatusText.Text = "No time-slicer data available.";
         }

From 1196c6c668681c462bb0eda39965af93730d0e3a Mon Sep 17 00:00:00 2001
From: rferraton <16419423+rferraton@users.noreply.github.com>
Date: Fri, 27 Mar 2026 23:57:38 +0100
Subject: [PATCH 22/31] add quick filter buttons  and calendar for custom
 periode filter

---
 .../Controls/QueryStoreGridControl.axaml.cs   |   1 -
 .../Controls/TimeRangeSlicerControl.axaml     |  80 +++++++--
 .../Controls/TimeRangeSlicerControl.axaml.cs  | 153 +++++++++++++++---
 3 files changed, 205 insertions(+), 29 deletions(-)

diff --git a/src/PlanViewer.App/Controls/QueryStoreGridControl.axaml.cs b/src/PlanViewer.App/Controls/QueryStoreGridControl.axaml.cs
index 1b1f617..9451af1 100644
--- a/src/PlanViewer.App/Controls/QueryStoreGridControl.axaml.cs
+++ b/src/PlanViewer.App/Controls/QueryStoreGridControl.axaml.cs
@@ -64,7 +64,6 @@ public QueryStoreGridControl(ServerConnection serverConnection, ICredentialServi
         SetupColumnHeaders();
         PopulateDatabaseBox(databases, initialDatabase);
         TimeRangeSlicer.RangeChanged += OnTimeRangeChanged;
-        TimeRangeSlicer.IsExpanded = true;
 
         WaitStatsProfile.CategoryClicked += OnWaitCategoryClicked;
         WaitStatsProfile.CategoryDoubleClicked += OnWaitCategoryDoubleClicked;
diff --git a/src/PlanViewer.App/Controls/TimeRangeSlicerControl.axaml b/src/PlanViewer.App/Controls/TimeRangeSlicerControl.axaml
index ef28a01..6d02911 100644
--- a/src/PlanViewer.App/Controls/TimeRangeSlicerControl.axaml
+++ b/src/PlanViewer.App/Controls/TimeRangeSlicerControl.axaml
@@ -5,15 +5,10 @@
             BorderBrush="{DynamicResource SlicerBorderBrush}"
             BorderThickness="0,0,0,1">
         <Grid RowDefinitions="Auto,Auto">
-            <!-- Toggle header -->
-            <Button x:Name="ToggleButton" Grid.Row="0"
-                    Background="Transparent" BorderThickness="0"
-                    HorizontalAlignment="Stretch" HorizontalContentAlignment="Left"
-                    Padding="8,4" Cursor="Hand"
-                    Click="Toggle_Click">
-                <StackPanel Orientation="Horizontal" Spacing="6">
-                    <TextBlock x:Name="ToggleIcon" Text="▾" FontSize="12"
-                               Foreground="{DynamicResource SlicerToggleBrush}"
+            <!-- Header with range label button that opens date/time picker popup -->
+            <Panel Grid.Row="0">
+                <StackPanel Orientation="Horizontal" Spacing="6" Margin="8,4">
+                    <TextBlock Text="📅" FontSize="12"
                                VerticalAlignment="Center"/>
                     <TextBlock x:Name="ToggleLabel" Text="Time Range"
                                FontSize="11" FontWeight="SemiBold"
@@ -23,8 +18,73 @@
                                FontSize="11"
                                Foreground="{DynamicResource SlicerLabelBrush}"
                                VerticalAlignment="Center" Margin="12,0,0,0"/>
+                    <StackPanel x:Name="QuickFilterPanel" Orientation="Horizontal" Spacing="2" Margin="12,0,0,0" VerticalAlignment="Center">
+                        <Button x:Name="QF_3"      Content="3h"     Tag="3"   Click="QuickFilter_Click"   Height="20" MinWidth="32" Padding="6,0" FontSize="10" HorizontalContentAlignment="Center" VerticalContentAlignment="Center" Background="Transparent" BorderThickness="1" BorderBrush="{DynamicResource SlicerBorderBrush}" Foreground="{DynamicResource SlicerLabelBrush}" Cursor="Hand"/>
+                        <Button x:Name="QF_24"     Content="24h"    Tag="24"  Click="QuickFilter_Click"   Height="20" MinWidth="32" Padding="6,0" FontSize="10" HorizontalContentAlignment="Center" VerticalContentAlignment="Center" Background="Transparent" BorderThickness="1" BorderBrush="{DynamicResource SlicerBorderBrush}" Foreground="{DynamicResource SlicerLabelBrush}" Cursor="Hand"/>
+                        <Button x:Name="QF_168"    Content="7d"     Tag="168" Click="QuickFilter_Click"   Height="20" MinWidth="32" Padding="6,0" FontSize="10" HorizontalContentAlignment="Center" VerticalContentAlignment="Center" Background="Transparent" BorderThickness="1" BorderBrush="{DynamicResource SlicerBorderBrush}" Foreground="{DynamicResource SlicerLabelBrush}" Cursor="Hand"/>
+                        <Button x:Name="QF_720"    Content="30d"    Tag="720" Click="QuickFilter_Click"   Height="20" MinWidth="32" Padding="6,0" FontSize="10" HorizontalContentAlignment="Center" VerticalContentAlignment="Center" Background="Transparent" BorderThickness="1" BorderBrush="{DynamicResource SlicerBorderBrush}" Foreground="{DynamicResource SlicerLabelBrush}" Cursor="Hand"/>
+                        <Button x:Name="QF_Custom" Content="Custom" Tag="0"   Click="CustomFilter_Click"  Height="20" MinWidth="42" Padding="6,0" FontSize="10" HorizontalContentAlignment="Center" VerticalContentAlignment="Center" Background="Transparent" BorderThickness="1" BorderBrush="{DynamicResource SlicerBorderBrush}" Foreground="{DynamicResource SlicerLabelBrush}" Cursor="Hand"/>
+                    </StackPanel>
                 </StackPanel>
-            </Button>
+                <Popup x:Name="DateTimePopup"
+                       PlacementTarget="{Binding #QF_Custom}"
+                       Placement="BottomEdgeAlignedLeft"
+                       IsLightDismissEnabled="True"
+                       HorizontalOffset="0" VerticalOffset="2">
+                    <Border Background="{DynamicResource SlicerBackgroundBrush}"
+                            BorderBrush="{DynamicResource SlicerBorderBrush}"
+                            BorderThickness="1" CornerRadius="6"
+                            Padding="16" MinWidth="460">
+                        <StackPanel Spacing="12">
+                            <TextBlock Text="Custom Time Range"
+                                       FontSize="13" FontWeight="SemiBold"
+                                       Foreground="{DynamicResource ForegroundBrush}"/>
+                            <!-- Start date/time row -->
+                            <StackPanel Spacing="4">
+                                <TextBlock Text="Start" FontSize="11"
+                                           Foreground="{DynamicResource SlicerLabelBrush}"/>
+                                <StackPanel Orientation="Horizontal" Spacing="8">
+                                    <CalendarDatePicker x:Name="StartDatePicker"
+                                                        Width="180" Height="30" FontSize="12"
+                                                        DisplayDateStart="{x:Null}"
+                                                        DisplayDateEnd="{x:Null}"
+                                                        CustomDateFormatString="yyyy-MM-dd"
+                                                        SelectedDateFormat="Custom"/>
+                                    <TimePicker x:Name="StartTimePicker"
+                                                Width="120" Height="30" FontSize="12"
+                                                ClockIdentifier="24HourClock"
+                                                MinuteIncrement="15"/>
+                                </StackPanel>
+                            </StackPanel>
+                            <!-- End date/time row -->
+                            <StackPanel Spacing="4">
+                                <TextBlock Text="End" FontSize="11"
+                                           Foreground="{DynamicResource SlicerLabelBrush}"/>
+                                <StackPanel Orientation="Horizontal" Spacing="8">
+                                    <CalendarDatePicker x:Name="EndDatePicker"
+                                                        Width="180" Height="30" FontSize="12"
+                                                        DisplayDateStart="{x:Null}"
+                                                        DisplayDateEnd="{x:Null}"
+                                                        CustomDateFormatString="yyyy-MM-dd"
+                                                        SelectedDateFormat="Custom"/>
+                                    <TimePicker x:Name="EndTimePicker"
+                                                Width="120" Height="30" FontSize="12"
+                                                ClockIdentifier="24HourClock"
+                                                MinuteIncrement="15"/>
+                                </StackPanel>
+                            </StackPanel>
+                            <!-- Action buttons -->
+                            <StackPanel Orientation="Horizontal" HorizontalAlignment="Right" Spacing="8"
+                                        Margin="0,4,0,0">
+                                <Button Content="Cancel" Width="70" Height="28"
+                                        Click="PopupCancel_Click"/>
+                                <Button Content="Apply" Width="70" Height="28"
+                                        Click="PopupApply_Click"/>
+                            </StackPanel>
+                        </StackPanel>
+                    </Border>
+                </Popup>
+            </Panel>
             <!-- Slicer canvas area -->
             <Border x:Name="SlicerBorder" Grid.Row="1" Height="120" Margin="8,0,8,6"
                     Background="{DynamicResource SlicerBackgroundBrush}"
diff --git a/src/PlanViewer.App/Controls/TimeRangeSlicerControl.axaml.cs b/src/PlanViewer.App/Controls/TimeRangeSlicerControl.axaml.cs
index 29bec9a..bf313b3 100644
--- a/src/PlanViewer.App/Controls/TimeRangeSlicerControl.axaml.cs
+++ b/src/PlanViewer.App/Controls/TimeRangeSlicerControl.axaml.cs
@@ -17,7 +17,6 @@ public partial class TimeRangeSlicerControl : UserControl
 {
     private List<QueryStoreTimeSlice> _data = new();
     private string _metric = "cpu";
-    private bool _isExpanded = true;
 
     // Range as normalised [0..1] positions within _data
     private double _rangeStart;
@@ -25,7 +24,6 @@ public partial class TimeRangeSlicerControl : UserControl
 
     private const double HandleWidthPx = 8;
     private const double HandleGripWidthPx = 20; // extended hit-test area for easier grabbing
-    private const double MinIntervalHours = 3;
     private const double ChartPaddingTop = 16;
     private const double ChartPaddingBottom = 20;
     private const double MoveBarHeight = 14; // height of the draggable move bar at the top of the selection
@@ -59,6 +57,7 @@ private enum DragMode { None, MoveRange, DragStart, DragEnd, SelectRect }
     private double _selectRectCurrentX;  // canvas-x of current pointer during drag-select
 
     private int _hoveredIndex = -1;  // bucket index under the mouse (-1 = none)
+    private string _activeFilterTag = "24"; // tag of the currently active quick-filter button
     private DispatcherTimer? _rangeChangedDebounce;
 
     public event EventHandler<TimeRangeChangedEventArgs>? RangeChanged;
@@ -69,17 +68,7 @@ public TimeRangeSlicerControl()
         SlicerBorder.SizeChanged += (_, _) => Redraw();
         SlicerCanvas.Focusable = true;
         SlicerCanvas.KeyDown += Canvas_KeyDown;
-    }
-
-    public bool IsExpanded
-    {
-        get => _isExpanded;
-        set
-        {
-            _isExpanded = value;
-            SlicerBorder.IsVisible = _isExpanded;
-            ToggleIcon.Text = _isExpanded ? "▾" : "▸";
-        }
+        HighlightActiveFilter();
     }
 
     public void LoadData(List<QueryStoreTimeSlice> data, string metric,
@@ -98,6 +87,7 @@ public void LoadData(List<QueryStoreTimeSlice> data, string metric,
         {
             // Default selection: last 24 hours
             _rangeEnd = 1.0;
+            _activeFilterTag = "24";
             if (_data.Count >= 2)
             {
                 var last = _data[^1].IntervalStartUtc.AddHours(1);
@@ -108,6 +98,7 @@ public void LoadData(List<QueryStoreTimeSlice> data, string metric,
             {
                 _rangeStart = 0;
             }
+            HighlightActiveFilter();
         }
 
         UpdateRangeLabel();
@@ -165,14 +156,133 @@ private double MinNormInterval
         get
         {
             if (_data.Count == 0) return 0;
-            var n = _data.Count;
-            return Math.Min(MinIntervalHours / n, 1);
+            return 1.0 / _data.Count;
+        }
+    }
+
+    private void CustomFilter_Click(object? sender, RoutedEventArgs e)
+    {
+        PopulatePickersFromSelection();
+        DateTimePopup.IsOpen = true;
+    }
+
+    private void PopupApply_Click(object? sender, RoutedEventArgs e)
+    {
+        if (_data.Count < 2) { DateTimePopup.IsOpen = false; return; }
+
+        var startDate = StartDatePicker.SelectedDate;
+        var startTime = StartTimePicker.SelectedTime;
+        var endDate = EndDatePicker.SelectedDate;
+        var endTime = EndTimePicker.SelectedTime;
+
+        if (!startDate.HasValue || !endDate.HasValue) { DateTimePopup.IsOpen = false; return; }
+
+        var startDt = startDate.Value.Date + (startTime ?? TimeSpan.Zero);
+        var endDt = endDate.Value.Date + (endTime ?? TimeSpan.Zero);
+
+        // Convert display time back to UTC
+        var startUtc = ConvertFromDisplay(startDt);
+        var endUtc = ConvertFromDisplay(endDt);
+
+        if (endUtc <= startUtc) endUtc = startUtc.AddHours(1);
+
+        _rangeStart = GetNormFromDateTime(startUtc);
+        _rangeEnd = GetNormFromDateTime(endUtc);
+
+        // Enforce minimum interval
+        if (_rangeEnd - _rangeStart < MinNormInterval)
+            _rangeEnd = Math.Min(1, _rangeStart + MinNormInterval);
+
+        _activeFilterTag = "0";
+        HighlightActiveFilter();
+
+        DateTimePopup.IsOpen = false;
+        UpdateRangeLabel();
+        Redraw();
+        FireRangeChanged();
+    }
+
+    private void PopupCancel_Click(object? sender, RoutedEventArgs e)
+    {
+        DateTimePopup.IsOpen = false;
+    }
+
+    private void QuickFilter_Click(object? sender, RoutedEventArgs e)
+    {
+        if (sender is Button btn && btn.Tag is string hoursStr && int.TryParse(hoursStr, out var hours))
+        {
+            _activeFilterTag = hoursStr;
+            HighlightActiveFilter();
+            ApplyQuickFilter(hours);
+        }
+    }
+
+    private void ApplyQuickFilter(int hours)
+    {
+        if (_data.Count < 2) return;
+        var last = _data[^1].IntervalStartUtc.AddHours(1);
+        var start = last.AddHours(-hours);
+        _rangeStart = GetNormFromDateTime(start);
+        _rangeEnd = 1.0;
+        UpdateRangeLabel();
+        Redraw();
+        FireRangeChanged();
+    }
+
+    private void HighlightActiveFilter()
+    {
+        var accentBrush = TryFindBrush("AccentBrush", FallbackChartLineBrush);
+        var normalFg = TryFindBrush("SlicerLabelBrush", FallbackLabelBrush);
+        var normalBorder = TryFindBrush("SlicerBorderBrush", FallbackDayLineBrush);
+
+        foreach (var child in QuickFilterPanel.Children)
+        {
+            if (child is not Button btn) continue;
+            var tag = btn.Tag as string ?? "";
+            if (tag == _activeFilterTag)
+            {
+                btn.BorderBrush = accentBrush;
+                btn.Foreground = accentBrush;
+            }
+            else
+            {
+                btn.BorderBrush = normalBorder;
+                btn.Foreground = normalFg;
+            }
         }
     }
 
-    private void Toggle_Click(object? sender, RoutedEventArgs e)
+    private void PopulatePickersFromSelection()
     {
-        IsExpanded = !IsExpanded;
+        if (_data.Count == 0) return;
+
+        var startDisplay = TimeDisplayHelper.ConvertForDisplay(GetDateTimeAtNorm(_rangeStart));
+        var endDisplay = TimeDisplayHelper.ConvertForDisplay(GetDateTimeAtNorm(_rangeEnd));
+
+        StartDatePicker.SelectedDate = startDisplay.Date;
+        StartTimePicker.SelectedTime = startDisplay.TimeOfDay;
+
+        EndDatePicker.SelectedDate = endDisplay.Date;
+        EndTimePicker.SelectedTime = endDisplay.TimeOfDay;
+
+        // Set display date range limits from data bounds
+        var firstDisplay = TimeDisplayHelper.ConvertForDisplay(_data[0].IntervalStartUtc);
+        var lastDisplay = TimeDisplayHelper.ConvertForDisplay(_data[^1].IntervalStartUtc.AddHours(1));
+        StartDatePicker.DisplayDateStart = firstDisplay.Date;
+        StartDatePicker.DisplayDateEnd = lastDisplay.Date;
+        EndDatePicker.DisplayDateStart = firstDisplay.Date;
+        EndDatePicker.DisplayDateEnd = lastDisplay.Date;
+    }
+
+    private static DateTime ConvertFromDisplay(DateTime displayTime)
+    {
+        return TimeDisplayHelper.Current switch
+        {
+            TimeDisplayMode.Local => displayTime.ToUniversalTime(),
+            TimeDisplayMode.Utc => DateTime.SpecifyKind(displayTime, DateTimeKind.Utc),
+            TimeDisplayMode.Server => displayTime.AddMinutes(-TimeDisplayHelper.ServerUtcOffsetMinutes),
+            _ => displayTime.ToUniversalTime()
+        };
     }
 
     private double[] GetMetricValues()
@@ -785,6 +895,8 @@ private void Canvas_PointerReleased(object? sender, PointerReleasedEventArgs e)
 
         _dragMode = DragMode.None;
         e.Pointer.Capture(null);
+        _activeFilterTag = "0";
+        HighlightActiveFilter();
         UpdateRangeLabel();
         Redraw();
         FireRangeChanged();
@@ -820,6 +932,8 @@ private void Canvas_PointerWheelChanged(object? sender, PointerWheelEventArgs e)
         _rangeStart = Math.Max(0, newStart);
         _rangeEnd = Math.Min(1, newEnd);
 
+        _activeFilterTag = "0";
+        HighlightActiveFilter();
         UpdateRangeLabel();
         Redraw();
         FireRangeChanged();
@@ -878,7 +992,10 @@ private void UpdateRangeLabel()
         var start = TimeDisplayHelper.ConvertForDisplay(GetDateTimeAtNorm(_rangeStart));
         var end = TimeDisplayHelper.ConvertForDisplay(GetDateTimeAtNorm(_rangeEnd));
         var span = end - start;
-        RangeLabel.Text = $"{start:yyyy-MM-dd HH:mm} → {end:yyyy-MM-dd HH:mm}  ({span.TotalHours:F0}h)";
+        var spanText = span.TotalHours >= 48
+            ? $"{span.TotalDays:F1}d"
+            : $"{span.TotalHours:F0}h";
+        RangeLabel.Text = $"{start:yyyy-MM-dd HH:mm} → {end:yyyy-MM-dd HH:mm}  ({spanText})";
     }
 
     private void FireRangeChanged()

From 65901ecf2baf2cc2cb78311649d52fe96d164556 Mon Sep 17 00:00:00 2001
From: rferraton <16419423+rferraton@users.noreply.github.com>
Date: Sat, 28 Mar 2026 00:09:54 +0100
Subject: [PATCH 23/31] fix display for quick filter and timeslicer font (fixed
 type)

---
 .../Controls/TimeRangeSlicerControl.axaml     | 19 ++++++++++---------
 1 file changed, 10 insertions(+), 9 deletions(-)

diff --git a/src/PlanViewer.App/Controls/TimeRangeSlicerControl.axaml b/src/PlanViewer.App/Controls/TimeRangeSlicerControl.axaml
index 6d02911..26afd65 100644
--- a/src/PlanViewer.App/Controls/TimeRangeSlicerControl.axaml
+++ b/src/PlanViewer.App/Controls/TimeRangeSlicerControl.axaml
@@ -7,25 +7,26 @@
         <Grid RowDefinitions="Auto,Auto">
             <!-- Header with range label button that opens date/time picker popup -->
             <Panel Grid.Row="0">
-                <StackPanel Orientation="Horizontal" Spacing="6" Margin="8,4">
-                    <TextBlock Text="📅" FontSize="12"
+                <Grid ColumnDefinitions="Auto,Auto,*,Auto" Margin="8,4">
+                    <TextBlock Grid.Column="0" Text="📅" FontSize="12"
                                VerticalAlignment="Center"/>
-                    <TextBlock x:Name="ToggleLabel" Text="Time Range"
+                    <TextBlock Grid.Column="1" x:Name="ToggleLabel" Text="Time Range"
                                FontSize="11" FontWeight="SemiBold"
                                Foreground="{DynamicResource SlicerToggleBrush}"
-                               VerticalAlignment="Center"/>
-                    <TextBlock x:Name="RangeLabel" Text=""
-                               FontSize="11"
+                               VerticalAlignment="Center" Margin="6,0,0,0"/>
+                    <TextBlock Grid.Column="2" x:Name="RangeLabel" Text=""
+                               FontSize="11" FontFamily="Cascadia Mono,Consolas,monospace"
                                Foreground="{DynamicResource SlicerLabelBrush}"
-                               VerticalAlignment="Center" Margin="12,0,0,0"/>
-                    <StackPanel x:Name="QuickFilterPanel" Orientation="Horizontal" Spacing="2" Margin="12,0,0,0" VerticalAlignment="Center">
+                               VerticalAlignment="Center" Margin="12,0,0,0"
+                               TextTrimming="CharacterEllipsis"/>
+                    <StackPanel Grid.Column="3" x:Name="QuickFilterPanel" Orientation="Horizontal" Spacing="2" Margin="12,0,0,0" VerticalAlignment="Center">
                         <Button x:Name="QF_3"      Content="3h"     Tag="3"   Click="QuickFilter_Click"   Height="20" MinWidth="32" Padding="6,0" FontSize="10" HorizontalContentAlignment="Center" VerticalContentAlignment="Center" Background="Transparent" BorderThickness="1" BorderBrush="{DynamicResource SlicerBorderBrush}" Foreground="{DynamicResource SlicerLabelBrush}" Cursor="Hand"/>
                         <Button x:Name="QF_24"     Content="24h"    Tag="24"  Click="QuickFilter_Click"   Height="20" MinWidth="32" Padding="6,0" FontSize="10" HorizontalContentAlignment="Center" VerticalContentAlignment="Center" Background="Transparent" BorderThickness="1" BorderBrush="{DynamicResource SlicerBorderBrush}" Foreground="{DynamicResource SlicerLabelBrush}" Cursor="Hand"/>
                         <Button x:Name="QF_168"    Content="7d"     Tag="168" Click="QuickFilter_Click"   Height="20" MinWidth="32" Padding="6,0" FontSize="10" HorizontalContentAlignment="Center" VerticalContentAlignment="Center" Background="Transparent" BorderThickness="1" BorderBrush="{DynamicResource SlicerBorderBrush}" Foreground="{DynamicResource SlicerLabelBrush}" Cursor="Hand"/>
                         <Button x:Name="QF_720"    Content="30d"    Tag="720" Click="QuickFilter_Click"   Height="20" MinWidth="32" Padding="6,0" FontSize="10" HorizontalContentAlignment="Center" VerticalContentAlignment="Center" Background="Transparent" BorderThickness="1" BorderBrush="{DynamicResource SlicerBorderBrush}" Foreground="{DynamicResource SlicerLabelBrush}" Cursor="Hand"/>
                         <Button x:Name="QF_Custom" Content="Custom" Tag="0"   Click="CustomFilter_Click"  Height="20" MinWidth="42" Padding="6,0" FontSize="10" HorizontalContentAlignment="Center" VerticalContentAlignment="Center" Background="Transparent" BorderThickness="1" BorderBrush="{DynamicResource SlicerBorderBrush}" Foreground="{DynamicResource SlicerLabelBrush}" Cursor="Hand"/>
                     </StackPanel>
-                </StackPanel>
+                </Grid>
                 <Popup x:Name="DateTimePopup"
                        PlacementTarget="{Binding #QF_Custom}"
                        Placement="BottomEdgeAlignedLeft"

From 824efaa90fd537117f345501dc52c8e7c89d403e Mon Sep 17 00:00:00 2001
From: rferraton <16419423+rferraton@users.noreply.github.com>
Date: Sat, 28 Mar 2026 00:19:01 +0100
Subject: [PATCH 24/31] find the max in the period feature

---
 .../Controls/TimeRangeSlicerControl.axaml.cs  | 53 ++++---------------
 1 file changed, 10 insertions(+), 43 deletions(-)

diff --git a/src/PlanViewer.App/Controls/TimeRangeSlicerControl.axaml.cs b/src/PlanViewer.App/Controls/TimeRangeSlicerControl.axaml.cs
index bf313b3..6d1ac56 100644
--- a/src/PlanViewer.App/Controls/TimeRangeSlicerControl.axaml.cs
+++ b/src/PlanViewer.App/Controls/TimeRangeSlicerControl.axaml.cs
@@ -44,10 +44,6 @@ public partial class TimeRangeSlicerControl : UserControl
     private static readonly Cursor CursorSizeWE      = new(StandardCursorType.SizeWestEast);
     private static readonly FontFamily TooltipFont   = new("Cascadia Mono,Consolas,monospace");
 
-    // Line points computed in Redraw(), used for hover hit-testing
-    private Point[] _linePoints = Array.Empty<Point>();
-    private double  _stepX;
-
     private enum DragMode { None, MoveRange, DragStart, DragEnd, SelectRect }
     private DragMode _dragMode = DragMode.None;
     private double _dragOriginX;
@@ -56,7 +52,6 @@ private enum DragMode { None, MoveRange, DragStart, DragEnd, SelectRect }
     private double _selectRectOriginX;   // canvas-x where drag-select started
     private double _selectRectCurrentX;  // canvas-x of current pointer during drag-select
 
-    private int _hoveredIndex = -1;  // bucket index under the mouse (-1 = none)
     private string _activeFilterTag = "24"; // tag of the currently active quick-filter button
     private DispatcherTimer? _rangeChangedDebounce;
 
@@ -359,10 +354,6 @@ public void Redraw()
             var y = chartBottom - (values[i] / max) * chartHeight;
             linePoints.Add(new Point(x, y));
         }
-        // Cache for Y-proximity hit-testing in pointer events
-        _linePoints = linePoints.ToArray();
-        _stepX      = stepX;
-
         // Area fill
         var fillBrush = TryFindBrush("SlicerChartFillBrush", FallbackChartFillBrush);
         var areaGeometry = new StreamGeometry();
@@ -623,13 +614,18 @@ public void Redraw()
             SlicerCanvas.Children.Add(hitRect);
         }
 
-        // ── Hover dot ──────────────────────────────────────────────────
-        var dotIdx = _hoveredIndex;
-        if (dotIdx >= 0 && dotIdx < n)
+        // ── Peak dot: fixed at the maximum-value bucket within the selection ──
+        var selStartIdx = (int)Math.Floor(_rangeStart * n);
+        var selEndIdx   = Math.Min(n - 1, (int)Math.Ceiling(_rangeEnd * n) - 1);
+        if (selStartIdx <= selEndIdx)
         {
+            var peakIdx = selStartIdx;
+            for (int pi = selStartIdx + 1; pi <= selEndIdx; pi++)
+                if (values[pi] > values[peakIdx]) peakIdx = pi;
+
             const double DotR = 7;
-            var dotX = dotIdx * stepX + stepX / 2;
-            var dotY = chartBottom - (values[dotIdx] / max) * chartHeight;
+            var dotX = peakIdx * stepX + stepX / 2;
+            var dotY = chartBottom - (values[peakIdx] / max) * chartHeight;
             var dot = new Ellipse
             {
                 Width           = DotR * 2,
@@ -705,28 +701,6 @@ private IBrush TryFindBrush(string key, IBrush fallback)
         return fallback;
     }
 
-    /// <summary>
-    /// Finds the bucket index whose line point is closest horizontally to <paramref name="pos"/>,
-    /// or -1 if none qualifies.
-    /// </summary>
-    private int FindNearestLineIndex(Point pos)
-    {
-        if (_linePoints.Length == 0) return -1;
-        var best = -1;
-        var bestDist = double.MaxValue;
-        for (int i = 0; i < _linePoints.Length; i++)
-        {
-            var lp = _linePoints[i];
-            var dx = Math.Abs(pos.X - lp.X);
-            if (dx <= _stepX / 2 + 2 && dx < bestDist)
-            {
-                bestDist = dx;
-                best = i;
-            }
-        }
-        return best;
-    }
-
     // ── Interaction ────────────────────────────────────────────────────────
 
     private void Canvas_PointerPressed(object? sender, PointerPressedEventArgs e)
@@ -817,13 +791,6 @@ private void Canvas_PointerMoved(object? sender, PointerEventArgs e)
                 SlicerCanvas.Cursor = Cursor.Default;
             }
 
-            // Y-proximity hover for dot
-            var newHover = FindNearestLineIndex(pos);
-            if (newHover != _hoveredIndex)
-            {
-                _hoveredIndex = newHover;
-                Redraw();
-            }
             return;
         }
 

From 4b13bc8aab92ec4ce125fc5060ad7f4147241bb4 Mon Sep 17 00:00:00 2001
From: rferraton <16419423+rferraton@users.noreply.github.com>
Date: Sat, 28 Mar 2026 00:29:14 +0100
Subject: [PATCH 25/31] select top1 (dynamic) instead of all selected by
 default

---
 .../Controls/QueryStoreGridControl.axaml.cs        | 14 ++++++++++++--
 1 file changed, 12 insertions(+), 2 deletions(-)

diff --git a/src/PlanViewer.App/Controls/QueryStoreGridControl.axaml.cs b/src/PlanViewer.App/Controls/QueryStoreGridControl.axaml.cs
index 9451af1..a192af6 100644
--- a/src/PlanViewer.App/Controls/QueryStoreGridControl.axaml.cs
+++ b/src/PlanViewer.App/Controls/QueryStoreGridControl.axaml.cs
@@ -40,6 +40,7 @@ public partial class QueryStoreGridControl : UserControl
     private bool _initialOrderByLoaded;
     private bool _suppressRangeChanged;
     private string? _waitHighlightCategory;
+    private const int AutoSelectTopN = 1; // number of rows auto-selected after each fetch
     private bool _waitStatsSupported;  // false until version + capture mode confirmed
     private bool _waitStatsEnabled = true;
     private bool _waitPercentMode;
@@ -210,7 +211,7 @@ private async System.Threading.Tasks.Task FetchPlansForRangeAsync()
 
             ApplyFilters();
             LoadButton.IsEnabled = true;
-            SelectToggleButton.Content = "Select None";
+            SelectToggleButton.Content = "Select All";
 
             // Fetch per-plan wait stats after grid is populated (needs plan IDs)
             if (_waitStatsSupported && _waitStatsEnabled && _slicerStartUtc.HasValue && _slicerEndUtc.HasValue)
@@ -495,6 +496,7 @@ private void OnWaitCategoryDoubleClicked(object? sender, string category)
         // Clear column sort indicators since we're using custom sort
         _sortedColumnTag = null;
         UpdateSortIndicators(null);
+        ReapplyTopNSelection();
         UpdateBarRatios();
     }
 
@@ -936,6 +938,13 @@ private static string GetColumnLabel(StackPanel header)
         return tb.Text?.TrimEnd(' ', '▲', '▼') ?? string.Empty;
     }
 
+    private void ReapplyTopNSelection()
+    {
+        if (_filteredRows.Count == 0) return;
+        foreach (var r in _rows) r.IsSelected = false;
+        foreach (var r in _filteredRows.Take(AutoSelectTopN)) r.IsSelected = true;
+    }
+
     private void ApplySortAndFilters()
     {
         IEnumerable<QueryStoreRow> source = _rows.Where(RowMatchesAllFilters);
@@ -951,6 +960,7 @@ private void ApplySortAndFilters()
         foreach (var row in source)
             _filteredRows.Add(row);
 
+        ReapplyTopNSelection();
         UpdateStatusText();
         UpdateBarRatios();
     }
@@ -1045,7 +1055,7 @@ private static IComparable GetSortKey(string columnTag, QueryStoreRow r) =>
 
 public class QueryStoreRow : INotifyPropertyChanged
 {
-    private bool _isSelected = true;
+    private bool _isSelected = false;
 
     // Bar ratios [0..1] per column
     private double _execsRatio;

From 741313a57bb92905c0097658b5f4636c3abbe1ce Mon Sep 17 00:00:00 2001
From: Erik Darling <2136037+erikdarlingdata@users.noreply.github.com>
Date: Sat, 28 Mar 2026 12:11:16 -0400
Subject: [PATCH 26/31] Add GitHub Sponsors funding link

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
---
 .github/FUNDING.yml | 1 +
 1 file changed, 1 insertion(+)
 create mode 100644 .github/FUNDING.yml

diff --git a/.github/FUNDING.yml b/.github/FUNDING.yml
new file mode 100644
index 0000000..098803a
--- /dev/null
+++ b/.github/FUNDING.yml
@@ -0,0 +1 @@
+github: erikdarlingdata

From 23e978f15772bdd4da150787d4dead264cf2f80a Mon Sep 17 00:00:00 2001
From: rferraton <16419423+rferraton@users.noreply.github.com>
Date: Sat, 28 Mar 2026 17:28:10 +0100
Subject: [PATCH 27/31] QS - TimeSlicer : 48h quick filter button comes back

---
 src/PlanViewer.App/Controls/TimeRangeSlicerControl.axaml | 1 +
 1 file changed, 1 insertion(+)

diff --git a/src/PlanViewer.App/Controls/TimeRangeSlicerControl.axaml b/src/PlanViewer.App/Controls/TimeRangeSlicerControl.axaml
index 26afd65..068d20f 100644
--- a/src/PlanViewer.App/Controls/TimeRangeSlicerControl.axaml
+++ b/src/PlanViewer.App/Controls/TimeRangeSlicerControl.axaml
@@ -22,6 +22,7 @@
                     <StackPanel Grid.Column="3" x:Name="QuickFilterPanel" Orientation="Horizontal" Spacing="2" Margin="12,0,0,0" VerticalAlignment="Center">
                         <Button x:Name="QF_3"      Content="3h"     Tag="3"   Click="QuickFilter_Click"   Height="20" MinWidth="32" Padding="6,0" FontSize="10" HorizontalContentAlignment="Center" VerticalContentAlignment="Center" Background="Transparent" BorderThickness="1" BorderBrush="{DynamicResource SlicerBorderBrush}" Foreground="{DynamicResource SlicerLabelBrush}" Cursor="Hand"/>
                         <Button x:Name="QF_24"     Content="24h"    Tag="24"  Click="QuickFilter_Click"   Height="20" MinWidth="32" Padding="6,0" FontSize="10" HorizontalContentAlignment="Center" VerticalContentAlignment="Center" Background="Transparent" BorderThickness="1" BorderBrush="{DynamicResource SlicerBorderBrush}" Foreground="{DynamicResource SlicerLabelBrush}" Cursor="Hand"/>
+                        <Button x:Name="QF_48"     Content="48h"    Tag="48"  Click="QuickFilter_Click"   Height="20" MinWidth="32" Padding="6,0" FontSize="10" HorizontalContentAlignment="Center" VerticalContentAlignment="Center" Background="Transparent" BorderThickness="1" BorderBrush="{DynamicResource SlicerBorderBrush}" Foreground="{DynamicResource SlicerLabelBrush}" Cursor="Hand"/>
                         <Button x:Name="QF_168"    Content="7d"     Tag="168" Click="QuickFilter_Click"   Height="20" MinWidth="32" Padding="6,0" FontSize="10" HorizontalContentAlignment="Center" VerticalContentAlignment="Center" Background="Transparent" BorderThickness="1" BorderBrush="{DynamicResource SlicerBorderBrush}" Foreground="{DynamicResource SlicerLabelBrush}" Cursor="Hand"/>
                         <Button x:Name="QF_720"    Content="30d"    Tag="720" Click="QuickFilter_Click"   Height="20" MinWidth="32" Padding="6,0" FontSize="10" HorizontalContentAlignment="Center" VerticalContentAlignment="Center" Background="Transparent" BorderThickness="1" BorderBrush="{DynamicResource SlicerBorderBrush}" Foreground="{DynamicResource SlicerLabelBrush}" Cursor="Hand"/>
                         <Button x:Name="QF_Custom" Content="Custom" Tag="0"   Click="CustomFilter_Click"  Height="20" MinWidth="42" Padding="6,0" FontSize="10" HorizontalContentAlignment="Center" VerticalContentAlignment="Center" Background="Transparent" BorderThickness="1" BorderBrush="{DynamicResource SlicerBorderBrush}" Foreground="{DynamicResource SlicerLabelBrush}" Cursor="Hand"/>

From 4bda39522e96d0a08bd8b0be098544604f15f44e Mon Sep 17 00:00:00 2001
From: rferraton <16419423+rferraton@users.noreply.github.com>
Date: Sat, 28 Mar 2026 18:25:14 +0100
Subject: [PATCH 28/31] - Create FormatWaitRatio helper method in
 WaitStatsModels.cs - Modify WaitStatsProfileControl to default to ribbon
 chart mode - Remove the grid data button from WaitStatsProfileControl header
 - Add legend button to WaitStatsProfileControl that opens a color legend
 popup - Add vertical dashed lines for day boundaries in
 WaitStatsRibbonControl - Align X-axis ticks/labels to day boundaries (00:00)
 in WaitStatsRibbonControl - Add horizontal dashed average line with label in
 WaitStatsRibbonControl - Apply FormatWaitRatio in WaitStatsRibbonControl
 tooltips - Apply FormatWaitRatio in WaitProfileBarControl tooltips - Apply
 FormatWaitRatio in WaitStatsProfileControl grid table rows

---
 .../Controls/WaitProfileBarControl.axaml.cs   |   2 +-
 .../Controls/WaitStatsProfileControl.axaml    |  33 +---
 .../Controls/WaitStatsProfileControl.axaml.cs | 147 ++++++++++++------
 .../Controls/WaitStatsRibbonControl.axaml.cs  | 117 ++++++++++++--
 src/PlanViewer.Core/Models/WaitStatsModels.cs |  27 ++++
 5 files changed, 238 insertions(+), 88 deletions(-)

diff --git a/src/PlanViewer.App/Controls/WaitProfileBarControl.axaml.cs b/src/PlanViewer.App/Controls/WaitProfileBarControl.axaml.cs
index 61cfb81..9de88d0 100644
--- a/src/PlanViewer.App/Controls/WaitProfileBarControl.axaml.cs
+++ b/src/PlanViewer.App/Controls/WaitProfileBarControl.axaml.cs
@@ -113,7 +113,7 @@ private void Redraw()
             Canvas.SetTop(rect, 0);
             BarCanvas.Children.Add(rect);
 
-            ToolTip.SetTip(rect, $"{seg.Category}: {seg.WaitRatio:P2} ({seg.Ratio:P1} of total)");
+            ToolTip.SetTip(rect, $"{seg.Category}: {WaitRatioFormatter.Format(seg.WaitRatio)} ({seg.Ratio:P1} of total)");
 
             var capturedCategory = seg.Category;
             rect.PointerPressed += (_, e) =>
diff --git a/src/PlanViewer.App/Controls/WaitStatsProfileControl.axaml b/src/PlanViewer.App/Controls/WaitStatsProfileControl.axaml
index 66bd23b..9b83576 100644
--- a/src/PlanViewer.App/Controls/WaitStatsProfileControl.axaml
+++ b/src/PlanViewer.App/Controls/WaitStatsProfileControl.axaml
@@ -1,11 +1,11 @@
 <UserControl xmlns="https://github.com/avaloniaui"
-             xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
-             xmlns:local="using:PlanViewer.App.Controls"
+xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
+xmlns:local="using:PlanViewer.App.Controls"
              x:Class="PlanViewer.App.Controls.WaitStatsProfileControl">
     <Grid RowDefinitions="Auto,*">
         <!-- Header: toggle chart type -->
         <StackPanel Grid.Row="0" Orientation="Horizontal" Spacing="6" Margin="4,2">
-            <Button x:Name="ToggleChartButton" Content="☰"
+            <Button x:Name="ToggleChartButton" Content="▤"
                     Width="22" Height="22" Padding="0"
                     FontSize="12" Background="Transparent" BorderThickness="0"
                     Foreground="{DynamicResource ForegroundBrush}"
@@ -15,34 +15,17 @@
                        FontSize="11" FontWeight="SemiBold"
                        Foreground="{DynamicResource SlicerToggleBrush}"
                        VerticalAlignment="Center"/>
-            <Button x:Name="TableViewButton" Content="▦"
+            <Button x:Name="LegendButton" Content="◆"
                     Width="22" Height="22" Padding="0"
                     FontSize="12" Background="Transparent" BorderThickness="0"
                     Foreground="{DynamicResource ForegroundBrush}"
-                    ToolTip.Tip="Show wait stats as table"
-                    Click="TableView_Click"/>
+                    ToolTip.Tip="Show color legend"
+                    Click="Legend_Click"/>
         </StackPanel>
         <!-- Content area -->
         <Grid Grid.Row="1" x:Name="ContentArea" MinHeight="24">
-            <local:WaitProfileBarControl x:Name="GlobalBar" PercentMode="True"/>
-            <local:WaitStatsRibbonControl x:Name="GlobalRibbon" IsVisible="False"/>
-            <DataGrid x:Name="TableGrid" IsVisible="False"
-                      AutoGenerateColumns="False"
-                      CanUserSortColumns="True"
-                      CanUserResizeColumns="True"
-                      IsReadOnly="True"
-                      SelectionMode="Single"
-                      GridLinesVisibility="Horizontal"
-                      HeadersVisibility="Column"
-                      FontSize="11"
-                      Background="{DynamicResource BackgroundDarkBrush}"
-                      BorderThickness="0">
-                <DataGrid.Columns>
-                    <DataGridTextColumn Header="Category" Binding="{ReflectionBinding Category}" Width="*"/>
-                    <DataGridTextColumn Header="Wait Ratio" Binding="{ReflectionBinding WaitRatioText}" Width="Auto"/>
-                    <DataGridTextColumn Header="% of Total" Binding="{ReflectionBinding RatioText}" Width="Auto"/>
-                </DataGrid.Columns>
-            </DataGrid>
+            <local:WaitProfileBarControl x:Name="GlobalBar" PercentMode="True" IsVisible="False"/>
+            <local:WaitStatsRibbonControl x:Name="GlobalRibbon"/>
             <!-- Loading overlay -->
             <Border x:Name="WaitLoadingOverlay" IsVisible="False"
                     Background="#80000000" CornerRadius="0"
diff --git a/src/PlanViewer.App/Controls/WaitStatsProfileControl.axaml.cs b/src/PlanViewer.App/Controls/WaitStatsProfileControl.axaml.cs
index f25a39c..1f5aa26 100644
--- a/src/PlanViewer.App/Controls/WaitStatsProfileControl.axaml.cs
+++ b/src/PlanViewer.App/Controls/WaitStatsProfileControl.axaml.cs
@@ -1,22 +1,25 @@
 using System;
+using System;
 using System.Collections.Generic;
-using System.Collections.ObjectModel;
-using System.Diagnostics;
 using System.Linq;
+using Avalonia;
 using Avalonia.Controls;
+using Avalonia.Controls.Primitives;
 using Avalonia.Interactivity;
+using Avalonia.Layout;
+using Avalonia.Media;
 using PlanViewer.Core.Models;
 
 namespace PlanViewer.App.Controls;
 
 public partial class WaitStatsProfileControl : UserControl
 {
-    private enum ViewMode { Bar, Ribbon, Table }
+    private enum ViewMode { Bar, Ribbon }
 
-    private ViewMode _viewMode = ViewMode.Bar;
+    private ViewMode _viewMode = ViewMode.Ribbon;
     private bool _isCollapsed;
     private WaitProfile? _currentProfile;
-    private readonly ObservableCollection<WaitTableRow> _tableRows = new();
+    private Popup? _legendPopup;
 
     public event EventHandler<string>? CategoryClicked;
     public event EventHandler<string>? CategoryDoubleClicked;
@@ -24,10 +27,19 @@ private enum ViewMode { Bar, Ribbon, Table }
 
     public bool IsCollapsed => _isCollapsed;
 
+    // All known wait categories in the order they appear in the theme
+    private static readonly string[] AllWaitCategories =
+    [
+        "Unknown", "CPU", "Worker Thread", "Lock", "Latch", "Buffer Latch",
+        "Buffer IO", "Compilation", "SQL CLR", "Mirroring", "Transaction",
+        "Preemptive", "Service Broker", "Tran Log IO", "Network IO",
+        "Parallelism", "Memory", "Tracing", "Full Text Search",
+        "Other Disk IO", "Replication", "Log Rate Governor", "Others"
+    ];
+
     public WaitStatsProfileControl()
     {
         InitializeComponent();
-        TableGrid.ItemsSource = _tableRows;
         GlobalBar.CategoryClicked += (_, cat) => CategoryClicked?.Invoke(this, cat);
         GlobalBar.CategoryDoubleClicked += (_, cat) => CategoryDoubleClicked?.Invoke(this, cat);
         GlobalRibbon.CategoryClicked += (_, cat) => CategoryClicked?.Invoke(this, cat);
@@ -38,7 +50,6 @@ public void SetBarProfile(WaitProfile? profile)
     {
         _currentProfile = profile;
         GlobalBar.SetProfile(profile);
-        RefreshTableRows();
     }
 
     public void SetRibbonData(List<WaitCategoryTimeSlice> data)
@@ -59,7 +70,7 @@ public void Expand()
         ContentArea.IsVisible = true;
         TitleText.IsVisible = true;
         ToggleChartButton.IsVisible = true;
-        TableViewButton.IsVisible = true;
+        LegendButton.IsVisible = true;
         CollapsedChanged?.Invoke(this, false);
     }
 
@@ -70,7 +81,7 @@ public void Collapse()
         ContentArea.IsVisible = false;
         TitleText.IsVisible = false;
         ToggleChartButton.IsVisible = false;
-        TableViewButton.IsVisible = false;
+        LegendButton.IsVisible = false;
         CollapsedChanged?.Invoke(this, true);
     }
 
@@ -81,22 +92,7 @@ public void SetLoading(bool isLoading)
 
     private void ToggleChart_Click(object? sender, RoutedEventArgs e)
     {
-        // Cycle: Bar -> Ribbon -> Bar (skip table; table has its own button)
-        if (_viewMode == ViewMode.Table)
-        {
-            // If in table mode, toggle goes back to bar
-            _viewMode = ViewMode.Bar;
-        }
-        else
-        {
-            _viewMode = _viewMode == ViewMode.Bar ? ViewMode.Ribbon : ViewMode.Bar;
-        }
-        ApplyViewMode();
-    }
-
-    private void TableView_Click(object? sender, RoutedEventArgs e)
-    {
-        _viewMode = _viewMode == ViewMode.Table ? ViewMode.Bar : ViewMode.Table;
+        _viewMode = _viewMode == ViewMode.Bar ? ViewMode.Ribbon : ViewMode.Bar;
         ApplyViewMode();
     }
 
@@ -104,34 +100,91 @@ private void ApplyViewMode()
     {
         GlobalBar.IsVisible = _viewMode == ViewMode.Bar;
         GlobalRibbon.IsVisible = _viewMode == ViewMode.Ribbon;
-        TableGrid.IsVisible = _viewMode == ViewMode.Table;
-        ToggleChartButton.Content = _viewMode == ViewMode.Ribbon ? "▤" : "☰";
-
-        // The ContentArea lives inside an Auto-sized parent row, so a *-row
-        // DataGrid would collapse to zero height.  Give an explicit height
-        // when in table mode; reset to NaN (auto) for chart modes.
-        ContentArea.Height = _viewMode == ViewMode.Table ? 120 : double.NaN;
+        ToggleChartButton.Content = _viewMode == ViewMode.Ribbon ? "☰" : "▤";
     }
 
-    private void RefreshTableRows()
+    private void Legend_Click(object? sender, RoutedEventArgs e)
     {
-        _tableRows.Clear();
-        if (_currentProfile == null) { return; }
-        foreach (var seg in _currentProfile.Segments.OrderByDescending(s => s.Ratio))
+        if (_legendPopup != null)
         {
-            _tableRows.Add(new WaitTableRow
+            _legendPopup.IsOpen = !_legendPopup.IsOpen;
+            return;
+        }
+
+        var grid = new Grid { ColumnDefinitions = new ColumnDefinitions("Auto,Auto") };
+        for (int i = 0; i < AllWaitCategories.Length; i++)
+            grid.RowDefinitions.Add(new RowDefinition(GridLength.Auto));
+
+        for (int i = 0; i < AllWaitCategories.Length; i++)
+        {
+            var cat = AllWaitCategories[i];
+            var brush = TryFindBrush($"WaitCategory.{cat}", new SolidColorBrush(Color.Parse("#555D66")));
+
+            var swatch = new Border
             {
-                Category = seg.Category,
-                WaitRatioText = seg.WaitRatio.ToString("P2"),
-                RatioText = seg.Ratio.ToString("P1")
-            });
+                Width = 14,
+                Height = 14,
+                Background = brush,
+                CornerRadius = new CornerRadius(2),
+                Margin = new Thickness(4, 2),
+                VerticalAlignment = VerticalAlignment.Center,
+            };
+            Grid.SetRow(swatch, i);
+            Grid.SetColumn(swatch, 0);
+            grid.Children.Add(swatch);
+
+            var label = new TextBlock
+            {
+                Text = cat,
+                FontSize = 11,
+                VerticalAlignment = VerticalAlignment.Center,
+                Margin = new Thickness(4, 2, 8, 2),
+            };
+            if (this.TryFindResource("ForegroundBrush", this.ActualThemeVariant, out var fg) && fg is IBrush fgBrush)
+                label.Foreground = fgBrush;
+            Grid.SetRow(label, i);
+            Grid.SetColumn(label, 1);
+            grid.Children.Add(label);
         }
+
+        var scroll = new ScrollViewer
+        {
+            Content = grid,
+            MaxHeight = 300,
+            VerticalScrollBarVisibility = Avalonia.Controls.Primitives.ScrollBarVisibility.Auto,
+        };
+
+        var bgBrush = TryFindBrush("BackgroundLightBrush", new SolidColorBrush(Color.Parse("#22252D")));
+        var borderBrush = TryFindBrush("BorderBrush", new SolidColorBrush(Color.Parse("#3A3D45")));
+        var container = new Border
+        {
+            Background = bgBrush,
+            BorderBrush = borderBrush,
+            BorderThickness = new Thickness(1),
+            CornerRadius = new CornerRadius(6),
+            Padding = new Thickness(4),
+            Child = scroll,
+        };
+
+        _legendPopup = new Popup
+        {
+            Child = container,
+            IsLightDismissEnabled = true,
+            Placement = PlacementMode.Bottom,
+            PlacementTarget = LegendButton,
+        };
+
+        // Add to visual tree so DynamicResources resolve
+        if (this.Content is Grid rootGrid)
+            rootGrid.Children.Add(_legendPopup);
+
+        _legendPopup.IsOpen = true;
     }
-}
 
-public class WaitTableRow
-{
-    public string Category { get; set; } = "";
-    public string WaitRatioText { get; set; } = "";
-    public string RatioText { get; set; } = ""; 
+    private IBrush TryFindBrush(string key, IBrush fallback)
+    {
+        if (this.TryFindResource(key, this.ActualThemeVariant, out var resource) && resource is IBrush brush)
+            return brush;
+        return fallback;
+    }
 }
diff --git a/src/PlanViewer.App/Controls/WaitStatsRibbonControl.axaml.cs b/src/PlanViewer.App/Controls/WaitStatsRibbonControl.axaml.cs
index a56f1dd..f948b5c 100644
--- a/src/PlanViewer.App/Controls/WaitStatsRibbonControl.axaml.cs
+++ b/src/PlanViewer.App/Controls/WaitStatsRibbonControl.axaml.cs
@@ -22,7 +22,7 @@ public partial class WaitStatsRibbonControl : UserControl
     public event EventHandler<string>? CategoryClicked;
     public event EventHandler<string>? CategoryDoubleClicked;
 
-    private const double PaddingTop = 4;
+    private const double PaddingTop = 14; // extra room for average label
     private const double PaddingBottom = 16;
 
     public WaitStatsRibbonControl()
@@ -94,6 +94,30 @@ private void Redraw()
             .ToList();
         orderedCats.Add("Others");
 
+        // ── Vertical dashed lines at day boundaries (00:00) ────────────────
+        var dashBrush = TryFindBrush("SlicerLabelBrush", new SolidColorBrush(Color.Parse("#99E4E6EB")));
+        for (int i = 0; i < n; i++)
+        {
+            if (allHours[i].Hour == 0)
+            {
+                var lineX = i * stepX;
+                var line = new Line
+                {
+                    StartPoint = new Point(lineX, PaddingTop),
+                    EndPoint = new Point(lineX, PaddingTop + chartH),
+                    Stroke = dashBrush,
+                    StrokeThickness = 1,
+                    StrokeDashArray = [4, 4],
+                    Opacity = 0.5,
+                };
+                RibbonCanvas.Children.Add(line);
+            }
+        }
+
+        // ── Stacked bars ───────────────────────────────────────────────────
+        double totalWaitSum = 0;
+        int bucketsWithData = 0;
+
         for (int i = 0; i < n; i++)
         {
             var hour = allHours[i];
@@ -118,6 +142,10 @@ private void Redraw()
                     catValues["Others"] += s.WaitRatio;
             }
 
+            var bucketTotal = catValues.Values.Sum();
+            totalWaitSum += bucketTotal;
+            bucketsWithData++;
+
             // Draw stacked from bottom
             foreach (var cat in orderedCats)
             {
@@ -149,7 +177,7 @@ private void Redraw()
                     : TimeDisplayHelper.FormatForDisplay(intervalEnd, "yyyy-MM-dd HH:mm");
                 var tipBlock = new TextBlock
                 {
-                    Text = $"{cat}: {ratio:P2}\n{startDisplay} \u2013 {endDisplay}",
+                    Text = $"{cat}: {WaitRatioFormatter.Format(ratio)}\n{startDisplay} \u2013 {endDisplay}",
                     FontSize = 13,
                     Padding = new Thickness(6, 4),
                 };
@@ -169,21 +197,80 @@ private void Redraw()
             }
         }
 
-        // X-axis labels
-        var labelBrush = TryFindBrush("SlicerLabelBrush", new SolidColorBrush(Color.Parse("#99E4E6EB")));
-        int labelInterval = Math.Max(1, n / 6);
-        for (int i = 0; i < n; i += labelInterval)
+        // ── Horizontal dashed average line ─────────────────────────────────
+        if (bucketsWithData > 0)
+        {
+            var avgWait = totalWaitSum / bucketsWithData;
+            if (avgWait > 0 && avgWait <= maxTotal)
+            {
+                var avgY = PaddingTop + chartH - (avgWait / maxTotal) * chartH;
+                var avgLine = new Line
+                {
+                    StartPoint = new Point(0, avgY),
+                    EndPoint = new Point(w, avgY),
+                    Stroke = dashBrush,
+                    StrokeThickness = 1,
+                    StrokeDashArray = [6, 3],
+                    Opacity = 0.7,
+                };
+                RibbonCanvas.Children.Add(avgLine);
+
+                var avgLabel = new TextBlock
+                {
+                    Text = $"avg:{WaitRatioFormatter.Format(avgWait)}",
+                    FontSize = 8,
+                    Foreground = dashBrush,
+                };
+                Canvas.SetLeft(avgLabel, 2);
+                Canvas.SetTop(avgLabel, avgY - 12);
+                RibbonCanvas.Children.Add(avgLabel);
+            }
+        }
+
+        // ── X-axis labels aligned to day boundaries (00:00) ────────────────
+        var labelBrush = dashBrush;
+
+        // Collect day-boundary indices
+        var dayIndices = new List<int>();
+        for (int i = 0; i < n; i++)
         {
-            var dt = allHours[i];
-            var tb = new TextBlock
+            if (allHours[i].Hour == 0)
+                dayIndices.Add(i);
+        }
+
+        if (dayIndices.Count > 0)
+        {
+            foreach (var i in dayIndices)
             {
-                Text = TimeDisplayHelper.FormatForDisplay(dt, "MM/dd HH:mm"),
-                FontSize = 8,
-                Foreground = labelBrush,
-            };
-            Canvas.SetLeft(tb, i * stepX);
-            Canvas.SetTop(tb, h - PaddingBottom + 1);
-            RibbonCanvas.Children.Add(tb);
+                var dt = allHours[i];
+                var tb = new TextBlock
+                {
+                    Text = TimeDisplayHelper.FormatForDisplay(dt, "MM/dd"),
+                    FontSize = 8,
+                    Foreground = labelBrush,
+                };
+                Canvas.SetLeft(tb, i * stepX + 2);
+                Canvas.SetTop(tb, h - PaddingBottom + 1);
+                RibbonCanvas.Children.Add(tb);
+            }
+        }
+        else
+        {
+            // Fallback if no day boundary exists (range < 1 day)
+            int labelInterval = Math.Max(1, n / 6);
+            for (int i = 0; i < n; i += labelInterval)
+            {
+                var dt = allHours[i];
+                var tb = new TextBlock
+                {
+                    Text = TimeDisplayHelper.FormatForDisplay(dt, "MM/dd HH:mm"),
+                    FontSize = 8,
+                    Foreground = labelBrush,
+                };
+                Canvas.SetLeft(tb, i * stepX);
+                Canvas.SetTop(tb, h - PaddingBottom + 1);
+                RibbonCanvas.Children.Add(tb);
+            }
         }
     }
 
diff --git a/src/PlanViewer.Core/Models/WaitStatsModels.cs b/src/PlanViewer.Core/Models/WaitStatsModels.cs
index 64b3282..7bcb57d 100644
--- a/src/PlanViewer.Core/Models/WaitStatsModels.cs
+++ b/src/PlanViewer.Core/Models/WaitStatsModels.cs
@@ -3,6 +3,33 @@
 
 namespace PlanViewer.Core.Models;
 
+/// <summary>
+/// Formats a WaitRatio value using adapted time-based units instead of percentages.
+/// WaitRatio is expressed in seconds-of-wait per second-of-wall-clock.
+///   - Below 1 s/sec → display as ms/sec  (e.g. "320 ms/sec")
+///   - 1 to 60 s/sec → display as s/sec   (e.g. "4.2 s/sec")
+///   - Above 60 s/sec → display as min/sec (e.g. "1.5 min/sec")
+/// </summary>
+public static class WaitRatioFormatter
+{
+    public static string Format(double waitRatio)
+    {
+        if (waitRatio < 0) waitRatio = 0;
+
+        if (waitRatio < 1.0)
+        {
+            var ms = waitRatio * 1000.0;
+            return ms < 10 ? $"{ms:N1} ms/sec" : $"{ms:N0} ms/sec";
+        }
+        if (waitRatio < 60.0)
+        {
+            return $"{waitRatio:N1} s/sec";
+        }
+        var min = waitRatio / 60.0;
+        return $"{min:N1} min/sec";
+    }
+}
+
 /// <summary>
 /// A single wait category aggregated over a time range.
 /// WaitRatio = SUM(total_query_wait_time_ms) / interval_ms.

From 3301e020134af23dea7b954aeb761be4740f3e32 Mon Sep 17 00:00:00 2001
From: rferraton <16419423+rferraton@users.noreply.github.com>
Date: Sat, 28 Mar 2026 18:43:18 +0100
Subject: [PATCH 29/31] - improve label readability for avg wait ratio by using
 black font over light grey background - switch wait color legend to the right
 of the global wait header

---
 .../Controls/WaitStatsProfileControl.axaml    | 26 +++++++++++--------
 .../Controls/WaitStatsRibbonControl.axaml.cs  | 16 ++++++++----
 2 files changed, 26 insertions(+), 16 deletions(-)

diff --git a/src/PlanViewer.App/Controls/WaitStatsProfileControl.axaml b/src/PlanViewer.App/Controls/WaitStatsProfileControl.axaml
index 9b83576..d8368da 100644
--- a/src/PlanViewer.App/Controls/WaitStatsProfileControl.axaml
+++ b/src/PlanViewer.App/Controls/WaitStatsProfileControl.axaml
@@ -1,27 +1,31 @@
 <UserControl xmlns="https://github.com/avaloniaui"
-xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
-xmlns:local="using:PlanViewer.App.Controls"
+             xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
+             xmlns:local="using:PlanViewer.App.Controls"
              x:Class="PlanViewer.App.Controls.WaitStatsProfileControl">
     <Grid RowDefinitions="Auto,*">
-        <!-- Header: toggle chart type -->
-        <StackPanel Grid.Row="0" Orientation="Horizontal" Spacing="6" Margin="4,2">
-            <Button x:Name="ToggleChartButton" Content="▤"
+        <!-- Header row: left controls + right-aligned legend button -->
+        <Grid Grid.Row="0" ColumnDefinitions="Auto,Auto,*,Auto" Margin="4,2">
+            <Button x:Name="ToggleChartButton" Grid.Column="0" Content="&#x25A4;"
                     Width="22" Height="22" Padding="0"
                     FontSize="12" Background="Transparent" BorderThickness="0"
                     Foreground="{DynamicResource ForegroundBrush}"
                     ToolTip.Tip="Toggle bar / ribbon chart"
                     Click="ToggleChart_Click"/>
-            <TextBlock x:Name="TitleText" Text="Wait Stats"
+            <TextBlock x:Name="TitleText" Grid.Column="1" Text="Wait Stats"
                        FontSize="11" FontWeight="SemiBold"
                        Foreground="{DynamicResource SlicerToggleBrush}"
-                       VerticalAlignment="Center"/>
-            <Button x:Name="LegendButton" Content="◆"
-                    Width="22" Height="22" Padding="0"
-                    FontSize="12" Background="Transparent" BorderThickness="0"
+                       VerticalAlignment="Center" Margin="6,0,0,0"/>
+            <!-- spacer -->
+            <Button x:Name="LegendButton" Grid.Column="3" Content="Legend"
+                    Height="20" Padding="8,0"
+                    FontSize="10"
+                    Background="Transparent" BorderThickness="1"
+                    BorderBrush="{DynamicResource ForegroundMutedBrush}"
                     Foreground="{DynamicResource ForegroundBrush}"
                     ToolTip.Tip="Show color legend"
+                    VerticalAlignment="Center"
                     Click="Legend_Click"/>
-        </StackPanel>
+        </Grid>
         <!-- Content area -->
         <Grid Grid.Row="1" x:Name="ContentArea" MinHeight="24">
             <local:WaitProfileBarControl x:Name="GlobalBar" PercentMode="True" IsVisible="False"/>
diff --git a/src/PlanViewer.App/Controls/WaitStatsRibbonControl.axaml.cs b/src/PlanViewer.App/Controls/WaitStatsRibbonControl.axaml.cs
index f948b5c..5805bea 100644
--- a/src/PlanViewer.App/Controls/WaitStatsRibbonControl.axaml.cs
+++ b/src/PlanViewer.App/Controls/WaitStatsRibbonControl.axaml.cs
@@ -215,14 +215,20 @@ private void Redraw()
                 };
                 RibbonCanvas.Children.Add(avgLine);
 
-                var avgLabel = new TextBlock
+                var avgLabel = new Border
                 {
-                    Text = $"avg:{WaitRatioFormatter.Format(avgWait)}",
-                    FontSize = 8,
-                    Foreground = dashBrush,
+                    Background = new SolidColorBrush(Color.Parse("#B0D0D0D0")),
+                    CornerRadius = new CornerRadius(3),
+                    Padding = new Thickness(4, 1),
+                    Child = new TextBlock
+                    {
+                        Text = $"avg:{WaitRatioFormatter.Format(avgWait)}",
+                        FontSize = 10,
+                        Foreground = Brushes.Black,
+                    },
                 };
                 Canvas.SetLeft(avgLabel, 2);
-                Canvas.SetTop(avgLabel, avgY - 12);
+                Canvas.SetTop(avgLabel, avgY - 16);
                 RibbonCanvas.Children.Add(avgLabel);
             }
         }

From 107d2d599c1ed078bfb071f394c89e89c55b1bd2 Mon Sep 17 00:00:00 2001
From: Erik Darling <2136037+erikdarlingdata@users.noreply.github.com>
Date: Sat, 28 Mar 2026 17:26:05 -0400
Subject: [PATCH 30/31] Fix wait stats cleanup: duplicate using, label overlap,
 avg label clipping

- Remove duplicate `using System;` in WaitStatsProfileControl
- Clamp avg line label position to prevent clipping at top of chart
- Skip day boundary labels when too dense to prevent overlap on wide ranges

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
---
 .../Controls/WaitStatsProfileControl.axaml.cs      |  1 -
 .../Controls/WaitStatsRibbonControl.axaml.cs       | 14 ++++++++++++--
 2 files changed, 12 insertions(+), 3 deletions(-)

diff --git a/src/PlanViewer.App/Controls/WaitStatsProfileControl.axaml.cs b/src/PlanViewer.App/Controls/WaitStatsProfileControl.axaml.cs
index 1f5aa26..647b40a 100644
--- a/src/PlanViewer.App/Controls/WaitStatsProfileControl.axaml.cs
+++ b/src/PlanViewer.App/Controls/WaitStatsProfileControl.axaml.cs
@@ -1,5 +1,4 @@
 using System;
-using System;
 using System.Collections.Generic;
 using System.Linq;
 using Avalonia;
diff --git a/src/PlanViewer.App/Controls/WaitStatsRibbonControl.axaml.cs b/src/PlanViewer.App/Controls/WaitStatsRibbonControl.axaml.cs
index 5805bea..123e96e 100644
--- a/src/PlanViewer.App/Controls/WaitStatsRibbonControl.axaml.cs
+++ b/src/PlanViewer.App/Controls/WaitStatsRibbonControl.axaml.cs
@@ -228,7 +228,7 @@ private void Redraw()
                     },
                 };
                 Canvas.SetLeft(avgLabel, 2);
-                Canvas.SetTop(avgLabel, avgY - 16);
+                Canvas.SetTop(avgLabel, Math.Max(0, avgY - 16));
                 RibbonCanvas.Children.Add(avgLabel);
             }
         }
@@ -246,8 +246,18 @@ private void Redraw()
 
         if (dayIndices.Count > 0)
         {
-            foreach (var i in dayIndices)
+            // Skip labels when day boundaries are too dense to avoid overlap
+            // ~40px per label is a reasonable minimum at fontSize=8
+            int labelSkip = 1;
+            if (dayIndices.Count > 1)
             {
+                var avgGapPx = (dayIndices[^1] - dayIndices[0]) * stepX / (dayIndices.Count - 1);
+                if (avgGapPx < 40) labelSkip = (int)Math.Ceiling(40.0 / avgGapPx);
+            }
+
+            for (int li = 0; li < dayIndices.Count; li += labelSkip)
+            {
+                var i = dayIndices[li];
                 var dt = allHours[i];
                 var tb = new TextBlock
                 {

From 30eeb3034806cd9306895309a2b7837a9ab6cb36 Mon Sep 17 00:00:00 2001
From: Erik Darling <2136037+erikdarlingdata@users.noreply.github.com>
Date: Sun, 29 Mar 2026 08:17:31 -0400
Subject: [PATCH 31/31] Bump to v1.3.0

Co-authored-by: Claude Sonnet 4.6 <noreply@anthropic.com>
---
 src/PlanViewer.App/PlanViewer.App.csproj                       | 2 +-
 src/PlanViewer.Cli/PlanViewer.Cli.csproj                       | 2 +-
 src/PlanViewer.Core/PlanViewer.Core.csproj                     | 2 +-
 src/PlanViewer.Ssms.Installer/PlanViewer.Ssms.Installer.csproj | 2 +-
 4 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/src/PlanViewer.App/PlanViewer.App.csproj b/src/PlanViewer.App/PlanViewer.App.csproj
index 689e095..956357d 100644
--- a/src/PlanViewer.App/PlanViewer.App.csproj
+++ b/src/PlanViewer.App/PlanViewer.App.csproj
@@ -6,7 +6,7 @@
     <ApplicationManifest>app.manifest</ApplicationManifest>
     <ApplicationIcon>EDD.ico</ApplicationIcon>
     <AvaloniaUseCompiledBindingsByDefault>true</AvaloniaUseCompiledBindingsByDefault>
-    <Version>1.2.5</Version>
+    <Version>1.3.0</Version>
     <Authors>Erik Darling</Authors>
     <Company>Darling Data LLC</Company>
     <Product>Performance Studio</Product>
diff --git a/src/PlanViewer.Cli/PlanViewer.Cli.csproj b/src/PlanViewer.Cli/PlanViewer.Cli.csproj
index 66a0e68..0e6c7ec 100644
--- a/src/PlanViewer.Cli/PlanViewer.Cli.csproj
+++ b/src/PlanViewer.Cli/PlanViewer.Cli.csproj
@@ -11,7 +11,7 @@
     <Nullable>enable</Nullable>
     <RootNamespace>PlanViewer.Cli</RootNamespace>
     <AssemblyName>planview</AssemblyName>
-    <Version>1.2.5</Version>
+    <Version>1.3.0</Version>
     <Authors>Erik Darling</Authors>
     <Company>Darling Data LLC</Company>
     <Product>Performance Studio</Product>
diff --git a/src/PlanViewer.Core/PlanViewer.Core.csproj b/src/PlanViewer.Core/PlanViewer.Core.csproj
index f02483d..1a3c43a 100644
--- a/src/PlanViewer.Core/PlanViewer.Core.csproj
+++ b/src/PlanViewer.Core/PlanViewer.Core.csproj
@@ -5,7 +5,7 @@
     <ImplicitUsings>enable</ImplicitUsings>
     <Nullable>enable</Nullable>
     <RootNamespace>PlanViewer.Core</RootNamespace>
-    <Version>1.2.5</Version>
+    <Version>1.3.0</Version>
     <Authors>Erik Darling</Authors>
     <Company>Darling Data LLC</Company>
     <Product>SQL Performance Studio</Product>
diff --git a/src/PlanViewer.Ssms.Installer/PlanViewer.Ssms.Installer.csproj b/src/PlanViewer.Ssms.Installer/PlanViewer.Ssms.Installer.csproj
index a8f8bc0..abe0822 100644
--- a/src/PlanViewer.Ssms.Installer/PlanViewer.Ssms.Installer.csproj
+++ b/src/PlanViewer.Ssms.Installer/PlanViewer.Ssms.Installer.csproj
@@ -6,7 +6,7 @@
     <AssemblyName>InstallSsmsExtension</AssemblyName>
     <RootNamespace>PlanViewer.Ssms.Installer</RootNamespace>
     <ApplicationManifest>app.manifest</ApplicationManifest>
-    <Version>1.2.5</Version>
+    <Version>1.3.0</Version>
     <Authors>Erik Darling</Authors>
     <Company>Darling Data LLC</Company>
     <Product>SQL Performance Studio</Product>