Stop the wait stats rows clipping their trailing benefit text

Round-1 finding V4: wait rows clipped mid-word, so "up to 27%" arrived as
"up to", and the panel grew a horizontal scrollbar to show the rest.

The row grid put the bar in the flexible column and left the wait type,
duration and benefit on Auto, so when the strip narrowed there was nothing left
to give and the whole row overflowed to the right. The flexible column is now
the duration, which is the one piece the bar beside it already conveys. The wait
type is capped at 150px and ellipsizes with the full type in its tooltip, the
bar is fixed, and the trailing "up to N%" sits in an Auto column so it is never
what gets cut. The panel's ScrollViewer no longer scrolls horizontally at all.

Every row also carries a tooltip now: the wait type says which category it fell
into, the duration spells itself out, and the benefit says what the percentage
actually means.

Colours move onto the token set. The category palette maps I/O, Lock and Network
onto WarningBrush, ErrorBrush and SuccessBrush, which already mean the same
thing elsewhere; CPU takes the panel's own InsightWaitsBrush; Memory borrows
InsightServerBrush as the one remaining token that stays distinct; and "Other",
the unclassified bucket, takes the neutral muted foreground it always meant. The
bars drop the hand-rolled alpha blend and use the category brush at 0.38
opacity, so a token change carries into them for free.

The header also loses the two leading spaces it had when populated but not when
empty, which made it jump sideways as plans loaded.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_017DEJ8FiSKJg44Ew2GG2nQ7

Author: erikdarlingdata

src/PlanViewer.App/Controls/PlanViewerControl.WaitStats.cs

@@ -27,10 +27,12 @@ private void ShowWaitStats(List<WaitStatInfo> waits, List<WaitBenefit> benefits,
                 ? "No wait stats recorded"
                 : "No wait stats (estimated plan)";
             WaitStatsEmpty.IsVisible = true;
+            SetInsightQuiet(WaitStatsHeader, WaitStatsAccent, true);
             return;
         }
 
         WaitStatsEmpty.IsVisible = false;
+        SetInsightQuiet(WaitStatsHeader, WaitStatsAccent, false);
 
         // Build benefit lookup
         var benefitLookup = new Dictionary<string, double>(StringComparer.OrdinalIgnoreCase);
@@ -41,44 +43,53 @@ private void ShowWaitStats(List<WaitStatInfo> waits, List<WaitBenefit> benefits,
         var maxWait = sorted[0].WaitTimeMs;
         var totalWait = sorted.Sum(w => w.WaitTimeMs);
 
-        // Update expander header with total
-        WaitStatsHeader.Text = $"  Wait Stats \u2014 {totalWait:N0}ms total";
+        WaitStatsHeader.Text = $"Wait Stats \u2014 {totalWait:N0}ms total";
 
-        // Build a single Grid for all rows so columns align
-        // Name, bar, duration, and benefit columns
+        /* One Grid for all rows so the columns align. Only the duration column flexes (round-1
+           finding V4): the wait type is capped and ellipsized, the bar is fixed, and the trailing
+           "up to N%" sits in an Auto column so it is never the thing that gets clipped. The panel's
+           horizontal scrolling is off, so squeezing the strip narrows the duration rather than
+           growing a sideways scrollbar. */
         var grid = new Grid
         {
-            ColumnDefinitions = new ColumnDefinitions("Auto,*,Auto,Auto")
+            ColumnDefinitions = new ColumnDefinitions("Auto,Auto,*,Auto")
         };
         for (int i = 0; i < sorted.Count; i++)
             grid.RowDefinitions.Add(new RowDefinition(GridLength.Auto));
 
+        var durationBrush = FindBrushResource("ForegroundBrush");
+        var benefitBrush = FindBrushResource("ForegroundMutedBrush");
+
         for (int i = 0; i < sorted.Count; i++)
         {
             var w = sorted[i];
             var barFraction = maxWait > 0 ? (double)w.WaitTimeMs / maxWait : 0;
-            var color = GetWaitCategoryColor(GetWaitCategory(w.WaitType));
+            var category = GetWaitCategory(w.WaitType);
+            var categoryBrush = FindBrushResource(GetWaitCategoryBrushKey(category));
 
-            // Wait type name — colored by category
+            // Wait type name, colored by category. Capped so one long type cannot widen every row.
             var nameText = new TextBlock
             {
                 Text = w.WaitType,
                 FontSize = 12,
-                Foreground = new SolidColorBrush(Color.Parse(color)),
+                Foreground = categoryBrush,
+                MaxWidth = 150,
+                TextTrimming = TextTrimming.CharacterEllipsis,
                 VerticalAlignment = VerticalAlignment.Center,
                 Margin = new Thickness(0, 2, 10, 2)
             };
+            ToolTip.SetTip(nameText, $"{w.WaitType} \u2014 {category} wait");
             Grid.SetRow(nameText, i);
             Grid.SetColumn(nameText, 0);
             grid.Children.Add(nameText);
 
-            // Bar — semi-transparent category color, compact proportional indicator
-            var barColor = Color.Parse(color);
+            // Bar: the category color at low opacity, a compact proportional indicator
             var colorBar = new Border
             {
                 Width = Math.Max(4, barFraction * 60),
                 Height = 14,
-                Background = new SolidColorBrush(Color.FromArgb(0x60, barColor.R, barColor.G, barColor.B)),
+                Background = categoryBrush,
+                Opacity = 0.38,
                 CornerRadius = new CornerRadius(2),
                 HorizontalAlignment = HorizontalAlignment.Left,
                 VerticalAlignment = VerticalAlignment.Center,
@@ -88,15 +99,17 @@ private void ShowWaitStats(List<WaitStatInfo> waits, List<WaitBenefit> benefits,
             Grid.SetColumn(colorBar, 1);
             grid.Children.Add(colorBar);
 
-            // Duration text
+            // Duration text: the flexible column, so this is what gives when the strip is narrow
             var durationText = new TextBlock
             {
                 Text = $"{w.WaitTimeMs:N0}ms ({w.WaitCount:N0} waits)",
                 FontSize = 12,
-                Foreground = new SolidColorBrush(Color.Parse("#E4E6EB")),
+                Foreground = durationBrush,
+                TextTrimming = TextTrimming.CharacterEllipsis,
                 VerticalAlignment = VerticalAlignment.Center,
                 Margin = new Thickness(0, 2, 8, 2)
             };
+            ToolTip.SetTip(durationText, $"{w.WaitTimeMs:N0} ms across {w.WaitCount:N0} waits");
             Grid.SetRow(durationText, i);
             Grid.SetColumn(durationText, 2);
             grid.Children.Add(durationText);
@@ -108,10 +121,12 @@ private void ShowWaitStats(List<WaitStatInfo> waits, List<WaitBenefit> benefits,
                 {
                     Text = $"up to {benefitPct:N0}%",
                     FontSize = 11,
-                    Foreground = new SolidColorBrush(Color.Parse("#8b949e")),
+                    Foreground = benefitBrush,
                     VerticalAlignment = VerticalAlignment.Center,
                     Margin = new Thickness(0, 2, 0, 2)
                 };
+                ToolTip.SetTip(benefitText,
+                    $"Up to {benefitPct:N0}% of this statement's runtime could be recovered by removing {w.WaitType} waits");
                 Grid.SetRow(benefitText, i);
                 Grid.SetColumn(benefitText, 3);
                 grid.Children.Add(benefitText);
@@ -149,16 +164,25 @@ private static string GetWaitCategory(string waitType)
         return "Other";
     }
 
-    private static string GetWaitCategoryColor(string category)
+    /// <summary>
+    /// The theme token each wait category is drawn in.
+    ///
+    /// <para>I/O, Lock and Network map onto the semantic tokens that already mean the same thing
+    /// elsewhere (warning, error, ok). CPU takes the Wait Stats panel's own accent. Memory has no
+    /// semantic token of its own, so it borrows the one token left that stays distinct from the
+    /// other five. "Other" is the unclassified bucket and gets the neutral muted foreground, which
+    /// is what it always meant.</para>
+    /// </summary>
+    private static string GetWaitCategoryBrushKey(string category)
     {
         return category switch
         {
-            "CPU" => "#4FA3FF",
-            "I/O" => "#FFB347",
-            "Lock" => "#E57373",
-            "Memory" => "#9B59B6",
-            "Network" => "#2ECC71",
-            _ => "#6BB5FF"
+            "CPU" => "InsightWaitsBrush",
+            "I/O" => "WarningBrush",
+            "Lock" => "ErrorBrush",
+            "Memory" => "InsightServerBrush",
+            "Network" => "SuccessBrush",
+            _ => "ForegroundMutedBrush"
         };
     }
 }