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"
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;
diff --git a/src/PlanViewer.App/Controls/QueryStoreGridControl.axaml b/src/PlanViewer.App/Controls/QueryStoreGridControl.axaml
index 697ad74..d5a1e16 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="v" 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..1769992 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;
 
     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,10 @@ 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)
+            if (_waitStatsEnabled && _slicerStartUtc.HasValue && _slicerEndUtc.HasValue)
+                _ = FetchWaitStatsAsync(_slicerStartUtc.Value, _slicerEndUtc.Value, ct);
         }
         catch (OperationCanceledException)
         {
@@ -355,6 +367,146 @@ private async void OnTimeRangeChanged(object? sender, TimeRangeChangedEventArgs
         await FetchPlansForRangeAsync();
     }
 
+    // ── Wait stats ─────────────────────────────────────────────────────────
+
+    private async System.Threading.Tasks.Task FetchWaitStatsAsync(
+        DateTime startUtc, DateTime endUtc, CancellationToken ct)
+    {
+        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
+            var ribbonData = await QueryStoreService.FetchGlobalWaitStatsRibbonAsync(
+                _connectionString, startUtc, endUtc, ct);
+            if (ct.IsCancellationRequested) { return; }
+            WaitStatsProfile.SetRibbonData(ribbonData);
+
+            // Per-plan
+            var planWaits = await QueryStoreService.FetchPlanWaitStatsAsync(
+                _connectionString, startUtc, endUtc, ct);
+            if (ct.IsCancellationRequested) { 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();
+        }
+        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;
+
+        var waitProfileCol = ResultsGrid.Columns
+            .FirstOrDefault(c => c.SortMemberPath == "WaitGrandTotalSort");
+        if (waitProfileCol != null)
+            waitProfileCol.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 +640,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 +956,8 @@ private void UpdateBarRatios()
                 row.SetBar(columnId, ratio, isSorted);
             }
         }
+
+        UpdateWaitBarMode();
     }
 
     private static IComparable GetSortKey(string columnTag, QueryStoreRow r) =>
@@ -829,6 +984,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 +1023,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 +1091,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;
+    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/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.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..a56f1dd
--- /dev/null
+++ b/src/PlanViewer.App/Controls/WaitStatsRibbonControl.axaml.cs
@@ -0,0 +1,203 @@
+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 into a lookup
+        var bucketLookup = _data
+            .GroupBy(d => d.IntervalStartUtc)
+            .ToDictionary(g => g.Key, g => g.ToList());
+
+        if (bucketLookup.Count == 0) return;
+
+        // 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 (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"
+        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 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
+            var catValues = new Dictionary<string, double>();
+            foreach (var cat in orderedCats)
+                catValues[cat] = 0;
+
+            foreach (var s in bucketItems)
+            {
+                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);
+
+                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) =>
+                {
+                    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 = 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);
+        }
+    }
+
+    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/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;
 }
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..dec2e83 100644
--- a/src/PlanViewer.Core/Services/QueryStoreService.cs
+++ b/src/PlanViewer.Core/Services/QueryStoreService.cs
@@ -424,4 +424,188 @@ 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) / 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)
+    {
+        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)
+        / 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
+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 + @"
+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 = reader.GetDouble(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;
+    }
 }