1. Auto-expand first row (ExpandRowRecursive): After populating grouped rows in FetchGroupedPlansAsync, the first root row is recursively expanded to the deepest level so the user immediately sees the full hierarchy.

2. Load child plans (LoadHighlightedPlan_Click / LoadSelected_Click / CollectLeafPlans):
• "Load Plan" on a grouped row (QueryHash, PlanHash, or Module level) now recursively collects all descendant leaf plans where both PlanId > 0 and QueryId > 0
• Rows with PlanId == 0 or QueryId == 0 are never loaded
• "Load Selected" does the same expansion for each selected row
3. Golden headers (ApplyGroupByHeaderColors):
• When GroupBy=QueryHash: "Query Hash" and "Plan Hash" column headers get gold (#FFD700) foreground
• When GroupBy=Module: "Module" and "Query Hash" column headers get gold
• When GroupBy=None: all header colors are reset to default
4. Column reorder (ReorderColumnsForGroupBy):
• QueryId and PlanId columns are now pushed after the GroupBy key columns
• QueryHash mode: Expand → Checkbox → QueryHash → PlanHash → QueryId → PlanId → rest
• Module mode: Expand → Checkbox → Module → QueryHash → QueryId → PlanId → rest
• None mode: original column order is fully restored

Author: rferraton

src/PlanViewer.App/Controls/QueryStoreGridControl.axaml

@@ -150,17 +150,19 @@
                 </ContextMenu>
             </DataGrid.ContextMenu>
             <DataGrid.Columns>
-                <DataGridTemplateColumn Header="" Width="200" IsVisible="False">
+                <DataGridTemplateColumn Header="" Width="220" IsVisible="False">
                     <DataGridTemplateColumn.CellTemplate>
                         <DataTemplate x:DataType="local:QueryStoreRow">
-                            <StackPanel Orientation="Horizontal" Margin="{Binding IndentMargin}">
+                            <StackPanel Orientation="Horizontal" Margin="{Binding IndentMargin}"
+                                        VerticalAlignment="Stretch">
                                 <Button Content="{Binding ExpandChevron}"
                                         IsVisible="{Binding HasChildren}"
-                                        Width="24" Height="22" Padding="0"
-                                        FontSize="14" FontWeight="Bold"
+                                        MinWidth="20" Padding="2,0"
+                                        FontSize="18" FontWeight="Bold"
                                         Background="Transparent" BorderThickness="0"
                                         Foreground="{DynamicResource ForegroundBrush}"
-                                        VerticalAlignment="Center"
+                                        VerticalAlignment="Stretch"
+                                        VerticalContentAlignment="Center"
                                         Click="ExpandRow_Click"/>
                                 <TextBlock Text="{Binding GroupDisplayText}"
                                            VerticalAlignment="Center"

src/PlanViewer.App/Controls/QueryStoreGridControl.axaml.cs

@@ -299,6 +299,14 @@ private async System.Threading.Tasks.Task FetchGroupedPlansAsync(
 
         LoadButton.IsEnabled = true;
         SelectToggleButton.Content = "Select All";
+
+        // Auto-expand the first root row to the deepest level
+        if (rootRows.Count > 0)
+        {
+            var first = rootRows[0];
+            ExpandRowRecursive(first);
+        }
+
         UpdateStatusText();
         UpdateBarRatios();
 
@@ -307,6 +315,29 @@ private async System.Threading.Tasks.Task FetchGroupedPlansAsync(
             _ = FetchGroupedWaitStatsAsync(_slicerStartUtc.Value, _slicerEndUtc.Value, ct);
     }
 
+    /// <summary>
+    /// Recursively expands a row and all its children, inserting them into _filteredRows.
+    /// </summary>
+    private void ExpandRowRecursive(QueryStoreRow row)
+    {
+        if (!row.HasChildren) return;
+        row.IsExpanded = true;
+
+        var idx = _filteredRows.IndexOf(row);
+        if (idx < 0) return;
+
+        var insertAt = idx + 1;
+        foreach (var child in row.Children)
+        {
+            _filteredRows.Insert(insertAt, child);
+            insertAt++;
+        }
+
+        // Recurse into each child that has children
+        foreach (var child in row.Children)
+            ExpandRowRecursive(child);
+    }
+
     /// <summary>
     /// Fetches per-plan wait stats for all real plan IDs found in the grouped hierarchy,
     /// assigns them to leaf rows, then consolidates upward to intermediate and root rows.
@@ -650,19 +681,65 @@ private void ReorderColumnsForGroupBy()
                     cols[i].DisplayIndex = _savedColumnDisplayIndices[i];
                 _savedColumnDisplayIndices = null;
             }
+            // Reset header colors
+            ApplyGroupByHeaderColors();
             return;
         }
 
         // Save original order if not yet saved
         _savedColumnDisplayIndices ??= cols.Select(c => c.DisplayIndex).ToArray();
 
-        // Find the target column to promote
-        // cols[4] = QueryHash, cols[6] = Module (from AXAML definition order)
-        var targetColIndex = _groupByMode == QueryStoreGroupBy.QueryHash ? 4 : 6;
-        var targetCol = cols[targetColIndex];
+        // Column definition indices (AXAML order):
+        //   0=Expand, 1=Checkbox, 2=QueryId, 3=PlanId, 4=QueryHash, 5=PlanHash, 6=Module
+        if (_groupByMode == QueryStoreGroupBy.QueryHash)
+        {
+            // Order: Expand, Checkbox, QueryHash, PlanHash, QueryId, PlanId, ...
+            cols[4].DisplayIndex = 2;  // QueryHash → 2
+            cols[5].DisplayIndex = 3;  // PlanHash → 3
+            cols[2].DisplayIndex = 4;  // QueryId → 4
+            cols[3].DisplayIndex = 5;  // PlanId → 5
+        }
+        else // Module
+        {
+            // Order: Expand, Checkbox, Module, QueryHash, QueryId, PlanId, ...
+            cols[6].DisplayIndex = 2;  // Module → 2
+            cols[4].DisplayIndex = 3;  // QueryHash → 3
+            cols[2].DisplayIndex = 4;  // QueryId → 4
+            cols[3].DisplayIndex = 5;  // PlanId → 5
+        }
 
-        // Move it to DisplayIndex 2 (right after expand[0] and checkbox[1])
-        targetCol.DisplayIndex = 2;
+        // Apply golden header colors for expandable columns
+        ApplyGroupByHeaderColors();
+    }
+
+    /// <summary>
+    /// Applies golden foreground to column headers that represent expandable/collapsible
+    /// grouping levels in the current GroupBy mode, and resets others.
+    /// </summary>
+    private void ApplyGroupByHeaderColors()
+    {
+        // Column definition indices: 4=QueryHash, 5=PlanHash, 6=Module
+        var goldenCols = _groupByMode switch
+        {
+            QueryStoreGroupBy.QueryHash => new HashSet<int> { 4, 5 },   // QueryHash + PlanHash
+            QueryStoreGroupBy.Module    => new HashSet<int> { 6, 4 },   // Module + QueryHash
+            _                           => new HashSet<int>(),
+        };
+
+        var goldenBrush = new SolidColorBrush(Color.FromRgb(0xFF, 0xD7, 0x00)); // Gold
+
+        for (int i = 0; i < ResultsGrid.Columns.Count; i++)
+        {
+            var col = ResultsGrid.Columns[i];
+            if (col.Header is not StackPanel sp) continue;
+            var label = sp.Children.OfType<TextBlock>().LastOrDefault();
+            if (label == null) continue;
+
+            if (goldenCols.Contains(i))
+                label.Foreground = goldenBrush;
+            else
+                label.ClearValue(TextBlock.ForegroundProperty);
+        }
     }
 
     private void ExpandRow_Click(object? sender, RoutedEventArgs e)
@@ -1006,15 +1083,57 @@ private void SelectToggle_Click(object? sender, RoutedEventArgs e)
 
     private void LoadSelected_Click(object? sender, RoutedEventArgs e)
     {
-        var selected = _filteredRows.Where(r => r.IsSelected).Select(r => r.Plan).ToList();
+        List<QueryStorePlan> selected;
+        if (_groupByMode != QueryStoreGroupBy.None)
+        {
+            // In grouped mode, expand selected grouped rows to their leaf plans
+            selected = _filteredRows
+                .Where(r => r.IsSelected)
+                .SelectMany(r => r.HasChildren ? CollectLeafPlans(r) : (r.PlanId > 0 && r.QueryId > 0 ? [r.Plan] : []))
+                .ToList();
+        }
+        else
+        {
+            selected = _filteredRows.Where(r => r.IsSelected).Select(r => r.Plan).ToList();
+        }
         if (selected.Count > 0)
             PlansSelected?.Invoke(this, selected);
     }
 
     private void LoadHighlightedPlan_Click(object? sender, RoutedEventArgs e)
     {
-        if (ResultsGrid.SelectedItem is QueryStoreRow row)
+        if (ResultsGrid.SelectedItem is not QueryStoreRow row) return;
+
+        // In grouped mode, load all descendant leaf plans with real IDs
+        if (_groupByMode != QueryStoreGroupBy.None && row.HasChildren)
+        {
+            var leafPlans = CollectLeafPlans(row);
+            if (leafPlans.Count > 0)
+                PlansSelected?.Invoke(this, leafPlans);
+        }
+        else if (row.PlanId > 0 && row.QueryId > 0)
+        {
             PlansSelected?.Invoke(this, new List<QueryStorePlan> { row.Plan });
+        }
+    }
+
+    /// <summary>
+    /// Recursively collects all leaf-level plans (PlanId > 0 and QueryId > 0) from a grouped row and its descendants.
+    /// </summary>
+    private static List<QueryStorePlan> CollectLeafPlans(QueryStoreRow row)
+    {
+        var plans = new List<QueryStorePlan>();
+        if (row.Children.Count == 0)
+        {
+            if (row.PlanId > 0 && row.QueryId > 0)
+                plans.Add(row.Plan);
+        }
+        else
+        {
+            foreach (var child in row.Children)
+                plans.AddRange(CollectLeafPlans(child));
+        }
+        return plans;
     }
 
     private async void ViewHistory_Click(object? sender, RoutedEventArgs e)