diff --git a/src/PlanViewer.App/Controls/QueryStoreGridControl.axaml.cs b/src/PlanViewer.App/Controls/QueryStoreGridControl.axaml.cs
index a192af6..08f3ee1 100644
--- a/src/PlanViewer.App/Controls/QueryStoreGridControl.axaml.cs
+++ b/src/PlanViewer.App/Controls/QueryStoreGridControl.axaml.cs
@@ -587,12 +587,19 @@ private void LoadHighlightedPlan_Click(object? sender, RoutedEventArgs e)
     private async void ViewHistory_Click(object? sender, RoutedEventArgs e)
     {
         if (ResultsGrid.SelectedItem is not QueryStoreRow row) return;
+        if (string.IsNullOrEmpty(row.QueryHash)) return;
+
+        var metricTag = QueryStoreHistoryWindow.MapOrderByToMetricTag(_lastFetchedOrderBy);
 
         var window = new QueryStoreHistoryWindow(
             _connectionString,
-            row.QueryId,
+            row.QueryHash,
             row.FullQueryText,
-            _database);
+            _database,
+            initialMetricTag: metricTag,
+            slicerStartUtc: _slicerStartUtc,
+            slicerEndUtc: _slicerEndUtc,
+            slicerDaysBack: _slicerDaysBack);
 
         var topLevel = Avalonia.Controls.TopLevel.GetTopLevel(this);
         if (topLevel is Window parentWindow)
diff --git a/src/PlanViewer.App/Dialogs/QueryStoreHistoryWindow.axaml b/src/PlanViewer.App/Dialogs/QueryStoreHistoryWindow.axaml
index 08e58fb..04d9188 100644
--- a/src/PlanViewer.App/Dialogs/QueryStoreHistoryWindow.axaml
+++ b/src/PlanViewer.App/Dialogs/QueryStoreHistoryWindow.axaml
@@ -9,26 +9,43 @@
         Icon="avares://PlanViewer.App/EDD.ico"
         Background="{DynamicResource BackgroundBrush}">
 
-    <Grid Margin="12" RowDefinitions="Auto,Auto,300,*,Auto">
+    <Grid Margin="12" RowDefinitions="Auto,Auto,Auto,300,*,Auto">
 
         <!-- Row 0: Header -->
         <StackPanel Grid.Row="0" Margin="0,0,0,8">
             <TextBlock x:Name="QueryIdentifierText" FontSize="16" FontWeight="Bold"
                        Foreground="{DynamicResource ForegroundBrush}"/>
-            <TextBlock x:Name="SummaryText" FontSize="12" Margin="0,4,0,0"
-                       Foreground="{DynamicResource ForegroundBrush}"
-                       TextTrimming="CharacterEllipsis"/>
         </StackPanel>
 
-        <!-- Row 1: Controls toolbar -->
-        <Border Grid.Row="1" Background="{DynamicResource BackgroundDarkBrush}" Padding="8,6"
+        <!-- Row 1: Query preview area -->
+        <Border Grid.Row="1" Background="{DynamicResource BackgroundDarkBrush}"
+                BorderBrush="{DynamicResource BorderBrush}" BorderThickness="1" CornerRadius="3"
+                Margin="0,0,0,8" MaxHeight="160" MinHeight="40">
+            <Grid ColumnDefinitions="*,Auto">
+                <ScrollViewer Grid.Column="0" HorizontalScrollBarVisibility="Auto"
+                              VerticalScrollBarVisibility="Auto">
+                    <TextBox x:Name="QueryTextBox" IsReadOnly="True"
+                             TextWrapping="Wrap" AcceptsReturn="True"
+                             FontFamily="Cascadia Mono,Consolas,monospace"
+                             FontSize="12" Padding="8,6"
+                             Foreground="{DynamicResource ForegroundBrush}"
+                             Background="Transparent" BorderThickness="0"/>
+                </ScrollViewer>
+                <Button Grid.Column="1" Content="Copy" Click="CopyQuery_Click"
+                        VerticalAlignment="Top" Margin="4,4,4,4"
+                        Padding="10,4" FontSize="11"
+                        Theme="{StaticResource AppButton}"/>
+            </Grid>
+        </Border>
+
+        <!-- Row 2: Controls toolbar -->
+        <Border Grid.Row="2" Background="{DynamicResource BackgroundDarkBrush}" Padding="8,6"
                 BorderBrush="{DynamicResource BorderBrush}" BorderThickness="1" CornerRadius="3"
                 Margin="0,0,0,8">
-            <StackPanel Orientation="Horizontal" Spacing="12">
-                <StackPanel Spacing="2">
-                    <TextBlock Text="Metric" FontSize="11"
-                               Foreground="{DynamicResource ForegroundBrush}"/>
+            <Grid ColumnDefinitions="Auto,*">
+                <StackPanel Grid.Column="0" Orientation="Horizontal" Spacing="12">
                     <ComboBox x:Name="MetricSelector" Width="200" Height="32" FontSize="13"
+                              VerticalAlignment="Center"
                               SelectionChanged="MetricSelector_SelectionChanged">
                         <ComboBoxItem Content="Avg CPU (ms)" Tag="AvgCpuMs" IsSelected="True"/>
                         <ComboBoxItem Content="Avg Duration (ms)" Tag="AvgDurationMs"/>
@@ -42,68 +59,99 @@
                         <ComboBoxItem Content="Total Reads" Tag="TotalLogicalReads"/>
                         <ComboBoxItem Content="Total Writes" Tag="TotalLogicalWrites"/>
                         <ComboBoxItem Content="Total Physical Reads" Tag="TotalPhysicalReads"/>
+                        <ComboBoxItem Content="Total Memory (MB)" Tag="TotalMemoryMb"/>
                         <ComboBoxItem Content="Executions" Tag="CountExecutions"/>
                     </ComboBox>
+                    <StackPanel Orientation="Horizontal" Spacing="4" VerticalAlignment="Center">
+                        <Button x:Name="RangePeriodButton" Content="Range Period" Click="RangePeriod_Click"
+                                Height="28" Padding="16,0" FontSize="12"
+                                Theme="{StaticResource AppButton}"/>
+                        <Button x:Name="FullHistoryButton" Content="Full History" Click="FullHistory_Click"
+                                Height="28" Padding="16,0" FontSize="12"
+                                Theme="{StaticResource AppButton}"/>
+                    </StackPanel>
                 </StackPanel>
-                <StackPanel Spacing="2">
-                    <TextBlock Text="Hours back" FontSize="11"
-                               Foreground="{DynamicResource ForegroundBrush}"/>
-                    <NumericUpDown x:Name="HoursBackBox" Value="24" Minimum="1" Maximum="720"
-                                   Width="120" Height="32" FontSize="13" FormatString="0"
-                                   HorizontalContentAlignment="Center"/>
-                </StackPanel>
-                <StackPanel Spacing="2" VerticalAlignment="Bottom">
-                    <Button x:Name="RefreshButton" Content="Refresh" Click="Refresh_Click"
-                            Height="28" Padding="16,0" FontSize="12"
-                            Theme="{StaticResource AppButton}"/>
-                </StackPanel>
-                <TextBlock x:Name="StatusText" VerticalAlignment="Center"
+                <TextBlock Grid.Column="1" x:Name="StatusText" VerticalAlignment="Center"
+                           HorizontalAlignment="Right"
                            FontSize="12" Foreground="{DynamicResource ForegroundBrush}"/>
-            </StackPanel>
+            </Grid>
         </Border>
 
-        <!-- Row 2: Chart -->
-        <Border Grid.Row="2" Background="{DynamicResource BackgroundDarkBrush}"
-                BorderBrush="{DynamicResource BorderBrush}" BorderThickness="1" CornerRadius="3"
-                Margin="0,0,0,8">
-            <scottplot:AvaPlot x:Name="HistoryChart"/>
-        </Border>
+        <!-- Row 3: Chart with legend overlay -->
+        <Grid Grid.Row="3" Margin="0,0,0,8">
+            <Border Background="{DynamicResource BackgroundDarkBrush}"
+                    BorderBrush="{DynamicResource BorderBrush}" BorderThickness="1" CornerRadius="3">
+                <scottplot:AvaPlot x:Name="HistoryChart"/>
+            </Border>
+            <!-- Legend toggle button (top-right overlay) -->
+            <Button x:Name="LegendToggleButton" Click="LegendToggle_Click"
+                    HorizontalAlignment="Right" VerticalAlignment="Top"
+                    Margin="0,26,18,10" Padding="8,3" FontSize="11"
+                    Background="#33333333" Foreground="{DynamicResource ForegroundBrush}"
+                    BorderThickness="1" BorderBrush="{DynamicResource BorderBrush}"
+                    CornerRadius="3">
+                <StackPanel Orientation="Horizontal" Spacing="4">
+                    <TextBlock Text="Legend"/>
+                    <TextBlock x:Name="LegendArrow" Text="▼" FontSize="9" VerticalAlignment="Center"/>
+                </StackPanel>
+            </Button>
+            <!-- Collapsible legend panel -->
+            <Border x:Name="LegendPanel" IsVisible="False"
+                    HorizontalAlignment="Right" VerticalAlignment="Top"
+                    Margin="0,52,18,10" MaxHeight="180" MinWidth="140"
+                    Background="{DynamicResource BackgroundDarkBrush}"
+                    BorderBrush="{DynamicResource BorderBrush}" BorderThickness="1" CornerRadius="3"
+                    Padding="6,4">
+                <ScrollViewer VerticalScrollBarVisibility="Auto" HorizontalScrollBarVisibility="Disabled">
+                    <StackPanel x:Name="LegendItemsPanel" Spacing="3"/>
+                </ScrollViewer>
+            </Border>
+        </Grid>
 
-        <!-- Row 3: DataGrid -->
-        <DataGrid Grid.Row="3" x:Name="HistoryDataGrid"
+        <!-- Row 4: DataGrid -->
+        <DataGrid Grid.Row="4" x:Name="HistoryDataGrid"
                   AutoGenerateColumns="False" IsReadOnly="True"
+                  SelectionMode="Extended"
                   CanUserSortColumns="True" CanUserReorderColumns="True"
                   CanUserResizeColumns="True"
                   GridLinesVisibility="Horizontal" HeadersVisibility="Column"
                   FontSize="11"
                   Background="{DynamicResource BackgroundDarkBrush}"
                   BorderThickness="0"
+                  SelectionChanged="HistoryDataGrid_SelectionChanged"
                   ScrollViewer.HorizontalScrollBarVisibility="Auto">
             <DataGrid.Columns>
-                <DataGridTextColumn Header="Plan ID" Binding="{ReflectionBinding PlanId}" Width="80"/>
+                <DataGridTemplateColumn Header="" Width="6" CanUserResize="False" CanUserSort="False" CanUserReorder="False">
+                    <DataGridTemplateColumn.CellTemplate>
+                        <DataTemplate>
+                            <Border x:Name="ColorIndicator" Width="6" CornerRadius="2"/>
+                        </DataTemplate>
+                    </DataGridTemplateColumn.CellTemplate>
+                </DataGridTemplateColumn>
                 <DataGridTextColumn Header="Plan Hash" Binding="{ReflectionBinding QueryPlanHash}" Width="150"/>
                 <DataGridTextColumn Header="Interval Start" Binding="{ReflectionBinding IntervalStartLocal}" Width="140"/>
                 <DataGridTextColumn Header="Executions" Binding="{ReflectionBinding CountExecutions}" Width="90"/>
-                <DataGridTextColumn Header="Avg Duration (ms)" Binding="{ReflectionBinding AvgDurationMs}" Width="130"/>
-                <DataGridTextColumn Header="Avg CPU (ms)" Binding="{ReflectionBinding AvgCpuMs}" Width="110"/>
-                <DataGridTextColumn Header="Avg Reads" Binding="{ReflectionBinding AvgLogicalReads}" Width="90"/>
-                <DataGridTextColumn Header="Avg Writes" Binding="{ReflectionBinding AvgLogicalWrites}" Width="90"/>
-                <DataGridTextColumn Header="Avg Phys Reads" Binding="{ReflectionBinding AvgPhysicalReads}" Width="110"/>
-                <DataGridTextColumn Header="Avg Memory (MB)" Binding="{ReflectionBinding AvgMemoryMb}" Width="120"/>
-                <DataGridTextColumn Header="Avg Rows" Binding="{ReflectionBinding AvgRowcount}" Width="80"/>
-                <DataGridTextColumn Header="Total Duration (ms)" Binding="{ReflectionBinding TotalDurationMs}" Width="140"/>
-                <DataGridTextColumn Header="Total CPU (ms)" Binding="{ReflectionBinding TotalCpuMs}" Width="120"/>
-                <DataGridTextColumn Header="Total Reads" Binding="{ReflectionBinding TotalLogicalReads}" Width="100"/>
-                <DataGridTextColumn Header="Total Writes" Binding="{ReflectionBinding TotalLogicalWrites}" Width="100"/>
-                <DataGridTextColumn Header="Total Phys Reads" Binding="{ReflectionBinding TotalPhysicalReads}" Width="120"/>
+                <DataGridTextColumn Header="Avg Duration (ms)" Binding="{ReflectionBinding AvgDurationMsDisplay}" Width="130"/>
+                <DataGridTextColumn Header="Avg CPU (ms)" Binding="{ReflectionBinding AvgCpuMsDisplay}" Width="110"/>
+                <DataGridTextColumn Header="Avg Reads" Binding="{ReflectionBinding AvgLogicalReadsDisplay}" Width="90"/>
+                <DataGridTextColumn Header="Avg Writes" Binding="{ReflectionBinding AvgLogicalWritesDisplay}" Width="90"/>
+                <DataGridTextColumn Header="Avg Phys Reads" Binding="{ReflectionBinding AvgPhysicalReadsDisplay}" Width="110"/>
+                <DataGridTextColumn Header="Avg Memory (MB)" Binding="{ReflectionBinding AvgMemoryMbDisplay}" Width="120"/>
+                <DataGridTextColumn Header="Avg Rows" Binding="{ReflectionBinding AvgRowcountDisplay}" Width="80"/>
+                <DataGridTextColumn Header="Total Duration (ms)" Binding="{ReflectionBinding TotalDurationMsDisplay}" Width="140"/>
+                <DataGridTextColumn Header="Total CPU (ms)" Binding="{ReflectionBinding TotalCpuMsDisplay}" Width="120"/>
+                <DataGridTextColumn Header="Total Reads" Binding="{ReflectionBinding TotalLogicalReadsDisplay}" Width="100"/>
+                <DataGridTextColumn Header="Total Writes" Binding="{ReflectionBinding TotalLogicalWritesDisplay}" Width="100"/>
+                <DataGridTextColumn Header="Total Phys Reads" Binding="{ReflectionBinding TotalPhysicalReadsDisplay}" Width="120"/>
+                <DataGridTextColumn Header="Total Memory (MB)" Binding="{ReflectionBinding TotalMemoryMbDisplay}" Width="120"/>
                 <DataGridTextColumn Header="Min DOP" Binding="{ReflectionBinding MinDop}" Width="70"/>
                 <DataGridTextColumn Header="Max DOP" Binding="{ReflectionBinding MaxDop}" Width="70"/>
                 <DataGridTextColumn Header="Last Execution" Binding="{ReflectionBinding LastExecutionLocal}" Width="140"/>
             </DataGrid.Columns>
         </DataGrid>
 
-        <!-- Row 4: Footer -->
-        <StackPanel Grid.Row="4" Orientation="Horizontal" HorizontalAlignment="Right"
+        <!-- Row 5: Footer -->
+        <StackPanel Grid.Row="5" Orientation="Horizontal" HorizontalAlignment="Right"
                     Margin="0,8,0,0">
             <Button Content="Close" Click="Close_Click" Padding="20,6" FontSize="12"
                     Theme="{StaticResource AppButton}"/>
diff --git a/src/PlanViewer.App/Dialogs/QueryStoreHistoryWindow.axaml.cs b/src/PlanViewer.App/Dialogs/QueryStoreHistoryWindow.axaml.cs
index f3b51af..b71aef8 100644
--- a/src/PlanViewer.App/Dialogs/QueryStoreHistoryWindow.axaml.cs
+++ b/src/PlanViewer.App/Dialogs/QueryStoreHistoryWindow.axaml.cs
@@ -7,7 +7,9 @@
 using Avalonia.Controls.Primitives;
 using Avalonia.Input;
 using Avalonia.Interactivity;
+using Avalonia.Layout;
 using Avalonia.Media;
+using Avalonia.VisualTree;
 using PlanViewer.Core.Models;
 using PlanViewer.Core.Services;
 using ScottPlot;
@@ -17,16 +19,46 @@ namespace PlanViewer.App.Dialogs;
 public partial class QueryStoreHistoryWindow : Window
 {
     private readonly string _connectionString;
-    private readonly long _queryId;
+    private readonly string _queryHash;
     private readonly string _database;
+    private readonly string _queryText;
+    private readonly DateTime? _slicerStartUtc;
+    private readonly DateTime? _slicerEndUtc;
+    private readonly int _maxHoursBack;
+    private bool _useFullHistory;
     private CancellationTokenSource? _fetchCts;
     private List<QueryStoreHistoryRow> _historyData = new();
-    private readonly List<(ScottPlot.Plottables.Scatter Scatter, string Label)> _scatters = new();
+    private readonly List<(ScottPlot.Plottables.Scatter Scatter, string Label, string PlanHash)> _scatters = new();
 
     // Hover tooltip
     private readonly Popup _tooltip;
     private readonly TextBlock _tooltipText;
 
+    // Box selection state
+    private bool _isDragging;
+    private Point _dragStartPoint;
+    private ScottPlot.Plottables.Rectangle? _selectionRect;
+    private readonly HashSet<int> _selectedRowIndices = new();
+
+    // Highlight markers for selected dots
+    private readonly List<ScottPlot.Plottables.Scatter> _highlightMarkers = new();
+
+    // Color mapping: plan hash -> color
+    private readonly Dictionary<string, ScottPlot.Color> _planHashColorMap = new();
+
+    // Legend state
+    private bool _legendExpanded;
+    private bool _suppressGridSelectionEvent;
+
+    // Legend highlight: which plan hash is currently highlighted (null = none)
+    private string? _highlightedPlanHash;
+    private ScottPlot.Plottables.HorizontalLine? _avgLine;
+
+    // Active button highlight brush
+    private static readonly SolidColorBrush ActiveButtonBg = new(Avalonia.Media.Color.FromRgb(0x4F, 0xC3, 0xF7));
+    private static readonly SolidColorBrush ActiveButtonFg = new(Avalonia.Media.Color.FromRgb(0x11, 0x12, 0x17));
+    private static readonly SolidColorBrush InactiveButtonFg = new(Avalonia.Media.Color.FromRgb(0x9D, 0xA5, 0xB4));
+
     private static readonly ScottPlot.Color[] PlanColors =
     {
         ScottPlot.Color.FromHex("#4FC3F7"),
@@ -39,21 +71,56 @@ public partial class QueryStoreHistoryWindow : Window
         ScottPlot.Color.FromHex("#A1887F"),
     };
 
-    public QueryStoreHistoryWindow(string connectionString, long queryId,
-        string queryText, string database, int hoursBack = 24)
+    // Map grid orderBy tags to history metric tags
+    private static readonly Dictionary<string, string> OrderByToMetricTag = new()
+    {
+        ["cpu"]              = "TotalCpuMs",
+        ["avg-cpu"]          = "AvgCpuMs",
+        ["duration"]         = "TotalDurationMs",
+        ["avg-duration"]     = "AvgDurationMs",
+        ["reads"]            = "TotalLogicalReads",
+        ["avg-reads"]        = "AvgLogicalReads",
+        ["writes"]           = "TotalLogicalWrites",
+        ["avg-writes"]       = "AvgLogicalWrites",
+        ["physical-reads"]   = "TotalPhysicalReads",
+        ["avg-physical-reads"] = "AvgPhysicalReads",
+        ["memory"]           = "TotalMemoryMb",
+        ["avg-memory"]       = "AvgMemoryMb",
+        ["executions"]       = "CountExecutions",
+    };
+
+    public QueryStoreHistoryWindow(string connectionString, string queryHash,
+        string queryText, string database,
+        string initialMetricTag = "AvgCpuMs",
+        DateTime? slicerStartUtc = null, DateTime? slicerEndUtc = null,
+        int slicerDaysBack = 30)
     {
         _connectionString = connectionString;
-        _queryId = queryId;
+        _queryHash = queryHash;
         _database = database;
+        _queryText = queryText;
+        _slicerStartUtc = slicerStartUtc;
+        _slicerEndUtc = slicerEndUtc;
+        _maxHoursBack = slicerDaysBack * 24;
         InitializeComponent();
 
-        HoursBackBox.Value = hoursBack;
+        QueryIdentifierText.Text = $"Query Store History: {queryHash} in [{database}]";
+        QueryTextBox.Text = queryText;
+
+        // Select initial metric in the combo box
+        var metricTag = initialMetricTag;
+        foreach (ComboBoxItem item in MetricSelector.Items)
+        {
+            if (item.Tag?.ToString() == metricTag)
+            {
+                MetricSelector.SelectedItem = item;
+                break;
+            }
+        }
 
-        var preview = queryText.Length > 120
-            ? queryText[..120].Replace("\n", " ").Replace("\r", "") + "..."
-            : queryText.Replace("\n", " ").Replace("\r", "");
-        QueryIdentifierText.Text = $"Query Store History: Query {queryId} in [{database}]";
-        SummaryText.Text = preview;
+        // Default to range period mode when slicer range is available
+        _useFullHistory = !(_slicerStartUtc.HasValue && _slicerEndUtc.HasValue);
+        UpdateRangeButtons();
 
         // Build hover tooltip
         _tooltipText = new TextBlock
@@ -81,10 +148,25 @@ public QueryStoreHistoryWindow(string connectionString, long queryId,
 
         HistoryChart.PointerMoved += OnChartPointerMoved;
         HistoryChart.PointerExited += (_, _) => _tooltip.IsOpen = false;
+        HistoryChart.PointerPressed += OnChartPointerPressed;
+        HistoryChart.PointerReleased += OnChartPointerReleased;
+
+        // Disable ScottPlot's built-in left-click-drag pan so our box selection works
+        HistoryChart.UserInputProcessor.LeftClickDragPan(enable: false);
 
         Opened += async (_, _) => await LoadHistoryAsync();
     }
 
+    /// <summary>
+    /// Maps a grid orderBy tag (e.g. "cpu", "avg-duration") to the history metric tag.
+    /// </summary>
+    public static string MapOrderByToMetricTag(string orderBy)
+    {
+        return OrderByToMetricTag.TryGetValue(orderBy?.ToLowerInvariant() ?? "", out var tag)
+            ? tag
+            : "AvgCpuMs";
+    }
+
     private async System.Threading.Tasks.Task LoadHistoryAsync()
     {
         _fetchCts?.Cancel();
@@ -92,20 +174,34 @@ private async System.Threading.Tasks.Task LoadHistoryAsync()
         _fetchCts = new CancellationTokenSource();
         var ct = _fetchCts.Token;
 
-        var hoursBack = (int)(HoursBackBox.Value ?? 24);
-        RefreshButton.IsEnabled = false;
         StatusText.Text = "Loading...";
 
         try
         {
-            _historyData = await QueryStoreService.FetchHistoryAsync(
-                _connectionString, _queryId, hoursBack, ct);
+            if (_useFullHistory)
+            {
+                _historyData = await QueryStoreService.FetchAggregateHistoryAsync(
+                    _connectionString, _queryHash, _maxHoursBack, ct);
+            }
+            else if (_slicerStartUtc.HasValue && _slicerEndUtc.HasValue)
+            {
+                _historyData = await QueryStoreService.FetchAggregateHistoryAsync(
+                    _connectionString, _queryHash, ct: ct,
+                    startUtc: _slicerStartUtc.Value, endUtc: _slicerEndUtc.Value);
+            }
+            else
+            {
+                _historyData = await QueryStoreService.FetchAggregateHistoryAsync(
+                    _connectionString, _queryHash, _maxHoursBack, ct);
+            }
 
+            BuildColorMap();
             HistoryDataGrid.ItemsSource = _historyData;
+            ApplyColorIndicators();
 
             if (_historyData.Count > 0)
             {
-                var planCount = _historyData.Select(r => r.PlanId).Distinct().Count();
+                var planCount = _historyData.Select(r => r.QueryPlanHash).Distinct().Count();
                 var totalExec = _historyData.Sum(r => r.CountExecutions);
                 var first = TimeDisplayHelper.ConvertForDisplay(_historyData.Min(r => r.IntervalStartUtc));
                 var last = TimeDisplayHelper.ConvertForDisplay(_historyData.Max(r => r.IntervalStartUtc));
@@ -119,6 +215,7 @@ private async System.Threading.Tasks.Task LoadHistoryAsync()
             }
 
             UpdateChart();
+            PopulateLegendPanel();
         }
         catch (OperationCanceledException)
         {
@@ -128,16 +225,212 @@ private async System.Threading.Tasks.Task LoadHistoryAsync()
         {
             StatusText.Text = ex.Message.Length > 80 ? ex.Message[..80] + "..." : ex.Message;
         }
-        finally
+    }
+
+    private void BuildColorMap()
+    {
+        _planHashColorMap.Clear();
+        var hashes = _historyData.Select(r => r.QueryPlanHash).Distinct().OrderBy(h => h).ToList();
+        for (int i = 0; i < hashes.Count; i++)
+            _planHashColorMap[hashes[i]] = PlanColors[i % PlanColors.Length];
+    }
+
+    private void ApplyColorIndicators()
+    {
+        HistoryDataGrid.LoadingRow -= OnDataGridLoadingRow;
+        HistoryDataGrid.LoadingRow += OnDataGridLoadingRow;
+    }
+
+    private void OnDataGridLoadingRow(object? sender, DataGridRowEventArgs e)
+    {
+        if (e.Row.DataContext is QueryStoreHistoryRow row &&
+            _planHashColorMap.TryGetValue(row.QueryPlanHash, out var color))
         {
-            RefreshButton.IsEnabled = true;
+            var avColor = Avalonia.Media.Color.FromRgb(color.R, color.G, color.B);
+            var brush = new SolidColorBrush(avColor);
+            e.Row.Tag = brush;
+
+            // Try to apply immediately (works for recycled rows whose visual tree already exists)
+            if (TryApplyColorIndicator(e.Row, brush))
+                return;
+        }
+
+        // Visual tree not ready yet (first load) — defer to Loaded
+        e.Row.Loaded -= OnRowLoaded;
+        e.Row.Loaded += OnRowLoaded;
+    }
+
+    private void OnRowLoaded(object? sender, RoutedEventArgs e)
+    {
+        if (sender is not DataGridRow dgRow) return;
+        dgRow.Loaded -= OnRowLoaded;
+
+        if (dgRow.Tag is SolidColorBrush brush)
+            TryApplyColorIndicator(dgRow, brush);
+    }
+
+    private bool TryApplyColorIndicator(DataGridRow dgRow, SolidColorBrush brush)
+    {
+        var presenter = FindVisualChild<DataGridCellsPresenter>(dgRow);
+        if (presenter == null) return false;
+
+        var cell = presenter.Children.OfType<DataGridCell>().FirstOrDefault();
+        if (cell == null) return false;
+
+        var border = FindVisualChild<Border>(cell, "ColorIndicator");
+        if (border == null) return false;
+
+        border.Background = brush;
+        return true;
+    }
+
+    private static T? FindVisualChild<T>(Avalonia.Visual parent, string? name = null) where T : Avalonia.Visual
+    {
+        if (parent is T t && (name == null || (t is Control c && c.Name == name)))
+            return t;
+
+        var children = parent.GetVisualChildren();
+        foreach (var child in children)
+        {
+            if (child is Avalonia.Visual vc)
+            {
+                var found = FindVisualChild<T>(vc, name);
+                if (found != null) return found;
+            }
+        }
+        return null;
+    }
+
+    // ── Legend ────────────────────────────────────────────────────────────
+
+    private void PopulateLegendPanel()
+    {
+        LegendItemsPanel.Children.Clear();
+        foreach (var (hash, color) in _planHashColorMap.OrderBy(kv => kv.Key))
+        {
+            var avColor = Avalonia.Media.Color.FromRgb(color.R, color.G, color.B);
+            var item = new StackPanel
+            {
+                Orientation = Avalonia.Layout.Orientation.Horizontal,
+                Spacing = 6,
+                Tag = hash,
+                Cursor = new Avalonia.Input.Cursor(Avalonia.Input.StandardCursorType.Hand)
+            };
+            item.Children.Add(new Border
+            {
+                Width = 12, Height = 12,
+                CornerRadius = new CornerRadius(2),
+                Background = new SolidColorBrush(avColor),
+                VerticalAlignment = Avalonia.Layout.VerticalAlignment.Center
+            });
+            item.Children.Add(new TextBlock
+            {
+                Text = hash,
+                FontSize = 11,
+                VerticalAlignment = Avalonia.Layout.VerticalAlignment.Center,
+                Foreground = new SolidColorBrush(Avalonia.Media.Color.FromRgb(0xE0, 0xE0, 0xE0))
+            });
+            item.PointerPressed += OnLegendItemClicked;
+            LegendItemsPanel.Children.Add(item);
         }
     }
 
+    private void OnLegendItemClicked(object? sender, PointerPressedEventArgs e)
+    {
+        if (sender is not StackPanel panel || panel.Tag is not string planHash) return;
+
+        // Toggle: click again to deselect
+        if (_highlightedPlanHash == planHash)
+            _highlightedPlanHash = null;
+        else
+            _highlightedPlanHash = planHash;
+
+        ApplyPlanHighlight();
+        UpdateLegendVisuals();
+    }
+
+    private void UpdateLegendVisuals()
+    {
+        foreach (var child in LegendItemsPanel.Children)
+        {
+            if (child is not StackPanel panel || panel.Tag is not string hash) continue;
+            var isActive = _highlightedPlanHash == null || _highlightedPlanHash == hash;
+            panel.Opacity = isActive ? 1.0 : 0.4;
+        }
+    }
+
+    private void ApplyPlanHighlight()
+    {
+        var tag = (MetricSelector.SelectedItem as ComboBoxItem)?.Tag?.ToString() ?? "AvgCpuMs";
+
+        foreach (var (scatter, _, planHash) in _scatters)
+        {
+            if (_highlightedPlanHash == null)
+            {
+                // No highlight: restore normal appearance
+                var color = _planHashColorMap.GetValueOrDefault(planHash, PlanColors[0]);
+                scatter.Color = color.WithAlpha(140);
+                scatter.LineWidth = 2;
+                scatter.MarkerSize = 8;
+            }
+            else if (planHash == _highlightedPlanHash)
+            {
+                // Highlighted plan: emphasized
+                var color = _planHashColorMap.GetValueOrDefault(planHash, PlanColors[0]);
+                scatter.Color = color.WithAlpha(220);
+                scatter.LineWidth = 4;
+                scatter.MarkerSize = 10;
+            }
+            else
+            {
+                // Other plans: dimmed
+                var color = _planHashColorMap.GetValueOrDefault(planHash, PlanColors[0]);
+                scatter.Color = color.WithAlpha(40);
+                scatter.LineWidth = 1;
+                scatter.MarkerSize = 5;
+            }
+        }
+
+        // Recompute average line based on highlighted plan or all data
+        if (_avgLine != null)
+        {
+            var relevantRows = _highlightedPlanHash != null
+                ? _historyData.Where(r => r.QueryPlanHash == _highlightedPlanHash).ToList()
+                : _historyData;
+
+            if (relevantRows.Count > 0)
+            {
+                var avg = relevantRows.Select(r => GetMetricValue(r, tag)).Average();
+                _avgLine.Y = avg;
+                _avgLine.Text = $"avg: {avg:N0}";
+                _avgLine.IsVisible = true;
+            }
+            else
+            {
+                _avgLine.IsVisible = false;
+            }
+        }
+
+        HistoryChart.Refresh();
+    }
+
+    private void LegendToggle_Click(object? sender, RoutedEventArgs e)
+    {
+        _legendExpanded = !_legendExpanded;
+        LegendPanel.IsVisible = _legendExpanded;
+        LegendArrow.Text = _legendExpanded ? "\u25b2" : "\u25bc";
+    }
+
+    // ── Chart ────────────────────────────────────────────────────────────
+
     private void UpdateChart()
     {
         HistoryChart.Plot.Clear();
         _scatters.Clear();
+        _selectionRect = null;
+        _highlightMarkers.Clear();
+        _avgLine = null;
+        _highlightedPlanHash = null;
 
         if (_historyData.Count == 0)
         {
@@ -150,37 +443,375 @@ private void UpdateChart()
         var label = selected?.Content?.ToString() ?? "Avg CPU (ms)";
 
         var planGroups = _historyData
-            .GroupBy(r => r.PlanId)
+            .GroupBy(r => r.QueryPlanHash)
             .OrderBy(g => g.Key)
             .ToList();
 
-        int colorIndex = 0;
         foreach (var group in planGroups)
         {
+            var planHash = group.Key;
+            var color = _planHashColorMap.GetValueOrDefault(planHash, PlanColors[0]);
+
             var ordered = group.OrderBy(r => r.IntervalStartUtc).ToList();
             var xs = ordered.Select(r => TimeDisplayHelper.ConvertForDisplay(r.IntervalStartUtc).ToOADate()).ToArray();
             var ys = ordered.Select(r => GetMetricValue(r, tag)).ToArray();
 
             var scatter = HistoryChart.Plot.Add.Scatter(xs, ys);
-            scatter.Color = PlanColors[colorIndex % PlanColors.Length];
-            scatter.LegendText = $"Plan {group.Key}";
+            scatter.Color = color.WithAlpha(140);
+            scatter.LegendText = "";
             scatter.LineWidth = 2;
-            scatter.MarkerSize = ordered.Count <= 2 ? 8 : 4;
+            scatter.MarkerSize = 8;
+            scatter.MarkerShape = MarkerShape.FilledCircle;
+            scatter.MarkerLineColor = ScottPlot.Color.FromHex("#AAAAAA");
+            scatter.MarkerLineWidth = 1f;
 
-            _scatters.Add((scatter, $"Plan {group.Key}"));
-            colorIndex++;
+            _scatters.Add((scatter, planHash.Length > 10 ? planHash[..10] : planHash, planHash));
         }
 
-        HistoryChart.Plot.Axes.DateTimeTicksBottom();
+        // Add average line with label positioned just above the line
+        var allValues = _historyData.Select(r => GetMetricValue(r, tag)).ToArray();
+        if (allValues.Length > 0)
+        {
+            var avg = allValues.Average();
+            _avgLine = HistoryChart.Plot.Add.HorizontalLine(avg);
+            _avgLine.Color = ScottPlot.Color.FromHex("#FFD54F").WithAlpha(150);
+            _avgLine.LineWidth = 2f;
+            _avgLine.LinePattern = LinePattern.DenselyDashed;
+            _avgLine.Text = $"avg: {avg:N0}";
+            _avgLine.LabelFontColor = ScottPlot.Color.FromHex("#9DA5B4");
+            _avgLine.LabelFontSize = 11;
+            _avgLine.LabelBackgroundColor = ScottPlot.Color.FromHex("#333333").WithAlpha(170);
+            _avgLine.LabelOppositeAxis = false;
+            _avgLine.LabelRotation = 0;
+            _avgLine.LabelAlignment = Alignment.LowerLeft;
+            _avgLine.LabelOffsetX = 38;
+            _avgLine.LabelOffsetY = -8;
+        }
+
+        // Y-axis always includes 0 as origin
+        HistoryChart.Plot.Axes.AutoScale();
+        var yLimits = HistoryChart.Plot.Axes.GetLimits();
+        HistoryChart.Plot.Axes.SetLimitsY(0, yLimits.Top * 1.1);
+
+        // Disable ScottPlot's built-in legend — we use our custom overlay
+        HistoryChart.Plot.HideLegend();
+
+        // Smart X-axis labels
+        ConfigureSmartXAxis();
+
         HistoryChart.Plot.YLabel(label);
         ApplyDarkTheme();
         HistoryChart.Refresh();
     }
 
+    private void ConfigureSmartXAxis()
+    {
+        if (_historyData.Count == 0) return;
+
+        var minTime = _historyData.Min(r => r.IntervalStartUtc);
+        var maxTime = _historyData.Max(r => r.IntervalStartUtc);
+        var span = maxTime - minTime;
+
+        HistoryChart.Plot.Axes.DateTimeTicksBottom();
+
+        if (span.TotalHours <= 48)
+        {
+            HistoryChart.Plot.Axes.Bottom.TickLabelStyle.ForeColor = ScottPlot.Color.FromHex("#9DA5B4");
+            HistoryChart.Plot.Axes.Bottom.TickGenerator = new ScottPlot.TickGenerators.DateTimeAutomatic
+            {
+                LabelFormatter = dt => dt.ToString("HH:mm\nMM/dd")
+            };
+        }
+        else if (span.TotalDays <= 14)
+        {
+            HistoryChart.Plot.Axes.Bottom.TickGenerator = new ScottPlot.TickGenerators.DateTimeAutomatic
+            {
+                LabelFormatter = dt => dt.ToString("HH:mm\nMM/dd")
+            };
+        }
+        else
+        {
+            HistoryChart.Plot.Axes.Bottom.TickGenerator = new ScottPlot.TickGenerators.DateTimeAutomatic
+            {
+                LabelFormatter = dt => dt.ToString("MM/dd\nyyyy")
+            };
+        }
+    }
+
+    // ── Dot highlighting on chart ────────────────────────────────────────
+
+    private void ClearHighlightMarkers()
+    {
+        foreach (var m in _highlightMarkers)
+            HistoryChart.Plot.Remove(m);
+        _highlightMarkers.Clear();
+    }
+
+    private void HighlightDotsOnChart(HashSet<int> rowIndices)
+    {
+        ClearHighlightMarkers();
+        if (rowIndices.Count == 0)
+        {
+            HistoryChart.Refresh();
+            return;
+        }
+
+        var tag = (MetricSelector.SelectedItem as ComboBoxItem)?.Tag?.ToString() ?? "AvgCpuMs";
+
+        // Group selected rows by plan hash for coloring
+        var groups = rowIndices
+            .Where(i => i >= 0 && i < _historyData.Count)
+            .Select(i => _historyData[i])
+            .GroupBy(r => r.QueryPlanHash);
+
+        foreach (var group in groups)
+        {
+            var color = _planHashColorMap.GetValueOrDefault(group.Key, PlanColors[0]);
+            var xs = group.Select(r => TimeDisplayHelper.ConvertForDisplay(r.IntervalStartUtc).ToOADate()).ToArray();
+            var ys = group.Select(r => GetMetricValue(r, tag)).ToArray();
+
+            // Bigger filled dot with white border for emphasis
+            var highlight = HistoryChart.Plot.Add.Scatter(xs, ys);
+            highlight.LineWidth = 0;
+            highlight.MarkerSize = 14;
+            highlight.MarkerShape = MarkerShape.FilledCircle;
+            highlight.Color = color;
+            highlight.MarkerLineColor = ScottPlot.Colors.White;
+            highlight.MarkerLineWidth = 2.5f;
+
+            _highlightMarkers.Add(highlight);
+        }
+
+        HistoryChart.Refresh();
+    }
+
+    // ── Box selection ────────────────────────────────────────────────────
+
+    private void OnChartPointerPressed(object? sender, PointerPressedEventArgs e)
+    {
+        if (!e.GetCurrentPoint(HistoryChart).Properties.IsLeftButtonPressed) return;
+
+        _isDragging = true;
+        _dragStartPoint = e.GetPosition(HistoryChart);
+
+        // Remove old selection rect
+        if (_selectionRect != null)
+        {
+            HistoryChart.Plot.Remove(_selectionRect);
+            _selectionRect = null;
+        }
+
+        e.Handled = true;
+    }
+
+    private void OnChartPointerReleased(object? sender, PointerReleasedEventArgs e)
+    {
+        if (!_isDragging) return;
+        _isDragging = false;
+
+        // Remove the drag preview rect
+        if (_selectionRect != null)
+        {
+            HistoryChart.Plot.Remove(_selectionRect);
+            _selectionRect = null;
+        }
+
+        var endPoint = e.GetPosition(HistoryChart);
+        var startCoords = PixelToCoordinates(_dragStartPoint);
+        var endCoords = PixelToCoordinates(endPoint);
+
+        // Determine if this was a click (small drag) or a box selection
+        var dx = Math.Abs(endPoint.X - _dragStartPoint.X);
+        var dy = Math.Abs(endPoint.Y - _dragStartPoint.Y);
+
+        if (dx < 5 && dy < 5)
+        {
+            HandleSingleClickSelection(endPoint);
+        }
+        else
+        {
+            HandleBoxSelection(startCoords, endCoords);
+        }
+
+        e.Handled = true;
+    }
+
+    private ScottPlot.Coordinates PixelToCoordinates(Point pos)
+    {
+        var scaling = HistoryChart.Bounds.Width > 0
+            ? (float)(HistoryChart.Plot.RenderManager.LastRender.FigureRect.Width / HistoryChart.Bounds.Width)
+            : 1f;
+        var pixel = new ScottPlot.Pixel((float)(pos.X * scaling), (float)(pos.Y * scaling));
+        return HistoryChart.Plot.GetCoordinates(pixel);
+    }
+
+    private void HandleSingleClickSelection(Point clickPoint)
+    {
+        if (_scatters.Count == 0) return;
+
+        var scaling = HistoryChart.Bounds.Width > 0
+            ? (float)(HistoryChart.Plot.RenderManager.LastRender.FigureRect.Width / HistoryChart.Bounds.Width)
+            : 1f;
+        var pixel = new ScottPlot.Pixel((float)(clickPoint.X * scaling), (float)(clickPoint.Y * scaling));
+        var mouseCoords = HistoryChart.Plot.GetCoordinates(pixel);
+
+        double bestDist = double.MaxValue;
+        ScottPlot.DataPoint bestPoint = default;
+        string bestPlanHash = "";
+        bool found = false;
+
+        foreach (var (scatter, _, planHash) in _scatters)
+        {
+            var nearest = scatter.Data.GetNearest(mouseCoords, HistoryChart.Plot.LastRender);
+            if (!nearest.IsReal) continue;
+
+            var nearestPixel = HistoryChart.Plot.GetPixel(
+                new ScottPlot.Coordinates(nearest.X, nearest.Y));
+            var d = Math.Sqrt(Math.Pow(nearestPixel.X - pixel.X, 2) + Math.Pow(nearestPixel.Y - pixel.Y, 2));
+
+            if (d < 30 && d < bestDist)
+            {
+                bestDist = d;
+                bestPoint = nearest;
+                bestPlanHash = planHash;
+                found = true;
+            }
+        }
+
+        _selectedRowIndices.Clear();
+
+        if (found)
+        {
+            var clickedTime = DateTime.FromOADate(bestPoint.X);
+            for (int i = 0; i < _historyData.Count; i++)
+            {
+                var row = _historyData[i];
+                var displayTime = TimeDisplayHelper.ConvertForDisplay(row.IntervalStartUtc);
+                if (row.QueryPlanHash == bestPlanHash &&
+                    Math.Abs((displayTime - clickedTime).TotalMinutes) < 1)
+                {
+                    _selectedRowIndices.Add(i);
+                }
+            }
+        }
+
+        HighlightDotsOnChart(_selectedRowIndices);
+        HighlightGridRows();
+    }
+
+    private void HandleBoxSelection(ScottPlot.Coordinates start, ScottPlot.Coordinates end)
+    {
+        var x1 = Math.Min(start.X, end.X);
+        var x2 = Math.Max(start.X, end.X);
+        var y1 = Math.Min(start.Y, end.Y);
+        var y2 = Math.Max(start.Y, end.Y);
+
+        // Find all data points inside the box
+        var tag = (MetricSelector.SelectedItem as ComboBoxItem)?.Tag?.ToString() ?? "AvgCpuMs";
+        _selectedRowIndices.Clear();
+
+        for (int i = 0; i < _historyData.Count; i++)
+        {
+            var row = _historyData[i];
+            var xVal = TimeDisplayHelper.ConvertForDisplay(row.IntervalStartUtc).ToOADate();
+            var yVal = GetMetricValue(row, tag);
+
+            if (xVal >= x1 && xVal <= x2 && yVal >= y1 && yVal <= y2)
+                _selectedRowIndices.Add(i);
+        }
+
+        HighlightDotsOnChart(_selectedRowIndices);
+        HighlightGridRows();
+    }
+
+    private void HighlightGridRows()
+    {
+        // Scroll to first selected row if any
+        if (_selectedRowIndices.Count > 0)
+        {
+            var firstIdx = _selectedRowIndices.Min();
+            if (firstIdx < _historyData.Count)
+                HistoryDataGrid.ScrollIntoView(_historyData[firstIdx], null);
+        }
+
+        HistoryDataGrid.LoadingRow -= OnHighlightLoadingRow;
+        HistoryDataGrid.LoadingRow += OnHighlightLoadingRow;
+
+        // Force grid to re-render rows
+        _suppressGridSelectionEvent = true;
+        var source = _historyData;
+        HistoryDataGrid.ItemsSource = null;
+        HistoryDataGrid.ItemsSource = source;
+        _suppressGridSelectionEvent = false;
+    }
+
+    private void OnHighlightLoadingRow(object? sender, DataGridRowEventArgs e)
+    {
+        var idx = e.Row.GetIndex();
+        if (_selectedRowIndices.Contains(idx))
+        {
+            e.Row.Background = new SolidColorBrush(Avalonia.Media.Color.FromArgb(60, 79, 195, 247));
+        }
+        else
+        {
+            e.Row.Background = Brushes.Transparent;
+        }
+    }
+
+    // ── Grid row click → chart highlight ─────────────────────────────────
+
+    private void HistoryDataGrid_SelectionChanged(object? sender, SelectionChangedEventArgs e)
+    {
+        if (_suppressGridSelectionEvent) return;
+
+        _selectedRowIndices.Clear();
+        if (HistoryDataGrid.SelectedItems != null)
+        {
+            foreach (var item in HistoryDataGrid.SelectedItems)
+            {
+                if (item is QueryStoreHistoryRow row)
+                {
+                    var idx = _historyData.IndexOf(row);
+                    if (idx >= 0)
+                        _selectedRowIndices.Add(idx);
+                }
+            }
+        }
+
+        HighlightDotsOnChart(_selectedRowIndices);
+    }
+
+    // ── Hover tooltip ────────────────────────────────────────────────────
+
     private void OnChartPointerMoved(object? sender, PointerEventArgs e)
     {
         if (_scatters.Count == 0) { _tooltip.IsOpen = false; return; }
 
+        // If dragging, update selection rectangle preview
+        if (_isDragging)
+        {
+            var currentPoint = e.GetPosition(HistoryChart);
+            var startCoords = PixelToCoordinates(_dragStartPoint);
+            var currentCoords = PixelToCoordinates(currentPoint);
+
+            if (_selectionRect != null)
+                HistoryChart.Plot.Remove(_selectionRect);
+
+            var x1 = Math.Min(startCoords.X, currentCoords.X);
+            var x2 = Math.Max(startCoords.X, currentCoords.X);
+            var y1 = Math.Min(startCoords.Y, currentCoords.Y);
+            var y2 = Math.Max(startCoords.Y, currentCoords.Y);
+
+            _selectionRect = HistoryChart.Plot.Add.Rectangle(x1, x2, y1, y2);
+            _selectionRect.FillColor = ScottPlot.Color.FromHex("#4FC3F7").WithAlpha(30);
+            _selectionRect.LineColor = ScottPlot.Color.FromHex("#4FC3F7").WithAlpha(120);
+            _selectionRect.LineWidth = 1;
+            HistoryChart.Refresh();
+
+            _tooltip.IsOpen = false;
+            return;
+        }
+
         try
         {
             var pos = e.GetPosition(HistoryChart);
@@ -195,21 +826,21 @@ private void OnChartPointerMoved(object? sender, PointerEventArgs e)
             string bestLabel = "";
             bool found = false;
 
-            foreach (var (scatter, label) in _scatters)
+            foreach (var (scatter, chartLabel, _) in _scatters)
             {
                 var nearest = scatter.Data.GetNearest(mouseCoords, HistoryChart.Plot.LastRender);
                 if (!nearest.IsReal) continue;
 
                 var nearestPixel = HistoryChart.Plot.GetPixel(
                     new ScottPlot.Coordinates(nearest.X, nearest.Y));
-                double dx = Math.Abs(nearestPixel.X - pixel.X);
-                double dy = Math.Abs(nearestPixel.Y - pixel.Y);
+                double ddx = Math.Abs(nearestPixel.X - pixel.X);
+                double ddy = Math.Abs(nearestPixel.Y - pixel.Y);
 
-                if (dx < 80 && dy < bestDist)
+                if (ddx < 80 && ddy < bestDist)
                 {
-                    bestDist = dy;
+                    bestDist = ddy;
                     bestPoint = nearest;
-                    bestLabel = label;
+                    bestLabel = chartLabel;
                     found = true;
                 }
             }
@@ -246,7 +877,8 @@ private void OnChartPointerMoved(object? sender, PointerEventArgs e)
         "TotalLogicalReads"  => row.TotalLogicalReads,
         "TotalLogicalWrites" => row.TotalLogicalWrites,
         "TotalPhysicalReads" => row.TotalPhysicalReads,
-        "CountExecutions"    => row.CountExecutions,
+        "TotalMemoryMb"      => row.TotalMemoryMb,
+		"CountExecutions"    => row.CountExecutions,
         _                    => row.AvgCpuMs,
     };
 
@@ -263,9 +895,40 @@ private void ApplyDarkTheme()
         HistoryChart.Plot.Grid.MajorLineColor = grid;
         HistoryChart.Plot.Axes.Bottom.TickLabelStyle.ForeColor = text;
         HistoryChart.Plot.Axes.Left.TickLabelStyle.ForeColor = text;
-        HistoryChart.Plot.Legend.BackgroundColor = fig;
-        HistoryChart.Plot.Legend.FontColor = ScottPlot.Color.FromHex("#E4E6EB");
-        HistoryChart.Plot.Legend.OutlineColor = ScottPlot.Color.FromHex("#3A3D45");
+    }
+
+    private void UpdateRangeButtons()
+    {
+        if (_useFullHistory)
+        {
+            FullHistoryButton.Background = ActiveButtonBg;
+            FullHistoryButton.Foreground = ActiveButtonFg;
+            RangePeriodButton.Background = Brushes.Transparent;
+            RangePeriodButton.Foreground = InactiveButtonFg;
+        }
+        else
+        {
+            RangePeriodButton.Background = ActiveButtonBg;
+            RangePeriodButton.Foreground = ActiveButtonFg;
+            FullHistoryButton.Background = Brushes.Transparent;
+            FullHistoryButton.Foreground = InactiveButtonFg;
+        }
+    }
+
+    private async void RangePeriod_Click(object? sender, RoutedEventArgs e)
+    {
+        if (!_useFullHistory) return;
+        _useFullHistory = false;
+        UpdateRangeButtons();
+        await LoadHistoryAsync();
+    }
+
+    private async void FullHistory_Click(object? sender, RoutedEventArgs e)
+    {
+        if (_useFullHistory) return;
+        _useFullHistory = true;
+        UpdateRangeButtons();
+        await LoadHistoryAsync();
     }
 
     private void MetricSelector_SelectionChanged(object? sender, SelectionChangedEventArgs e)
@@ -274,9 +937,12 @@ private void MetricSelector_SelectionChanged(object? sender, SelectionChangedEve
             UpdateChart();
     }
 
-    private async void Refresh_Click(object? sender, RoutedEventArgs e)
+    private async void CopyQuery_Click(object? sender, RoutedEventArgs e)
     {
-        await LoadHistoryAsync();
+        if (string.IsNullOrEmpty(_queryText)) return;
+        var clipboard = TopLevel.GetTopLevel(this)?.Clipboard;
+        if (clipboard != null)
+            await clipboard.SetTextAsync(_queryText);
     }
 
     private void Close_Click(object? sender, RoutedEventArgs e) => Close();
diff --git a/src/PlanViewer.Core/Models/QueryStoreHistoryRow.cs b/src/PlanViewer.Core/Models/QueryStoreHistoryRow.cs
index b38c6ba..b275acf 100644
--- a/src/PlanViewer.Core/Models/QueryStoreHistoryRow.cs
+++ b/src/PlanViewer.Core/Models/QueryStoreHistoryRow.cs
@@ -23,11 +23,25 @@ public class QueryStoreHistoryRow
     public double TotalLogicalReads { get; set; }
     public double TotalLogicalWrites { get; set; }
     public double TotalPhysicalReads { get; set; }
-
-    public int MinDop { get; set; }
+    public double TotalMemoryMb { get; set; }
+	public int MinDop { get; set; }
     public int MaxDop { get; set; }
     public DateTime? LastExecutionUtc { get; set; }
 
-    public string IntervalStartLocal => TimeDisplayHelper.FormatForDisplay(IntervalStartUtc);
+    // Display-formatted properties (2 decimal places)
+    public string AvgDurationMsDisplay => AvgDurationMs.ToString("N2");
+    public string AvgCpuMsDisplay => AvgCpuMs.ToString("N2");
+    public string AvgLogicalReadsDisplay => AvgLogicalReads.ToString("N2");
+    public string AvgLogicalWritesDisplay => AvgLogicalWrites.ToString("N2");
+    public string AvgPhysicalReadsDisplay => AvgPhysicalReads.ToString("N2");
+    public string AvgMemoryMbDisplay => AvgMemoryMb.ToString("N2");
+    public string AvgRowcountDisplay => AvgRowcount.ToString("N2");
+    public string TotalDurationMsDisplay => TotalDurationMs.ToString("N2");
+    public string TotalCpuMsDisplay => TotalCpuMs.ToString("N2");
+    public string TotalLogicalReadsDisplay => TotalLogicalReads.ToString("N0");
+    public string TotalLogicalWritesDisplay => TotalLogicalWrites.ToString("N0");
+    public string TotalPhysicalReadsDisplay => TotalPhysicalReads.ToString("N0");
+    public string TotalMemoryMbDisplay => TotalMemoryMb.ToString("N2");
+	public string IntervalStartLocal => TimeDisplayHelper.FormatForDisplay(IntervalStartUtc);
     public string LastExecutionLocal => LastExecutionUtc.HasValue ? TimeDisplayHelper.FormatForDisplay(LastExecutionUtc.Value) : "";
 }
diff --git a/src/PlanViewer.Core/Services/QueryStoreService.cs b/src/PlanViewer.Core/Services/QueryStoreService.cs
index 7692981..8b96fbd 100644
--- a/src/PlanViewer.Core/Services/QueryStoreService.cs
+++ b/src/PlanViewer.Core/Services/QueryStoreService.cs
@@ -432,6 +432,234 @@ JOIN sys.query_store_plan p
         return rows;
     }
 
+    /// <summary>
+    /// Fetches interval-level history rows for all queries sharing the given query_hash.
+    /// When <paramref name="startUtc"/>/<paramref name="endUtc"/> are provided they define the
+    /// time window (slicer range); otherwise falls back to <paramref name="hoursBack"/>.
+    /// </summary>
+    public static async Task<List<QueryStoreHistoryRow>> FetchHistoryByHashAsync(
+        string connectionString, string queryHash, int hoursBack = 24,
+        CancellationToken ct = default,
+        DateTime? startUtc = null, DateTime? endUtc = null)
+    {
+        var parameters = new List<SqlParameter>();
+        parameters.Add(new SqlParameter("@queryHash", queryHash.Trim()));
+
+        string timeFilter;
+        if (startUtc.HasValue && endUtc.HasValue)
+        {
+            timeFilter = "AND rsi.start_time >= @rangeStart AND rsi.start_time < @rangeEnd";
+            parameters.Add(new SqlParameter("@rangeStart", startUtc.Value));
+            parameters.Add(new SqlParameter("@rangeEnd", endUtc.Value));
+        }
+        else
+        {
+            timeFilter = "AND rsi.start_time >= DATEADD(HOUR, -@hoursBack, GETUTCDATE())";
+            parameters.Add(new SqlParameter("@hoursBack", hoursBack));
+        }
+
+        var sql = $@"
+SET TRANSACTION ISOLATION LEVEL READ UNCOMMITTED;
+
+SELECT
+    p.plan_id,
+    CONVERT(varchar(18), MAX(p.query_plan_hash), 1),
+    rsi.start_time,
+    SUM(rs.count_executions),
+    CASE WHEN SUM(rs.count_executions) > 0
+         THEN SUM(rs.avg_duration * rs.count_executions) / SUM(rs.count_executions) / 1000.0
+         ELSE 0 END,
+    CASE WHEN SUM(rs.count_executions) > 0
+         THEN SUM(rs.avg_cpu_time * rs.count_executions) / SUM(rs.count_executions) / 1000.0
+         ELSE 0 END,
+    CASE WHEN SUM(rs.count_executions) > 0
+         THEN SUM(rs.avg_logical_io_reads * rs.count_executions) / SUM(rs.count_executions)
+         ELSE 0 END,
+    CASE WHEN SUM(rs.count_executions) > 0
+         THEN SUM(rs.avg_logical_io_writes * rs.count_executions) / SUM(rs.count_executions)
+         ELSE 0 END,
+    CASE WHEN SUM(rs.count_executions) > 0
+         THEN SUM(rs.avg_physical_io_reads * rs.count_executions) / SUM(rs.count_executions)
+         ELSE 0 END,
+    CASE WHEN SUM(rs.count_executions) > 0
+         THEN SUM(rs.avg_query_max_used_memory * rs.count_executions) / SUM(rs.count_executions) * 8.0 / 1024.0
+         ELSE 0 END,
+    CASE WHEN SUM(rs.count_executions) > 0
+         THEN SUM(rs.avg_rowcount * rs.count_executions) / SUM(rs.count_executions)
+         ELSE 0 END,
+    SUM(rs.avg_duration * rs.count_executions) / 1000.0,
+    SUM(rs.avg_cpu_time * rs.count_executions) / 1000.0,
+    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),
+    MIN(rs.min_dop),
+    MAX(rs.max_dop),
+    MAX(rs.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
+JOIN sys.query_store_plan p
+    ON rs.plan_id = p.plan_id
+JOIN sys.query_store_query q
+    ON p.query_id = q.query_id
+WHERE q.query_hash = CONVERT(binary(8), @queryHash, 1)
+{timeFilter}
+GROUP BY p.plan_id, rsi.start_time
+ORDER BY rsi.start_time, p.plan_id;";
+
+        var rows = new List<QueryStoreHistoryRow>();
+
+        await using var conn = new SqlConnection(connectionString);
+        await conn.OpenAsync(ct);
+        await using var cmd = new SqlCommand(sql, conn) { CommandTimeout = 120 };
+        foreach (var p in parameters)
+            cmd.Parameters.Add(p);
+        await using var reader = await cmd.ExecuteReaderAsync(ct);
+
+        while (await reader.ReadAsync(ct))
+        {
+            rows.Add(new QueryStoreHistoryRow
+            {
+                PlanId = reader.GetInt64(0),
+                QueryPlanHash = reader.IsDBNull(1) ? "" : reader.GetString(1),
+                IntervalStartUtc = ((DateTimeOffset)reader.GetValue(2)).UtcDateTime,
+                CountExecutions = reader.GetInt64(3),
+                AvgDurationMs = reader.GetDouble(4),
+                AvgCpuMs = reader.GetDouble(5),
+                AvgLogicalReads = reader.GetDouble(6),
+                AvgLogicalWrites = reader.GetDouble(7),
+                AvgPhysicalReads = reader.GetDouble(8),
+                AvgMemoryMb = reader.GetDouble(9),
+                AvgRowcount = reader.GetDouble(10),
+                TotalDurationMs = reader.GetDouble(11),
+                TotalCpuMs = reader.GetDouble(12),
+                TotalLogicalReads = reader.GetDouble(13),
+                TotalLogicalWrites = reader.GetDouble(14),
+                TotalPhysicalReads = reader.GetDouble(15),
+                MinDop = (int)reader.GetInt64(16),
+                MaxDop = (int)reader.GetInt64(17),
+                LastExecutionUtc = reader.IsDBNull(18) ? null : ((DateTimeOffset)reader.GetValue(18)).UtcDateTime,
+            });
+        }
+
+        return rows;
+    }
+
+    /// <summary>
+    /// Fetches interval-level history rows for all queries sharing the given query_hash,
+    /// grouped by query_plan_hash and interval start.
+    /// Smart aggregation: SUM for totals/executions, weighted AVG for averages, MAX for last_execution.
+    /// When <paramref name="startUtc"/>/<paramref name="endUtc"/> are provided they define the
+    /// time window; otherwise falls back to <paramref name="hoursBack"/>.
+    /// </summary>
+    public static async Task<List<QueryStoreHistoryRow>> FetchAggregateHistoryAsync(
+        string connectionString, string queryHash, int hoursBack = 24,
+        CancellationToken ct = default,
+        DateTime? startUtc = null, DateTime? endUtc = null)
+    {
+        var parameters = new List<SqlParameter>();
+        parameters.Add(new SqlParameter("@queryHash", queryHash.Trim()));
+
+        string timeFilter;
+        if (startUtc.HasValue && endUtc.HasValue)
+        {
+            timeFilter = "AND rsi.start_time >= @rangeStart AND rsi.start_time < @rangeEnd";
+            parameters.Add(new SqlParameter("@rangeStart", startUtc.Value));
+            parameters.Add(new SqlParameter("@rangeEnd", endUtc.Value));
+        }
+        else
+        {
+            timeFilter = "AND rsi.start_time >= DATEADD(HOUR, -@hoursBack, GETUTCDATE())";
+            parameters.Add(new SqlParameter("@hoursBack", hoursBack));
+        }
+
+        var sql = $@"
+SET TRANSACTION ISOLATION LEVEL READ UNCOMMITTED;
+
+SELECT
+    CONVERT(varchar(18), p.query_plan_hash, 1),
+    rsi.start_time,
+    SUM(rs.count_executions),
+    CASE WHEN SUM(rs.count_executions) > 0
+         THEN SUM(rs.avg_duration * rs.count_executions) / SUM(rs.count_executions) / 1000.0
+         ELSE 0 END,
+    CASE WHEN SUM(rs.count_executions) > 0
+         THEN SUM(rs.avg_cpu_time * rs.count_executions) / SUM(rs.count_executions) / 1000.0
+         ELSE 0 END,
+    CASE WHEN SUM(rs.count_executions) > 0
+         THEN SUM(rs.avg_logical_io_reads * rs.count_executions) / SUM(rs.count_executions)
+         ELSE 0 END,
+    CASE WHEN SUM(rs.count_executions) > 0
+         THEN SUM(rs.avg_logical_io_writes * rs.count_executions) / SUM(rs.count_executions)
+         ELSE 0 END,
+    CASE WHEN SUM(rs.count_executions) > 0
+         THEN SUM(rs.avg_physical_io_reads * rs.count_executions) / SUM(rs.count_executions)
+         ELSE 0 END,
+    CASE WHEN SUM(rs.count_executions) > 0
+         THEN SUM(rs.avg_query_max_used_memory * rs.count_executions) / SUM(rs.count_executions) * 8.0 / 1024.0
+         ELSE 0 END,
+    CASE WHEN SUM(rs.count_executions) > 0
+         THEN SUM(rs.avg_rowcount * rs.count_executions) / SUM(rs.count_executions)
+         ELSE 0 END,
+    SUM(rs.avg_duration * rs.count_executions) / 1000.0,
+    SUM(rs.avg_cpu_time * rs.count_executions) / 1000.0,
+    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),
+    MIN(rs.min_dop),
+    MAX(rs.max_dop),
+    MAX(rs.last_execution_time),
+    SUM(rs.avg_query_max_used_memory * rs.count_executions)
+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
+JOIN sys.query_store_plan p
+    ON rs.plan_id = p.plan_id
+JOIN sys.query_store_query q
+    ON p.query_id = q.query_id
+WHERE q.query_hash = CONVERT(binary(8), @queryHash, 1)
+{timeFilter}
+GROUP BY p.query_plan_hash, rsi.start_time
+ORDER BY rsi.start_time, p.query_plan_hash;";
+
+        var rows = new List<QueryStoreHistoryRow>();
+
+        await using var conn = new SqlConnection(connectionString);
+        await conn.OpenAsync(ct);
+        await using var cmd = new SqlCommand(sql, conn) { CommandTimeout = 120 };
+        foreach (var p in parameters)
+            cmd.Parameters.Add(p);
+        await using var reader = await cmd.ExecuteReaderAsync(ct);
+
+        while (await reader.ReadAsync(ct))
+        {
+            rows.Add(new QueryStoreHistoryRow
+            {
+                QueryPlanHash = reader.IsDBNull(0) ? "" : reader.GetString(0),
+                IntervalStartUtc = ((DateTimeOffset)reader.GetValue(1)).UtcDateTime,
+                CountExecutions = reader.GetInt64(2),
+                AvgDurationMs = reader.GetDouble(3),
+                AvgCpuMs = reader.GetDouble(4),
+                AvgLogicalReads = reader.GetDouble(5),
+                AvgLogicalWrites = reader.GetDouble(6),
+                AvgPhysicalReads = reader.GetDouble(7),
+                AvgMemoryMb = reader.GetDouble(8),
+                AvgRowcount = reader.GetDouble(9),
+                TotalDurationMs = reader.GetDouble(10),
+                TotalCpuMs = reader.GetDouble(11),
+                TotalLogicalReads = reader.GetDouble(12),
+                TotalLogicalWrites = reader.GetDouble(13),
+                TotalPhysicalReads = reader.GetDouble(14),
+                MinDop = (int)reader.GetInt64(15),
+                MaxDop = (int)reader.GetInt64(16),
+                LastExecutionUtc = reader.IsDBNull(17) ? null : ((DateTimeOffset)reader.GetValue(17)).UtcDateTime,
+                TotalMemoryMb = reader.GetDouble(18),
+			});
+        }
+
+        return rows;
+    }
+
     /// <summary>
     /// Fetches hourly-aggregated metric data for the time-range slicer.
     /// Limits data to the last <paramref name="daysBack"/> days (default 30).